jobty 0.1.0__tar.gz

jobty-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.3
+Name: jobty
+Version: 0.1.0
+Summary: Add your description here
+Author: El John
+Author-email: El John <bongaeljohn07@gmail.com>
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: sqlalchemy>=2.0.49
+Requires-Dist: typer>=0.24.1
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# Jobty
+
+A simple command-line application to track your job applications.
+
+This project helps you manage every job application in one place with commands for listing, adding, updating, and deleting job application entries. I originally created this project for myself to keep track of my job applications.
+
+## What this project is
+
+`jobty` is a Python CLI app built to track job applications you submit.
+It stores application details locally and provides a quick interface to:
+
+- add new job application entry
+- view all saved application entries
+- inspect a single job application entry
+- update a single job application entry
+- delete a single job application entry
+
+## Requirements
+
+- Python 3.13 or newer
+- `pydantic`
+- `questionary`
+- `typer`
+
+## How to clone and run it
+
+> [!IMPORTANT]  
+> You must already have [uv](https://docs.astral.sh/uv/) installed on your machine. If not, you can check out the documentation [here](https://docs.astral.sh/uv/getting-started/installation/).
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/eljohn316/jobty.git
+cd jobty
+```
+
+2. Create and activate a virtual environment with uv:
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+```
+
+3. Installation
+
+```bash
+uv sync
+```
+
+## Example commands
+
+- List all job applications entries:
+
+```bash
+jobty list
+```
+
+- View a single application by ID:
+
+```bash
+jobty list-one <job_id>
+```
+
+- Add a new application:
+
+```bash
+jobty add
+```
+
+- Update an existing application:
+
+```bash
+jobty update <job_id>
+```
+
+- Delete an application:
+
+```bash
+jobty delete <job_id>
+```
+
+## Notes
+
+When run, the CLI initializes the local job applications storage automatically, so you can start adding applications right away.

jobty-0.1.0/README.md

@@ -0,0 +1,84 @@
+# Jobty
+
+A simple command-line application to track your job applications.
+
+This project helps you manage every job application in one place with commands for listing, adding, updating, and deleting job application entries. I originally created this project for myself to keep track of my job applications.
+
+## What this project is
+
+`jobty` is a Python CLI app built to track job applications you submit.
+It stores application details locally and provides a quick interface to:
+
+- add new job application entry
+- view all saved application entries
+- inspect a single job application entry
+- update a single job application entry
+- delete a single job application entry
+
+## Requirements
+
+- Python 3.13 or newer
+- `pydantic`
+- `questionary`
+- `typer`
+
+## How to clone and run it
+
+> [!IMPORTANT]  
+> You must already have [uv](https://docs.astral.sh/uv/) installed on your machine. If not, you can check out the documentation [here](https://docs.astral.sh/uv/getting-started/installation/).
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/eljohn316/jobty.git
+cd jobty
+```
+
+2. Create and activate a virtual environment with uv:
+
+```bash
+uv venv .venv
+source .venv/bin/activate
+```
+
+3. Installation
+
+```bash
+uv sync
+```
+
+## Example commands
+
+- List all job applications entries:
+
+```bash
+jobty list
+```
+
+- View a single application by ID:
+
+```bash
+jobty list-one <job_id>
+```
+
+- Add a new application:
+
+```bash
+jobty add
+```
+
+- Update an existing application:
+
+```bash
+jobty update <job_id>
+```
+
+- Delete an application:
+
+```bash
+jobty delete <job_id>
+```
+
+## Notes
+
+When run, the CLI initializes the local job applications storage automatically, so you can start adding applications right away.

jobty-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "jobty"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "El John", email = "bongaeljohn07@gmail.com" }
+]
+requires-python = ">=3.13"
+dependencies = [
+    "pydantic>=2.12.5",
+    "sqlalchemy>=2.0.49",
+    "typer>=0.24.1",
+]
+
+[project.scripts]
+jobty = "jobty.main:app"
+
+[build-system]
+requires = ["uv_build>=0.9.15,<0.10.0"]
+build-backend = "uv_build"

jobty-0.1.0/src/jobty/constants.py

@@ -0,0 +1,14 @@
+from enum import Enum
+from typing import Literal
+
+
+class Colors(Enum):
+    red = "#ef4444"
+    emerald = "#34d399"
+    amber = "#fbbf24"
+    gray = "#9ca3af"
+
+
+Arrangement = Literal["Onsite", "Hybrid", "Remote"]
+
+Status = Literal["Applied", "Interview", "Hired", "Rejected"]

jobty-0.1.0/src/jobty/database.py

@@ -0,0 +1,26 @@
+from contextlib import contextmanager
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import DeclarativeBase, sessionmaker
+
+SQLALCHEMY_DATABASE_URL = "sqlite:///jobs.db"
+
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+Session = sessionmaker(bind=engine, autoflush=False)
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+@contextmanager
+def get_db_session():
+    db = Session()
+    try:
+        yield db
+    except Exception:
+        db.rollback()
+        raise
+    finally:
+        db.close()

jobty-0.1.0/src/jobty/main.py

@@ -0,0 +1,186 @@
+from datetime import datetime
+from enum import Enum
+from typing import Annotated
+
+import typer
+from typer import Argument, Option
+
+from .constants import Arrangement, Status
+from .database import Base, engine
+from .print_helpers import print_job, print_jobs
+from .schemas import JobCreate, JobDetails, JobUpdate
+from .services import create_job, delete_job, get_job, get_jobs, update_job
+from .validations import validate_model
+
+Base.metadata.create_all(bind=engine)
+
+app = typer.Typer(no_args_is_help=True)
+
+
+class FilterStatus(str, Enum):
+    applied = "Applied"
+    interview = "Interview"
+    hired = "Hired"
+    rejected = "Rejected"
+
+
+class WorkArrangement(str, Enum):
+    onsite = "Onsite"
+    hybrid = "Hybrid"
+    remote = "Remote"
+
+
+@app.command()
+def list(
+    job_id: Annotated[
+        int,
+        Argument(help="The ID of the Job to list", metavar="job_id"),
+    ] = None,
+    status: Annotated[list[FilterStatus], Option(help="Filter by status")] = [],
+    work_arrangement: Annotated[
+        list[WorkArrangement], Option(help="Filter by work arrangement")
+    ] = [],
+):
+    """List all job application entries or a single job application entry if job id is provided."""
+    if job_id:
+        job = get_job(job_id)
+        if job is None:
+            typer.echo("Job application not found")
+            return
+        job_details = JobDetails(**job.__dict__)
+        print_job(job_details)
+    else:
+        jobs = get_jobs(
+            status=[s.value for s in status],
+            work_arrangement=[w.value for w in work_arrangement],
+        )
+
+        if len(jobs) == 0:
+            typer.echo("You have no job applications yet.")
+            return
+
+        print_jobs(jobs)
+
+
+@app.command()
+def add(
+    role: Annotated[str, Option(help="Job role")],
+    company: Annotated[str, Option(help="Company name")],
+    location: Annotated[str, Option(help="Location")],
+    work_arrangement: Annotated[Arrangement, Option(help="Work arrangement")],
+    status: Annotated[Status, Option(help="Application status")] = "Applied",
+    source_link: Annotated[str | None, Option(help="Source link")] = None,
+    interview_date: Annotated[
+        datetime | None,
+        Option(
+            help="Interview date",
+            formats=["%m-%d-%Y"],
+        ),
+    ] = None,
+    interview_time: Annotated[
+        datetime | None,
+        Option(
+            help="Interview time",
+            formats=["%I:%M %p"],
+        ),
+    ] = None,
+):
+    """
+    Add job application entry.
+    """
+    job_create_model = validate_model(
+        JobCreate,
+        {
+            "role": role,
+            "company": company,
+            "location": location,
+            "work_arrangement": work_arrangement,
+            "status": status,
+            "source_link": source_link,
+            "interview_date": interview_date.date() if interview_date else None,
+            "interview_time": interview_time.time() if interview_time else None,
+        },
+    )
+    create_job(job_create_model)
+    typer.echo("Job application added")
+
+
+@app.command()
+def update(
+    job_id: Annotated[
+        int,
+        Argument(help="The ID of the Job to update", metavar="job_id"),
+    ],
+    role: Annotated[str | None, Option(help="Job role")] = None,
+    company: Annotated[str | None, Option(help="Company name")] = None,
+    location: Annotated[str | None, Option(help="Location")] = None,
+    work_arrangement: Annotated[
+        Arrangement | None, Option(help="Work arrangement")
+    ] = None,
+    status: Annotated[Status | None, Option(help="Application status")] = None,
+    source_link: Annotated[str | None, Option(help="Source link")] = None,
+    interview_date: Annotated[
+        datetime | None,
+        Option(
+            help="Interview date",
+            formats=["%m-%d-%Y"],
+        ),
+    ] = None,
+    interview_time: Annotated[
+        datetime | None,
+        Option(
+            help="Interview time",
+            formats=["%I:%M %p"],
+        ),
+    ] = None,
+):
+    """
+    Update an existing job application entry.
+    """
+    if (
+        role is None
+        and company is None
+        and location is None
+        and work_arrangement is None
+        and status is None
+        and source_link is None
+        and interview_date is None
+        and interview_time is None
+    ):
+        typer.echo("No fields to update")
+        return
+
+    job_update = JobUpdate.model_validate(
+        {
+            "role": role,
+            "company": company,
+            "location": location,
+            "work_arrangement": work_arrangement,
+            "status": status,
+            "source_link": source_link,
+            "interview_date": interview_date.date() if interview_date else None,
+            "interview_time": interview_time.time() if interview_time else None,
+        }
+    )
+
+    updated_job_id = update_job(job_id, job_update)
+    typer.echo(f"Job #{updated_job_id} updated")
+
+
+@app.command()
+def delete(
+    job_id: Annotated[
+        int,
+        Argument(help="The ID of the Job to delete", metavar="job_id"),
+    ],
+):
+    """
+    Delete an existing job application entry.
+    """
+    job = get_job(job_id)
+    if job is None:
+        typer.echo("Job application not found")
+        return
+
+    delete_job(job)
+    typer.echo(f"Job #{job_id} deleted")

jobty-0.1.0/src/jobty/models.py

@@ -0,0 +1,35 @@
+from datetime import date, datetime, time
+from typing import Literal
+
+from sqlalchemy import Date, DateTime, Integer, String, Time, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .database import Base
+
+
+class Job(Base):
+    __tablename__ = "jobs"
+
+    id: Mapped[int] = mapped_column(
+        Integer,
+        primary_key=True,
+        index=True,
+        autoincrement=True,
+    )
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime, default=lambda: datetime.now()
+    )
+    role: Mapped[str] = mapped_column(String, nullable=False)
+    company: Mapped[str] = mapped_column(String, nullable=False)
+    location: Mapped[str] = mapped_column(String, nullable=False)
+    work_arrangement: Mapped[Literal["Onsite", "Hybrid", "Remote"]] = mapped_column(
+        String, nullable=False
+    )
+    status: Mapped[Literal["Applied", "Interview", "Hired", "Rejected"]] = (
+        mapped_column(String, nullable=False)
+    )
+    source_link: Mapped[str | None] = mapped_column(String, nullable=True)
+    interview_date: Mapped[date | None] = mapped_column(Date, nullable=True)
+    interview_time: Mapped[time | None] = mapped_column(Time, nullable=True)
+
+    __table_args__ = (UniqueConstraint("role", "company", name="unq_role_company"),)

jobty-0.1.0/src/jobty/print_helpers.py

@@ -0,0 +1,97 @@
+from datetime import datetime
+from typing import Literal, Sequence, Tuple
+
+import rich
+from pydantic import ValidationError
+from rich.table import Table
+from sqlalchemy import Row
+
+from .constants import Colors
+from .schemas import JobDetails, Status
+
+JobRow = Tuple[
+    int,
+    datetime,
+    str,
+    str,
+    Literal["Applied", "Interview", "Hired", "Rejected"],
+    Literal["Onsite", "Hybrid", "Remote"],
+]
+
+
+def print_jobs(
+    jobs: Sequence[Row[JobRow]],
+):
+    table = Table(box=rich.box.SIMPLE)
+
+    table.add_column("ID", header_style=Colors.emerald.value)
+    table.add_column("Role", header_style=Colors.emerald.value)
+    table.add_column("Company", header_style=Colors.emerald.value)
+    table.add_column(
+        "Work arrangement", header_style=Colors.emerald.value, justify="center"
+    )
+    table.add_column("Status", header_style=Colors.emerald.value, justify="right")
+    table.add_column("Added on", header_style=Colors.emerald.value, justify="right")
+
+    for job_id, created_at, role, company, status, work_arrangement in jobs:
+        table.add_row(
+            f"[{Colors.gray.value}]{str(job_id)}",
+            f"[bold]{role}",
+            company,
+            work_arrangement,
+            render_status(status),
+            f"[{Colors.gray.value}]{created_at.strftime('%b %-d, %Y - %I:%M %p')}",
+        )
+
+    rich.print(table)
+
+
+def print_job(job_details_model: JobDetails):
+    job = job_details_model.model_dump(exclude_none=True)
+
+    table = Table(box=rich.box.SIMPLE, show_header=False)
+    table.add_column(style=f"bold {Colors.emerald.value}")
+    table.add_row("ID", str(job.get("id")))
+    table.add_row("Role", f"[bold]{job.get('role')}")
+    table.add_row("Company", job.get("company"))
+    table.add_row("Location", job.get("location"))
+    table.add_row("Work arrangement", job.get("work_arrangement"))
+    table.add_row("Status", render_status(job.get("status")))
+    table.add_row(
+        "Source link",
+        job.get("source_link", f"[{Colors.gray.value}]Unset"),
+    )
+    table.add_row(
+        "Interview date",
+        job.get("interview_date", f"[{Colors.gray.value}]Unset"),
+    )
+    table.add_row(
+        "Interview time",
+        job.get("interview_time", f"[{Colors.gray.value}]Unset"),
+    )
+    table.add_row(
+        "Added on",
+        job.get("created_at"),
+    )
+    rich.print(table)
+
+
+def print_validation_errors(exception: ValidationError):
+    rich.print()
+    rich.print(f"[{Colors.red.value}]Validation error")
+    for error in exception.errors():
+        field: str = error["loc"][0]
+        field = (" ".join(field.split("_"))).capitalize()
+        message = error["msg"]
+        rich.print(f"{field} - [{Colors.gray.value}]{message}")
+
+
+def render_status(status: Status):
+    if status == "Applied":
+        return f"[yellow]{status}[/]"
+    if status == "Interview":
+        return f"[cyan]{status}[/]"
+    if status == "Hired":
+        return f"[green]{status}[/]"
+    if status == "Rejected":
+        return f"[red]{status}[/]"

jobty-0.1.0/src/jobty/schemas.py

@@ -0,0 +1,62 @@
+from datetime import date, datetime, time
+
+from pydantic import BaseModel, ConfigDict, field_serializer
+
+from .constants import Arrangement, Status
+
+
+class JobBaseModel(BaseModel):
+    model_config = ConfigDict(
+        extra="ignore",
+        str_strip_whitespace=True,
+        str_min_length=1,
+        validate_default=True,
+        use_enum_values=True,
+    )
+
+
+class JobBase(JobBaseModel):
+    role: str
+    company: str
+    location: str
+    work_arrangement: Arrangement
+    status: Status
+    source_link: str | None = None
+    interview_date: date | None = None
+    interview_time: time | None = None
+
+    @field_serializer("interview_date", mode="plain")
+    def ser_interview_date(self, value: date | None):
+        if isinstance(value, date):
+            return value.strftime("%b %d, %Y")
+        return value
+
+    @field_serializer("interview_time", mode="plain")
+    def ser_interview_time(self, value: time | None):
+        if isinstance(value, time):
+            return value.strftime("%I:%M %p")
+        return value
+
+
+class JobCreate(JobBase):
+    pass
+
+
+class JobDetails(JobBase):
+    id: int
+    created_at: datetime
+
+    @field_serializer("created_at", mode="plain")
+    def ser_created_at(self, value: datetime):
+        return value.strftime("%b %-d, %Y - %I:%M %p")
+
+
+class JobUpdate(JobBaseModel):
+    role: str | None = None
+    company: str | None = None
+    location: str | None = None
+    work_arrangement: Arrangement | None
+    status: Status | None = None
+    source_link: str | None = None
+    interview_date: date | None = None
+    interview_time: time | None = None

jobty-0.1.0/src/jobty/services.py

@@ -0,0 +1,80 @@
+import typer
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
+
+from . import models
+from .database import get_db_session
+from .schemas import JobCreate, JobUpdate
+
+
+def create_job(job: JobCreate):
+    with get_db_session() as session:
+        try:
+            new_job = models.Job(
+                role=job.role,
+                company=job.company,
+                location=job.location,
+                work_arrangement=job.work_arrangement,
+                status=job.status,
+                source_link=job.source_link,
+                interview_date=job.interview_date,
+                interview_time=job.interview_time,
+            )
+            session.add(new_job)
+            session.commit()
+            session.refresh(new_job)
+            return new_job
+        except IntegrityError:
+            typer.echo("Job already exists")
+            raise typer.Exit()
+
+
+def get_job(job_id: int):
+    with get_db_session() as session:
+        query = select(models.Job).where(models.Job.id == job_id)
+        job = session.execute(query).scalars().first()
+        return job
+
+
+def get_jobs(status: list[str], work_arrangement: list[str]):
+    with get_db_session() as session:
+        query = select(
+            models.Job.id,
+            models.Job.created_at,
+            models.Job.role,
+            models.Job.company,
+            models.Job.status,
+            models.Job.work_arrangement,
+        )
+
+        if status:
+            query = query.where(models.Job.status.in_(status))
+
+        if work_arrangement:
+            query = query.where(models.Job.work_arrangement.in_(work_arrangement))
+
+        jobs = session.execute(query).all()
+        return jobs
+
+
+def delete_job(job: models.Job):
+    with get_db_session() as session:
+        session.delete(job)
+        session.commit()
+
+
+def update_job(job_id: int, job_update: JobUpdate):
+    with get_db_session() as session:
+        job = session.get(models.Job, job_id)
+        if job is None:
+            typer.echo("Job application not found")
+            raise typer.Exit()
+
+        job_payload = job_update.model_dump(exclude_none=True)
+        for field, value in job_payload.items():
+            setattr(job, field, value)
+
+        session.commit()
+        session.refresh(job)
+
+        return job.id

jobty-0.1.0/src/jobty/validations.py

@@ -0,0 +1,15 @@
+from typing import Any
+
+import typer
+from pydantic import BaseModel, ValidationError
+
+from .print_helpers import print_validation_errors
+
+
+def validate_model(model: type[BaseModel], payload: dict[str, Any]):
+    try:
+        validated_model = model.model_validate(payload)
+        return validated_model
+    except ValidationError as e:
+        print_validation_errors(e)
+        raise typer.Exit()