cctodo 0.1.0__py3-none-any.whl

cctodo/__init__.py

@@ -0,0 +1,10 @@
+"""Command line tool and Python client for ccToDo (https://www.cctodo.com/)."""
+
+__version__ = "0.1.0"
+
+from .client import DONE, IN_PROGRESS, TODO, Client, Record  # noqa: E402
+from .errors import (ApiError, CctodoError, ConfigError, Conflict, ConnectionFailed, Invalid,  # noqa: E402
+                     NotAllowed, NotFound, RateLimited, Unauthorized)
+
+__all__ = ["Client", "Record", "TODO", "IN_PROGRESS", "DONE", "CctodoError", "ApiError", "ConfigError",
+           "ConnectionFailed", "Unauthorized", "NotAllowed", "NotFound", "Invalid", "Conflict", "RateLimited"]

cctodo/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

cctodo/cli.py

@@ -0,0 +1,569 @@
+"""The `cctodo` command.
+
+    cctodo mytasks
+    cctodo new -group "work group" "my task"
+    cctodo done 123
+"""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+import webbrowser
+from datetime import datetime
+
+from . import __version__, config
+from .client import DONE, IN_PROGRESS, TODO, Client
+from .errors import CctodoError, ConfigError, Invalid, Unauthorized
+
+STATE_MARK = {TODO: "[ ]", IN_PROGRESS: "[~]", DONE: "[x]"}
+STATE_WORDS = {TODO: "to do", IN_PROGRESS: "in progress", DONE: "done"}
+
+
+# ── Output helpers ──────────────────────────────────────────────────────────
+
+class Style:
+    def __init__(self, enabled: bool):
+        self.enabled = enabled
+
+    def _wrap(self, code, text):
+        return f"\033[{code}m{text}\033[0m" if self.enabled else text
+
+    def bold(self, text):
+        return self._wrap("1", text)
+
+    def dim(self, text):
+        return self._wrap("2", text)
+
+    def orange(self, text):
+        return self._wrap("38;5;208", text)
+
+    def green(self, text):
+        return self._wrap("32", text)
+
+
+def _use_color() -> bool:
+    return sys.stdout.isatty() and not os.environ.get("NO_COLOR") and os.environ.get("TERM") != "dumb"
+
+
+def _local(ts: str | None) -> str:
+    if not ts:
+        return ""
+    try:
+        return datetime.fromisoformat(ts.replace("Z", "+00:00")).astimezone().strftime("%Y-%m-%d %H:%M")
+    except ValueError:
+        return ts
+
+
+def _who(user) -> str:
+    return (user.name or user.email) if user else ""
+
+
+class Output:
+    def __init__(self, as_json: bool):
+        self.json = as_json
+        self.s = Style(_use_color() and not as_json)
+
+    def data(self, value):
+        print(json.dumps(value, indent=2, ensure_ascii=False))
+
+    def line(self, text=""):
+        print(text)
+
+    def ok(self, text):
+        if not self.json:
+            print(self.s.green("✓ ") + text)
+
+    def task_line(self, task, group_title: str | None = None, me_id: int | None = None):
+        s = self.s
+        mark = STATE_MARK.get(task.state, "[?]")
+        if task.state == IN_PROGRESS:
+            mark = s.orange(mark)
+        extras = []
+        if task.assignee:
+            name = "me" if task.assignee.id == me_id else _who(task.assignee)
+            extras.append(f"@{name}")
+        if group_title:
+            extras.append(group_title)
+        if task.body.strip():
+            extras.append("…")
+        tail = ("  " + s.dim(" · ".join(extras))) if extras else ""
+        self.line(f"  {s.dim(f'#{task.id}'.rjust(6))}  {mark} {task.title}{tail}")
+
+    def task_list(self, title, tasks, me_id=None, groups_by_id=None, empty="Nothing to do. 🎉"):
+        if self.json:
+            return self.data(tasks)
+        self.line(self.s.bold(title) + self.s.dim(f"  ({len(tasks)})"))
+        if not tasks:
+            self.line(self.s.dim(f"  {empty}"))
+        for task in tasks:
+            group = groups_by_id.get(task.group) if groups_by_id else None
+            self.task_line(task, group.title if group else None, me_id)
+
+
+# ── Commands ────────────────────────────────────────────────────────────────
+
+def cmd_login(args, client: Client, out: Output):
+    cfg = config.load()
+    api_url = (args.api_url or config.api_url(cfg)).rstrip("/")
+    token = args.token_value
+    if not token:
+        settings_url = f"{config.web_url(api_url)}/app/settings/#tokens"
+        print(f"Create a token under Settings → API tokens:\n  {settings_url}")
+        if not args.no_browser:
+            try:
+                webbrowser.open(settings_url)
+            except webbrowser.Error:
+                pass
+        token = getpass.getpass("Paste the token: ").strip()
+    if not token:
+        raise Invalid("No token given.")
+    me = Client(token=token, api_url=api_url).me()
+    cfg.update({"token": token})
+    if api_url != config.DEFAULT_API_URL:
+        cfg["api_url"] = api_url
+    else:
+        cfg.pop("api_url", None)
+    path = config.save(cfg)
+    if out.json:
+        return out.data(me)
+    out.ok(f"Logged in as {me.email}. Token saved in {path}")
+
+
+def cmd_logout(args, client, out):
+    cfg = config.load()
+    had = cfg.pop("token", None)
+    config.save(cfg)
+    out.ok("Logged out. (Revoke the token under Settings → API tokens if you no longer need it.)" if had
+           else "You weren't logged in.")
+
+
+def cmd_whoami(args, client, out):
+    me = client.me()
+    if out.json:
+        return out.data(me)
+    out.line(f"{me.name} <{me.email}>" if me.name and me.name != me.email else me.email)
+    out.line(out.s.dim(f"API: {client.api_url}"))
+
+
+def cmd_groups(args, client, out):
+    groups = client.groups()
+    if out.json:
+        return out.data(groups)
+    for g in groups:
+        role = "" if g.is_personal else f"{g.role} · {g.member_count} member{'s' if g.member_count != 1 else ''}"
+        pending = f"{g.pending_count} pending" if g.get("pending_count") is not None else ""
+        info = " · ".join(x for x in (pending, role) if x)
+        out.line(f"  {out.s.dim(f'#{g.id}'.rjust(6))}  {out.s.bold(g.title)}  {out.s.dim(info)}")
+
+
+def _group(client, name):
+    return client.personal_group() if name is None else client.find_group(name)
+
+
+def _show_group_tasks(client, out, group, completed=False, limit=50):
+    me_id = client.me().id
+    if completed:
+        tasks = list(client.completed_tasks(group.id, limit=limit))
+        return out.task_list(f"{group.title} · completed", tasks, me_id, empty="No completed tasks yet.")
+    out.task_list(group.title, client.tasks(group.id), me_id)
+
+
+def cmd_mytasks(args, client, out):
+    _show_group_tasks(client, out, client.personal_group(), args.completed, args.limit)
+
+
+def cmd_list(args, client, out):
+    if args.all:
+        groups = client.groups()
+        if out.json:
+            return out.data({g.title: client.tasks(g.id) for g in groups})
+        for i, g in enumerate(groups):
+            if i:
+                out.line()
+            _show_group_tasks(client, out, g)
+        return
+    _show_group_tasks(client, out, _group(client, args.group), args.completed, args.limit)
+
+
+def cmd_assigned(args, client, out):
+    groups = {g.id: g for g in client.groups()}
+    out.task_list("Assigned to me", client.assigned_to_me(), client.me().id, groups)
+
+
+def _edit_text(initial: str, suffix=".md") -> str:
+    editor = os.environ.get("VISUAL") or os.environ.get("EDITOR") or ("notepad" if sys.platform == "win32" else "vi")
+    with tempfile.NamedTemporaryFile("w", suffix=suffix, delete=False, encoding="utf-8") as f:
+        f.write(initial)
+        path = f.name
+    try:
+        subprocess.run([*shlex.split(editor), path], check=True)
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    finally:
+        os.unlink(path)
+
+
+def _split_title_body(text: str) -> tuple[str, str]:
+    title, _, body = text.strip().partition("\n")
+    return title.strip(), body.strip()
+
+
+def _resolve_assignee(client, group_id, who):
+    if who is None:
+        return None
+    if who.lower() in ("me", "myself"):
+        return client.me().id
+    if who.lower() in ("none", "nobody", "-"):
+        return None
+    return client.find_member(group_id, who).id
+
+
+def cmd_new(args, client, out):
+    group = _group(client, args.group)
+    title = " ".join(args.title).strip()
+    body = args.body or ""
+    if args.body == "-":
+        body = sys.stdin.read()
+    if args.edit or not title:
+        text = _edit_text(f"{title}\n\n{body}".strip() + "\n" if title or body else "")
+        title, body = _split_title_body(text)
+    if not title:
+        raise Invalid("A task needs a title.", field="title")
+    task = client.create_task(group.id, title, body=body, assignee_id=_resolve_assignee(client, group.id, args.assign))
+    if out.json:
+        return out.data(task)
+    out.ok(f"Added #{task.id} to {group.title}: {task.title}")
+
+
+def cmd_show(args, client, out):
+    task = client.task(args.id)
+    comments = client.comments(task.id)
+    if out.json:
+        return out.data({**task, "comments": comments})
+    s = out.s
+    group = next((g for g in client.groups() if g.id == task.group), None)
+    out.line(f"{s.dim(f'#{task.id}')} {s.bold(task.title)}")
+    info = [STATE_WORDS.get(task.state, task.state), group.title if group else f"group #{task.group}"]
+    if task.assignee:
+        info.append(f"assigned to {_who(task.assignee)}")
+    out.line(s.dim(" · ".join(info)))
+    created = f"Created {_local(task.created_at)}" + (f" by {_who(task.created_by)}" if task.created_by else "")
+    if task.completed_at:
+        created += f" · completed {_local(task.completed_at)}" + (f" by {_who(task.completed_by)}" if task.completed_by else "")
+    out.line(s.dim(created))
+    if task.body.strip():
+        out.line()
+        out.line(task.body.rstrip())
+    if comments:
+        out.line()
+        out.line(s.bold(f"Comments ({sum(1 + len(c.replies) for c in comments)})"))
+        for c in comments:
+            _comment_line(out, c)
+            for r in c.replies:
+                _comment_line(out, r, indent="      ")
+
+
+def _comment_line(out, c, indent="  "):
+    s = out.s
+    text = s.dim("Comment deleted") if c.is_deleted else c.text
+    edited = " · edited" if c.edited_at else ""
+    out.line(f"{indent}{s.dim(f'#{c.id}')} {s.bold(_who(c.author) or 'someone')} {s.dim(_local(c.created_at) + edited)}")
+    out.line(f"{indent}  {text}")
+
+
+def _state_command(state, verb):
+    def run(args, client, out):
+        results = [client.set_state(task_id, state) for task_id in args.ids]
+        if out.json:
+            return out.data(results)
+        for task in results:
+            out.ok(f"{verb} #{task.id}: {task.title}")
+    return run
+
+
+def cmd_edit(args, client, out):
+    task = client.task(args.id)
+    title, body = args.title, args.body
+    if args.body == "-":
+        body = sys.stdin.read()
+    if title is None and body is None:
+        edited = _edit_text(f"{task.title}\n\n{task.body}".rstrip() + "\n")
+        title, body = _split_title_body(edited)
+        if (title, body) == (task.title, task.body.strip()):
+            return out.ok("No changes.")
+    task = client.update_task(task.id, title=title, body=body, expected_updated_at=task.updated_at)
+    if out.json:
+        return out.data(task)
+    out.ok(f"Saved #{task.id}: {task.title}")
+
+
+def cmd_assign(args, client, out):
+    task = client.task(args.id)
+    task = client.assign(task.id, _resolve_assignee(client, task.group, args.who))
+    if out.json:
+        return out.data(task)
+    out.ok(f"#{task.id} assigned to {_who(task.assignee)}" if task.assignee else f"#{task.id} is unassigned")
+
+
+def cmd_mv(args, client, out):
+    if not (args.group or args.before or args.after):
+        raise Invalid("Say where to: -g GROUP, --before ID or --after ID.")
+    task = client.task(args.id)
+    if args.group:
+        target = client.find_group(args.group)
+        if target.id != task.group:
+            task = client.move_task_to_group(task.id, target.id)
+    if args.before or args.after:
+        task = client.move_task(task.id, before_id=args.before, after_id=args.after)
+    if out.json:
+        return out.data(task)
+    out.ok(f"Moved #{task.id}: {task.title}")
+
+
+def cmd_rm(args, client, out):
+    tasks = [client.task(task_id) for task_id in args.ids]
+    if not args.yes:
+        if not sys.stdin.isatty():
+            raise Invalid("Add --yes to delete without asking.")
+        titles = "\n".join(f"  #{t.id} {t.title}" for t in tasks)
+        answer = input(f"Delete {'these tasks' if len(tasks) > 1 else 'this task'}?\n{titles}\n[y/N] ")
+        if answer.strip().lower() not in ("y", "yes"):
+            return out.line("Kept.")
+    for task in tasks:
+        client.delete_task(task.id)
+        out.ok(f"Deleted #{task.id}: {task.title}")
+
+
+def cmd_comment(args, client, out):
+    text = " ".join(args.text).strip()
+    if not text or text == "-":
+        text = sys.stdin.read().strip()
+    comment = client.add_comment(args.id, text, parent_id=args.reply_to)
+    if out.json:
+        return out.data(comment)
+    out.ok(f"Commented on #{args.id}")
+
+
+def cmd_group_new(args, client, out):
+    group = client.create_group(" ".join(args.title), icon=args.icon, color=args.color)
+    if out.json:
+        return out.data(group)
+    out.ok(f"Created group #{group.id}: {group.title}")
+
+
+def cmd_group_rename(args, client, out):
+    group = client.find_group(args.group)
+    group = client.update_group(group.id, title=" ".join(args.title))
+    if out.json:
+        return out.data(group)
+    out.ok(f"Renamed #{group.id} to {group.title}")
+
+
+def cmd_group_members(args, client, out):
+    members = client.members(client.find_group(args.group).id)
+    if out.json:
+        return out.data(members)
+    for m in members:
+        name = f"{m.user.name} <{m.user.email}>" if m.user.name and m.user.name != m.user.email else m.user.email
+        out.line(f"  {name}  {out.s.dim(m.role)}")
+
+
+def cmd_group_leave(args, client, out):
+    group = client.find_group(args.group)
+    client.leave_group(group.id)
+    out.ok(f"Left {group.title}")
+
+
+def cmd_group_rm(args, client, out):
+    group = client.find_group(args.group)
+    if not args.yes:
+        if not sys.stdin.isatty():
+            raise Invalid("Add --yes to delete without asking.")
+        answer = input(f"Delete “{group.title}” and all its tasks for everyone? [y/N] ")
+        if answer.strip().lower() not in ("y", "yes"):
+            return out.line("Kept.")
+    client.delete_group(group.id)
+    out.ok(f"Deleted {group.title}")
+
+
+def cmd_invite(args, client, out):
+    group = client.find_group(args.group)
+    invite = client.invite(group.id, args.email, args.message or "")
+    if out.json:
+        return out.data(invite)
+    if invite.status == "requested":
+        out.ok(f"Asked the owners of {group.title} to invite {invite.email}")
+    else:
+        out.ok(f"Invited {invite.email} to {group.title}")
+
+
+def cmd_invites(args, client, out):
+    invites = client.pending_invites()
+    if out.json:
+        return out.data(invites)
+    if not invites:
+        return out.line(out.s.dim("No invites."))
+    for i in invites:
+        out.line(f"  {out.s.dim(f'#{i.id}'.rjust(6))}  {out.s.bold(i.group.title)}  {out.s.dim('from ' + _who(i.invited_by))}")
+    out.line(out.s.dim("\nAccept with: cctodo accept <id>"))
+
+
+def cmd_accept(args, client, out):
+    group = client.accept_invite(args.id)
+    if out.json:
+        return out.data(group)
+    out.ok(f"Joined {group.title}")
+
+
+def cmd_decline(args, client, out):
+    client.decline_invite(args.id)
+    out.ok("Invite declined")
+
+
+# ── Parser ──────────────────────────────────────────────────────────────────
+
+def _group_option(parser, help_text="group: id, title or the start of it (default: My Tasks)"):
+    parser.add_argument("-g", "-group", "--group", dest="group", metavar="GROUP", help=help_text)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help="print raw JSON")
+    common.add_argument("--api-url", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+
+    parser = argparse.ArgumentParser(
+        prog="cctodo", parents=[common],
+        description="ccToDo from the command line. Task ids are shown as #123.",
+        epilog='Examples:\n  cctodo mytasks\n  cctodo new -group "work group" "my task"\n  cctodo done 123\n\n'
+               "Run `cctodo <command> -h` for a command's options.",
+        formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("-V", "--version", action="version", version=f"cctodo {__version__}")
+    sub = parser.add_subparsers(dest="command", metavar="<command>")
+
+    def add(name, func, help_text, aliases=()):
+        p = sub.add_parser(name, help=help_text, description=help_text, aliases=list(aliases), parents=[common])
+        p.set_defaults(func=func)
+        return p
+
+    p = add("login", cmd_login, "log in with an API token (Settings → API tokens)")
+    p.add_argument("--token", dest="token_value", help="the token (otherwise you're asked for it)")
+    p.add_argument("--no-browser", action="store_true", help="don't open the settings page")
+    add("logout", cmd_logout, "forget the saved token")
+    add("whoami", cmd_whoami, "show who you're logged in as")
+
+    add("groups", cmd_groups, "list your groups")
+    p = add("mytasks", cmd_mytasks, "list your My Tasks", aliases=["my"])
+    p.add_argument("-c", "--completed", action="store_true", help="completed tasks instead")
+    p.add_argument("-n", "--limit", type=int, default=50, help="max completed tasks to show (default 50)")
+    p = add("list", cmd_list, "list the pending tasks in a group", aliases=["ls"])
+    p.add_argument("group_pos", nargs="?", metavar="GROUP", help=argparse.SUPPRESS)
+    _group_option(p)
+    p.add_argument("-a", "--all", action="store_true", help="every group")
+    p.add_argument("-c", "--completed", action="store_true", help="completed tasks instead")
+    p.add_argument("-n", "--limit", type=int, default=50, help="max completed tasks to show (default 50)")
+    add("assigned", cmd_assigned, "list pending tasks assigned to you, in all groups")
+
+    p = add("new", cmd_new, "add a task", aliases=["add"])
+    p.add_argument("title", nargs="*", help="the task title (quotes optional)")
+    _group_option(p)
+    p.add_argument("-b", "--body", help="details (markdown); '-' reads them from stdin")
+    p.add_argument("-a", "--assign", metavar="WHO", help="assign to 'me' or a member's email")
+    p.add_argument("-e", "--edit", action="store_true", help="write title and details in $EDITOR")
+    p = add("show", cmd_show, "show a task with its details and comments")
+    p.add_argument("id", type=int)
+    for name, state, verb, text, aliases in [
+        ("done", DONE, "Completed", "mark tasks as done", ["complete", "check"]),
+        ("start", IN_PROGRESS, "Started", "mark tasks as in progress", []),
+        ("reopen", TODO, "Reopened", "mark tasks as to do again", ["todo", "uncheck"]),
+    ]:
+        p = add(name, _state_command(state, verb), text, aliases)
+        p.add_argument("ids", nargs="+", type=int, metavar="ID")
+    p = add("edit", cmd_edit, "edit a task's title or details (opens $EDITOR without options)")
+    p.add_argument("id", type=int)
+    p.add_argument("-t", "--title")
+    p.add_argument("-b", "--body", help="new details (markdown); '-' reads them from stdin")
+    p = add("assign", cmd_assign, "assign a task to 'me', a member's email, or 'none'")
+    p.add_argument("id", type=int)
+    p.add_argument("who")
+    p = add("mv", cmd_mv, "move a task to another group, or reorder it", aliases=["move"])
+    p.add_argument("id", type=int)
+    _group_option(p, "the group to move it to")
+    p.add_argument("--before", type=int, metavar="ID", help="place it just before this task")
+    p.add_argument("--after", type=int, metavar="ID", help="place it just after this task")
+    p = add("rm", cmd_rm, "delete tasks", aliases=["delete"])
+    p.add_argument("ids", nargs="+", type=int, metavar="ID")
+    p.add_argument("-y", "--yes", action="store_true", help="don't ask")
+    p = add("comment", cmd_comment, "comment on a task")
+    p.add_argument("id", type=int)
+    p.add_argument("text", nargs="*", help="the comment ('-' or nothing reads stdin)")
+    p.add_argument("-r", "--reply-to", type=int, metavar="COMMENT_ID")
+
+    p = add("group", None, "create, rename, leave or delete groups; list members")
+    gsub = p.add_subparsers(dest="group_command", metavar="<action>", required=True)
+
+    def gadd(name, func, help_text):
+        gp = gsub.add_parser(name, help=help_text, description=help_text, parents=[common])
+        gp.set_defaults(func=func)
+        return gp
+
+    gp = gadd("new", cmd_group_new, "create a group (you become its owner)")
+    gp.add_argument("title", nargs="+")
+    gp.add_argument("--icon", help="a Lucide icon name, e.g. briefcase")
+    gp.add_argument("--color", help="e.g. orange, blue, teal")
+    gp = gadd("rename", cmd_group_rename, "rename a group")
+    gp.add_argument("group")
+    gp.add_argument("title", nargs="+")
+    gp = gadd("members", cmd_group_members, "list a group's members")
+    gp.add_argument("group")
+    gp = gadd("leave", cmd_group_leave, "leave a group")
+    gp.add_argument("group")
+    gp = gadd("rm", cmd_group_rm, "delete a group and its tasks (owners)")
+    gp.add_argument("group")
+    gp.add_argument("-y", "--yes", action="store_true", help="don't ask")
+
+    p = add("invite", cmd_invite, "invite someone to a group by email")
+    p.add_argument("group")
+    p.add_argument("email")
+    p.add_argument("-m", "--message", help="a personal message for the invite email")
+    add("invites", cmd_invites, "list invites addressed to you")
+    p = add("accept", cmd_accept, "accept an invite")
+    p.add_argument("id", type=int)
+    p = add("decline", cmd_decline, "decline an invite")
+    p.add_argument("id", type=int)
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if not getattr(args, "func", None):
+        parser.print_help()
+        return 0
+    if getattr(args, "group_pos", None) and not args.group:
+        args.group = args.group_pos
+    args.json = getattr(args, "json", False)
+    args.api_url = getattr(args, "api_url", None)
+    out = Output(args.json)
+    try:
+        client = Client(api_url=args.api_url) if args.func is not cmd_login else None
+        args.func(args, client, out)
+    except KeyboardInterrupt:
+        print(file=sys.stderr)
+        return 130
+    except (Unauthorized, ConfigError) as e:  # exit 3: log in first
+        print(f"cctodo: {e}", file=sys.stderr)
+        return 3
+    except CctodoError as e:
+        print(f"cctodo: {e}", file=sys.stderr)
+        return 1
+    except subprocess.CalledProcessError as e:
+        print(f"cctodo: the editor exited with status {e.returncode}; nothing saved.", file=sys.stderr)
+        return 1
+    return 0

cctodo/client.py

@@ -0,0 +1,315 @@
+"""A small client for the ccToDo REST API (https://api.cctodo.com/v1/).
+
+    from cctodo import Client
+
+    todo = Client()                      # token from $CCTODO_TOKEN or `cctodo login`
+    work = todo.find_group("work")
+    task = todo.create_task(work.id, "Write the report")
+    todo.complete(task.id)
+
+Results are :class:`Record` objects: plain dicts that also allow attribute access
+(``task.title`` as well as ``task["title"]``), exactly as the API returns them.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, Iterator
+
+from . import __version__, config
+from .errors import BY_STATUS, ApiError, ConfigError, ConnectionFailed, Invalid, NotFound
+
+TODO, IN_PROGRESS, DONE = "todo", "in_progress", "done"
+PERSONAL_ALIASES = {"my tasks", "mytasks", "my", "me", "personal"}
+
+
+class Record(dict):
+    """A dict with attribute access; nested dicts and lists are converted too."""
+
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name) from None
+
+    @classmethod
+    def wrap(cls, value):
+        if isinstance(value, dict):
+            return cls({k: cls.wrap(v) for k, v in value.items()})
+        if isinstance(value, list):
+            return [cls.wrap(v) for v in value]
+        return value
+
+
+class Client:
+    def __init__(self, token: str | None = None, api_url: str | None = None, timeout: float = 30):
+        cfg = config.load() if token is None or api_url is None else {}
+        self.token = token or config.token(cfg)
+        self.api_url = (api_url or config.api_url(cfg)).rstrip("/")
+        self.timeout = timeout
+        self._me = None
+
+    # ── Transport ───────────────────────────────────────────────────────────
+
+    def request(self, method: str, path: str, data: dict | None = None, params: dict | None = None) -> Any:
+        """Calls ``/v1/<path>`` and returns the decoded JSON (None for 204)."""
+        if not self.token:
+            raise ConfigError("No API token. Run `cctodo login`, or set CCTODO_TOKEN.")
+        url = f"{self.api_url}/v1/{path.lstrip('/')}"
+        if params:
+            url += "?" + urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
+        body = json.dumps(data).encode() if data is not None else None
+        req = urllib.request.Request(url, data=body, method=method, headers={
+            "Authorization": f"Bearer {self.token}",
+            "Accept": "application/json",
+            "User-Agent": f"cctodo-python/{__version__}",
+            **({"Content-Type": "application/json"} if body is not None else {}),
+        })
+        try:
+            with self._open(req) as resp:
+                raw = resp.read()
+        except urllib.error.HTTPError as e:
+            raise self._error(e.code, e.read()) from None
+        except (urllib.error.URLError, OSError) as e:
+            reason = getattr(e, "reason", e)
+            raise ConnectionFailed(f"Can't reach {self.api_url}: {reason}") from None
+        return Record.wrap(json.loads(raw)) if raw else None
+
+    def _open(self, req):  # replaced in tests
+        return urllib.request.urlopen(req, timeout=self.timeout)
+
+    @staticmethod
+    def _error(status: int, raw: bytes) -> ApiError:
+        try:
+            payload = json.loads(raw)
+        except ValueError:
+            payload = {}
+        if not isinstance(payload, dict):
+            payload = {}
+        message = payload.get("message") or payload.get("detail") or f"HTTP {status}"
+        if status == 401:
+            message = "Not logged in, or the token was revoked. Run `cctodo login`."
+        cls = BY_STATUS.get(status, ApiError)
+        return cls(message, status=status, code=payload.get("error", ""), field=payload.get("field"))
+
+    def _get(self, path, **params):
+        return self.request("GET", path, params=params or None)
+
+    def _post(self, path, data=None):
+        return self.request("POST", path, data if data is not None else {})
+
+    def _patch(self, path, data):
+        return self.request("PATCH", path, data)
+
+    def _delete(self, path):
+        return self.request("DELETE", path)
+
+    # ── Me ──────────────────────────────────────────────────────────────────
+
+    def me(self) -> Record:
+        """You: id, email, name, personal_group_id (your My Tasks)."""
+        if self._me is None:
+            self._me = self._get("me/")
+        return self._me
+
+    def notification_settings(self) -> Record:
+        return self._get("me/notifications/")
+
+    def update_notification_settings(self, **flags: bool) -> Record:
+        return self._patch("me/notifications/", flags)
+
+    # ── Groups ──────────────────────────────────────────────────────────────
+
+    def groups(self) -> list[Record]:
+        """Your groups, My Tasks first, each with role, member_count and pending_count."""
+        return self._get("groups/")
+
+    def group(self, group_id: int) -> Record:
+        return self._get(f"groups/{group_id}/")
+
+    def personal_group(self) -> Record:
+        """Your private My Tasks group (even if you renamed it)."""
+        return self.group(self.me().personal_group_id)
+
+    def find_group(self, name: str | int) -> Record:
+        """A group by id, exact title, or unique title prefix (case-insensitive).
+        "My Tasks", "mytasks" and "me" also find your personal group."""
+        groups = self.groups()
+        text = str(name).strip()
+        if text.isdigit():
+            for g in groups:
+                if g.id == int(text):
+                    return g
+        folded = text.casefold()
+        exact = [g for g in groups if g.title.casefold() == folded]
+        if len(exact) == 1:
+            return exact[0]
+        if not exact and folded in PERSONAL_ALIASES:
+            return next(g for g in groups if g.is_personal)
+        candidates = exact or [g for g in groups if g.title.casefold().startswith(folded)]
+        if len(candidates) == 1:
+            return candidates[0]
+        if not candidates:
+            raise NotFound(f"No group matches “{text}”.")
+        titles = ", ".join(f"{g.title} (#{g.id})" for g in candidates)
+        raise Invalid(f"“{text}” matches several groups: {titles}. Use the id.", field="group")
+
+    def create_group(self, title: str, icon: str | None = None, color: str | None = None) -> Record:
+        data = {"title": title}
+        if icon:
+            data["icon"] = icon
+        if color:
+            data["color"] = color
+        return self._post("groups/", data)
+
+    def update_group(self, group_id: int, *, title=None, icon=None, color=None) -> Record:
+        data = {k: v for k, v in {"title": title, "icon": icon, "color": color}.items() if v is not None}
+        return self._patch(f"groups/{group_id}/", data)
+
+    def delete_group(self, group_id: int) -> None:
+        self._delete(f"groups/{group_id}/")
+
+    def leave_group(self, group_id: int) -> None:
+        self._post(f"groups/{group_id}/leave/")
+
+    def members(self, group_id: int) -> list[Record]:
+        return self._get(f"groups/{group_id}/members/")
+
+    def set_role(self, group_id: int, user_id: int, role: str) -> Record:
+        """role: "owner" or "member" (owners only)."""
+        return self._patch(f"groups/{group_id}/members/{user_id}/", {"role": role})
+
+    def remove_member(self, group_id: int, user_id: int) -> None:
+        self._delete(f"groups/{group_id}/members/{user_id}/")
+
+    def icons(self) -> Record:
+        """Allowed group icons and colours."""
+        return self._get("meta/icons/")
+
+    # ── Invites ─────────────────────────────────────────────────────────────
+
+    def invite(self, group_id: int, email: str, message: str = "") -> Record:
+        """Owners' invites are sent at once (status "pending"); a member's waits for an owner ("requested")."""
+        return self._post(f"groups/{group_id}/invites/", {"email": email, "message": message})
+
+    def group_invites(self, group_id: int) -> list[Record]:
+        return self._get(f"groups/{group_id}/invites/")
+
+    def pending_invites(self) -> list[Record]:
+        """Invites to groups, addressed to you."""
+        return self._get("invites/pending/")
+
+    def accept_invite(self, invite_id: int) -> Record:
+        return self._post(f"invites/{invite_id}/accept/")
+
+    def decline_invite(self, invite_id: int) -> None:
+        self._post(f"invites/{invite_id}/decline/")
+
+    def revoke_invite(self, invite_id: int) -> None:
+        self._delete(f"invites/{invite_id}/")
+
+    # ── Tasks ───────────────────────────────────────────────────────────────
+
+    def tasks(self, group_id: int) -> list[Record]:
+        """Pending tasks (to do and in progress) in their manual order."""
+        return self._get(f"groups/{group_id}/tasks/").results
+
+    def completed_tasks(self, group_id: int, limit: int | None = None) -> Iterator[Record]:
+        """Completed tasks, newest first (fetched page by page)."""
+        page, count = 1, 0
+        while page:
+            data = self._get(f"groups/{group_id}/tasks/", view="completed", page=page)
+            for task in data.results:
+                if limit is not None and count >= limit:
+                    return
+                count += 1
+                yield task
+            page = data.next_page
+
+    def assigned_to_me(self) -> list[Record]:
+        """Pending tasks assigned to you, across all groups."""
+        return self._get("tasks/assigned-to-me/").results
+
+    def task(self, task_id: int) -> Record:
+        return self._get(f"tasks/{task_id}/")
+
+    def create_task(self, group_id: int, title: str, body: str = "", assignee_id: int | None = None) -> Record:
+        """New tasks go to the bottom of the list. ``body`` is markdown."""
+        data = {"title": title, "body": body}
+        if assignee_id is not None:
+            data["assignee_id"] = assignee_id
+        return self._post(f"groups/{group_id}/tasks/", data)
+
+    def update_task(self, task_id: int, *, title: str | None = None, body: str | None = None,
+                    expected_updated_at: str | None = None) -> Record:
+        """Pass the ``updated_at`` you loaded as ``expected_updated_at`` to get
+        :class:`~cctodo.errors.Conflict` instead of overwriting someone else's edit."""
+        data = {k: v for k, v in {"title": title, "body": body,
+                                  "expected_updated_at": expected_updated_at}.items() if v is not None}
+        return self._patch(f"tasks/{task_id}/", data)
+
+    def set_state(self, task_id: int, state: str) -> Record:
+        """state: "todo", "in_progress" or "done"."""
+        return self._patch(f"tasks/{task_id}/", {"state": state})
+
+    def complete(self, task_id: int) -> Record:
+        return self.set_state(task_id, DONE)
+
+    def start(self, task_id: int) -> Record:
+        return self.set_state(task_id, IN_PROGRESS)
+
+    def reopen(self, task_id: int) -> Record:
+        return self.set_state(task_id, TODO)
+
+    def assign(self, task_id: int, user_id: int | None) -> Record:
+        """Assign to a member of the task's group, or None to unassign."""
+        return self._patch(f"tasks/{task_id}/", {"assignee_id": user_id})
+
+    def move_task(self, task_id: int, *, before_id: int | None = None, after_id: int | None = None) -> Record:
+        """Reorder: place the task just before or just after another pending task."""
+        return self._post(f"tasks/{task_id}/move/", {"before_id": before_id, "after_id": after_id})
+
+    def move_task_to_group(self, task_id: int, group_id: int) -> Record:
+        """Moves the task to the bottom of another group (clears the assignee if they aren't a member there)."""
+        return self._post(f"tasks/{task_id}/move-group/", {"group_id": group_id})
+
+    def delete_task(self, task_id: int) -> None:
+        self._delete(f"tasks/{task_id}/")
+
+    # ── Comments ────────────────────────────────────────────────────────────
+
+    def comments(self, task_id: int) -> list[Record]:
+        """Top-level comments, oldest first, each with its ``replies``."""
+        return self._get(f"tasks/{task_id}/comments/")
+
+    def add_comment(self, task_id: int, text: str, parent_id: int | None = None) -> Record:
+        data = {"text": text}
+        if parent_id:
+            data["parent_id"] = parent_id
+        return self._post(f"tasks/{task_id}/comments/", data)
+
+    def edit_comment(self, comment_id: int, text: str) -> Record:
+        return self._patch(f"comments/{comment_id}/", {"text": text})
+
+    def delete_comment(self, comment_id: int) -> None:
+        self._delete(f"comments/{comment_id}/")
+
+    # ── Helpers ─────────────────────────────────────────────────────────────
+
+    def find_member(self, group_id: int, who: str) -> Record:
+        """A member of the group by email (or unique email/name prefix)."""
+        members = [m.user for m in self.members(group_id)]
+        folded = who.strip().casefold()
+        exact = [u for u in members if u.email.casefold() == folded]
+        if exact:
+            return exact[0]
+        candidates = [u for u in members if u.email.casefold().startswith(folded)
+                      or (u.name or "").casefold().startswith(folded)]
+        if len(candidates) == 1:
+            return candidates[0]
+        if not candidates:
+            raise NotFound(f"No member of this group matches “{who}”.")
+        raise Invalid(f"“{who}” matches several members: {', '.join(u.email for u in candidates)}.", field="assignee")

cctodo/config.py

@@ -0,0 +1,64 @@
+"""Where the token lives: $CCTODO_TOKEN, or the config file written by `cctodo login`."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+
+DEFAULT_API_URL = "https://api.cctodo.com"
+DEFAULT_WEB_URL = "https://www.cctodo.com"
+
+
+def config_path() -> Path:
+    if os.environ.get("CCTODO_CONFIG"):
+        return Path(os.environ["CCTODO_CONFIG"]).expanduser()
+    if sys.platform == "win32" and os.environ.get("APPDATA"):
+        base = Path(os.environ["APPDATA"])
+    else:
+        base = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config")
+    return base / "cctodo" / "config.json"
+
+
+def load() -> dict:
+    path = config_path()
+    try:
+        with path.open(encoding="utf-8") as f:
+            data = json.load(f)
+    except FileNotFoundError:
+        return {}
+    except (OSError, ValueError) as e:
+        from .errors import ConfigError
+        raise ConfigError(f"Can't read {path}: {e}") from e
+    return data if isinstance(data, dict) else {}
+
+
+def save(data: dict) -> Path:
+    """Writes the config readable by the current user only."""
+    path = config_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w", encoding="utf-8") as f:
+        json.dump(data, f, indent=2)
+        f.write("\n")
+    os.replace(tmp, path)
+    return path
+
+
+def api_url(config: dict | None = None) -> str:
+    config = load() if config is None else config
+    return (os.environ.get("CCTODO_API_URL") or config.get("api_url") or DEFAULT_API_URL).rstrip("/")
+
+
+def web_url(api: str) -> str:
+    """The website that belongs to an API URL (api.cctodo.com → www.cctodo.com)."""
+    if api.rstrip("/") == DEFAULT_API_URL:
+        return DEFAULT_WEB_URL
+    return api.replace("://api.", "://", 1)  # e.g. http://api.localhost:8000 → http://localhost:8000
+
+
+def token(config: dict | None = None) -> str | None:
+    config = load() if config is None else config
+    return os.environ.get("CCTODO_TOKEN") or config.get("token")

cctodo/errors.py

@@ -0,0 +1,63 @@
+"""Errors raised by :class:`cctodo.Client`.
+
+The API answers errors as ``{"error": code, "message": text, "field": name}``;
+each HTTP status maps to one exception class.
+"""
+
+from __future__ import annotations
+
+
+class CctodoError(Exception):
+    """Base class for everything this package raises."""
+
+
+class ConfigError(CctodoError):
+    """No token configured, or a broken config file."""
+
+
+class ConnectionFailed(CctodoError):
+    """The API couldn't be reached."""
+
+
+class ApiError(CctodoError):
+    status = 0
+
+    def __init__(self, message: str, *, status: int = 0, code: str = "", field: str | None = None):
+        super().__init__(message)
+        self.message = message
+        self.status = status or self.status
+        self.code = code
+        self.field = field
+
+
+class Unauthorized(ApiError):
+    """401: missing, invalid or revoked token."""
+    status = 401
+
+
+class NotAllowed(ApiError):
+    """403: you're a member, but not allowed to do this (e.g. owners only)."""
+    status = 403
+
+
+class NotFound(ApiError):
+    """404: doesn't exist, or you're not a member of its group."""
+    status = 404
+
+
+class Invalid(ApiError):
+    """400: bad input. ``field`` names the offending field when known."""
+    status = 400
+
+
+class Conflict(ApiError):
+    """409: e.g. the task was changed by someone else since you loaded it."""
+    status = 409
+
+
+class RateLimited(ApiError):
+    """429: too many requests (invites, comments, ...). Try again later."""
+    status = 429
+
+
+BY_STATUS = {cls.status: cls for cls in (Unauthorized, NotAllowed, NotFound, Invalid, Conflict, RateLimited)}

cctodo-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: cctodo
+Version: 0.1.0
+Summary: Command line tool and Python client for ccToDo (www.cctodo.com)
+Author-email: CloudCircus <support@cctodo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://www.cctodo.com/
+Project-URL: Source, https://github.com/RubenNorgaard/cctodo_py
+Keywords: todo,tasks,cli,cctodo
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Scheduling
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# cctodo
+
+The command line tool and Python client for [ccToDo](https://www.cctodo.com/), made by CloudCircus.
+
+```sh
+pip install cctodo
+cctodo login          # paste a token from Settings → API tokens
+cctodo mytasks
+cctodo new -group "work group" "my task"
+cctodo done 123
+```
+
+It uses only the Python standard library and needs Python 3.9 or newer.
+
+## Commands
+
+Tasks are shown with their id (`#123`), and the commands take that id. Where a command takes a group,
+you can give its id, its title, or the start of the title (case-insensitive). Without `-g`, commands
+use your **My Tasks**.
+
+| Command | What it does |
+|---|---|
+| `cctodo mytasks` (`my`) | Your pending My Tasks. `-c` shows completed tasks instead. |
+| `cctodo list [GROUP]` (`ls`) | A group's pending tasks. `--all` lists every group, `-c` shows completed tasks. |
+| `cctodo assigned` | Pending tasks assigned to you, in all groups. |
+| `cctodo groups` | Your groups, with their pending counts. |
+| `cctodo new TITLE… [-g GROUP] [-a WHO] [-b BODY] [-e]` (`add`) | Adds a task at the bottom of the list. `-b -` reads the details from stdin; `-e` writes the title and details in `$EDITOR`. |
+| `cctodo show ID` | A task with its details (markdown) and comments. |
+| `cctodo done ID…` / `start ID…` / `reopen ID…` | Sets the state to done, in progress, or to do. |
+| `cctodo edit ID [-t TITLE] [-b BODY]` | Edits a task. With no options it opens `$EDITOR`: the first line is the title and the rest is the details. It refuses to overwrite someone else's newer edit. |
+| `cctodo assign ID WHO` | Assigns to `me`, a member's email, or `none`. |
+| `cctodo mv ID -g GROUP` / `mv ID --before ID2` / `--after ID2` | Moves a task to another group, or reorders it. |
+| `cctodo rm ID… [-y]` | Deletes tasks after asking you to confirm. |
+| `cctodo comment ID TEXT… [-r COMMENT_ID]` | Adds a comment, or a reply with `-r`. |
+| `cctodo group new/rename/members/leave/rm` | Manages groups. |
+| `cctodo invite GROUP EMAIL [-m MESSAGE]` | Invites someone. If you're a member rather than an owner, an owner approves the invite first. |
+| `cctodo invites` / `accept ID` / `decline ID` | Lists and answers invites addressed to you. |
+| `cctodo whoami` / `logout` | Shows the account you're logged in as, or forgets the saved token. |
+
+Add `--json` to any command for the raw API output. `NO_COLOR` turns colours off.
+
+**Exit codes:**
+- `0`: the command succeeded.
+- `1`: an error occurred.
+- `3`: you're not logged in, or your token was revoked.
+
+## Configuration
+
+`cctodo login` saves the token in `~/.config/cctodo/config.json`, readable only by you
+(`%APPDATA%\cctodo\config.json` on Windows). You can set these environment variables instead:
+
+- `CCTODO_TOKEN`: the API token.
+- `CCTODO_API_URL`: the API address. It defaults to `https://api.cctodo.com`.
+- `CCTODO_CONFIG`: a different config file.
+
+To revoke a token, go to Settings → API tokens on www.cctodo.com.
+
+## Python
+
+```python
+from cctodo import Client, Conflict
+
+todo = Client()                                  # the same token as the CLI (or Client(token="cct_..."))
+work = todo.find_group("work group")
+task = todo.create_task(work.id, "Write the report", body="Due **Friday**")
+todo.assign(task.id, todo.me().id)
+todo.start(task.id)
+
+for t in todo.tasks(work.id):                    # pending tasks, in order
+    print(t.id, t.state, t.title)                # attribute or t["title"] access
+
+try:
+    todo.update_task(task.id, body="…", expected_updated_at=task.updated_at)
+except Conflict:
+    print("Someone else changed it first")
+```
+
+**Return values:** results are the API's JSON as `Record` objects (dicts with attribute access).
+
+**Errors:** errors raise `cctodo.NotFound` (404; this also covers groups you're not in), `NotAllowed` (403),
+`Invalid` (400), `Conflict` (409), `RateLimited` (429) or `Unauthorized` (401). All of them subclass `cctodo.CctodoError`.
+
+## Development
+
+```sh
+pip install -e .
+python -m unittest discover -s . -t .
+CCTODO_API_URL=http://api.localhost:8000 cctodo whoami      # against a local cctodo_web
+```
+
+## Licence
+
+MIT. See [LICENSE](LICENSE).

cctodo-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+cctodo/__init__.py,sha256=HPYPsUBqlu48vj5xm3CwPYijrvApbNW4lQ4h6huKlP4,572
+cctodo/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+cctodo/cli.py,sha256=PQ2_vb6DPSXWsuJFDXhT_aC_zz494A5xQhAbu6rnpHM,22440
+cctodo/client.py,sha256=gqvwqv4oEN0-hoUEAREM3fJ0xQ0sdvMNqwlTIiBguCk,14361
+cctodo/config.py,sha256=xcgVziIf-WAeJLX6ezyRj_tWhhjL5jBV3vP5sX2zZiA,2110
+cctodo/errors.py,sha256=ocuodQH29r7CKiMznIats16T0tBehxF2NY125kvC2fE,1589
+cctodo-0.1.0.dist-info/licenses/LICENSE,sha256=G24HdYmI4MWIlEUuVqBPItNa01TMjAtlv-e_X0ia7Tc,1068
+cctodo-0.1.0.dist-info/METADATA,sha256=a3BCG6yOqnM8xJafI_WeubuC4pzsw3Y0pIPnzEesSuU,4694
+cctodo-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+cctodo-0.1.0.dist-info/entry_points.txt,sha256=OKSTAxNQEciOtSDur1cKE9rqGWoU56KUBkmjUEYtLj4,43
+cctodo-0.1.0.dist-info/top_level.txt,sha256=6-z-8fTElOm8V6gkwktlo5c64GG1R5t1Fd89kTaobWU,7
+cctodo-0.1.0.dist-info/RECORD,,

cctodo-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cctodo-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cctodo = cctodo.cli:main

cctodo-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CloudCircus
+
+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.

cctodo-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cctodo