harshitsingh 0.1.0__tar.gz

harshitsingh-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: harshitsingh
+Version: 0.1.0
+Summary: Offline job-description relevance scoring against Harshit's profile.
+Author: Harshit
+License-Expression: MIT
+Keywords: profile,portfolio,resume,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# harshitsingh
+
+Harshit's profile as a small, offline job-description matcher. Give it a job description and it prints one relevance score.
+
+```powershell
+pip install harshitsingh
+harshitsingh "Backend role requiring Python, FastAPI, system design, and distributed systems"
+# 100%
+```
+
+For a longer description, save it as UTF-8 text and run:
+
+```powershell
+harshitsingh --file .\job-description.txt
+```
+
+Or pipe text to it:
+
+```powershell
+Get-Content .\job-description.txt -Raw | harshitsingh
+```
+
+Running `harshitsingh` without arguments opens a one-line prompt. The command prints only the percentage, so its output is easy to copy or use in a script.
+
+## Python API
+
+The distribution name is `harshitsingh`; the import name is `harshit_profile`.
+
+```python
+from harshit_profile import match_description
+
+result = match_description("Python backend role with FastAPI and distributed systems")
+print(result["percentage"])  # 100
+print(result["matched"])     # recognized strengths in Harshit's profile
+print(result["missing"])     # recognized requirements not in the profile
+```
+
+The matcher uses a local vocabulary of profile skills, aliases, and common engineering requirements. It counts each recognized skill once, gives explicit must-have requirements more weight, and discounts preferred skills. It makes no network calls and does not send job descriptions to an AI service. Unrecognized terms are ignored, so the score is a quick comparison aid rather than a hiring decision.
+
+The profile data is also available as `me`, `skills`, and `projects`:
+
+```python
+from harshit_profile import me, projects
+
+me.name       # "Harshit"
+[project.name for project in projects]  # includes "nazarGeo"
+```

harshitsingh-0.1.0/README.md

@@ -0,0 +1,47 @@
+# harshitsingh
+
+Harshit's profile as a small, offline job-description matcher. Give it a job description and it prints one relevance score.
+
+```powershell
+pip install harshitsingh
+harshitsingh "Backend role requiring Python, FastAPI, system design, and distributed systems"
+# 100%
+```
+
+For a longer description, save it as UTF-8 text and run:
+
+```powershell
+harshitsingh --file .\job-description.txt
+```
+
+Or pipe text to it:
+
+```powershell
+Get-Content .\job-description.txt -Raw | harshitsingh
+```
+
+Running `harshitsingh` without arguments opens a one-line prompt. The command prints only the percentage, so its output is easy to copy or use in a script.
+
+## Python API
+
+The distribution name is `harshitsingh`; the import name is `harshit_profile`.
+
+```python
+from harshit_profile import match_description
+
+result = match_description("Python backend role with FastAPI and distributed systems")
+print(result["percentage"])  # 100
+print(result["matched"])     # recognized strengths in Harshit's profile
+print(result["missing"])     # recognized requirements not in the profile
+```
+
+The matcher uses a local vocabulary of profile skills, aliases, and common engineering requirements. It counts each recognized skill once, gives explicit must-have requirements more weight, and discounts preferred skills. It makes no network calls and does not send job descriptions to an AI service. Unrecognized terms are ignored, so the score is a quick comparison aid rather than a hiring decision.
+
+The profile data is also available as `me`, `skills`, and `projects`:
+
+```python
+from harshit_profile import me, projects
+
+me.name       # "Harshit"
+[project.name for project in projects]  # includes "nazarGeo"
+```

harshitsingh-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "harshitsingh"
+version = "0.1.0"
+description = "Offline job-description relevance scoring against Harshit's profile."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{ name = "Harshit" }]
+keywords = ["profile", "portfolio", "resume", "cli"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Environment :: Console",
+]
+dependencies = []
+
+[project.scripts]
+harshitsingh = "harshit_profile.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

harshitsingh-0.1.0/setup.cfg

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

harshitsingh-0.1.0/src/harshit_profile/__init__.py

@@ -0,0 +1,29 @@
+"""Harshit's profile, importable.
+
+    >>> from harshit_profile import me, skills
+    >>> me.has("python")
+    True
+    >>> me.match(["Python", "Rust", "MongoDB"])["missing"]
+    ['Rust']
+
+Command line:  harshitsingh "paste a job description"  |  harshitsingh --file job.txt
+"""
+
+from . import blog
+from ._data import ME as _ME, PROJECTS as projects, SKILLS as skills
+from .models import Profile, Project, Skill
+
+__version__ = "0.1.0"
+
+me = Profile(
+    **{k: v for k, v in _ME.__dict__.items() if k not in ("skills", "projects")},
+    skills=tuple(skills),
+    projects=tuple(projects),
+)
+
+
+def match_description(description: str) -> dict:
+    """Return Harshit's skill match score and recognized skill details."""
+    return me.match_description(description)
+
+__all__ = ["me", "skills", "projects", "blog", "Profile", "Project", "Skill", "match_description", "__version__"]

harshitsingh-0.1.0/src/harshit_profile/__main__.py

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

harshitsingh-0.1.0/src/harshit_profile/_data.py

@@ -0,0 +1,55 @@
+"""The single source of truth for the profile. Edit this file, bump the version, republish."""
+
+from __future__ import annotations
+
+from .models import Profile, Project, Skill
+
+ME = Profile(
+    name="Harshit",
+    headline="System design, backend engineering, and applied AI for reliable production systems.",
+    employer="Aditya Birla Money Limited",
+    role="Senior Software Engineer",
+    education="VIT",
+    location="India",
+    site="https://falcon7-theta.vercel.app",  # update if you add a custom domain
+)
+
+SKILLS = [
+    Skill("C++20", "systems", "Kernel and engine work."),
+    Skill("Python", "languages", "Simulation, tooling, services."),
+    Skill("FastAPI", "backend", "Backend services for production APIs."),
+    Skill("System design", "backend", "Designing reliable, production-scale services."),
+    Skill("Backend engineering", "backend", "Services, gateways and production data systems."),
+    Skill("Distributed systems", "backend", "Reliable systems built for real-world constraints."),
+    Skill("Applied AI", "ai", "Computer vision, intelligent tools and agent systems."),
+    Skill("Computer vision", "ai", "Vision models, image analysis and spatial perception."),
+    Skill("Oracle", "data", "On-premise relational databases."),
+    Skill("SQL Server", "data", "On-premise relational databases."),
+    Skill("MongoDB", "data", "Document store for internal data flows."),
+    Skill("MCP", "ai", "Model Context Protocol servers and tools."),
+    Skill("Agent systems", "ai", "Agents as first-class objects."),
+    Skill("Execution engines", "markets", "Software-in-the-loop trading systems."),
+]
+
+PROJECTS = [
+    Project(
+        "SHAURYA",
+        "A heterogeneous software-in-the-loop execution engine for high-frequency trading.",
+        ("HFT", "SIL", "research"),
+    ),
+    Project(
+        "nazarGeo",
+        "A real-time building geolocation pipeline fusing vision, LiDAR, and IMU/GNSS.",
+        ("computer vision", "LiDAR", "geospatial"),
+    ),
+    Project(
+        "HershyOS",
+        "A 64-bit agentic operating system where agents are first-class kernel objects.",
+        ("C++20", "kernel", "agents"),
+    ),
+    Project(
+        "KYC Broker Sim",
+        "A simulation of the eKYC flow between an investor and a broker.",
+        ("Python", "eKYC"),
+    ),
+]

harshitsingh-0.1.0/src/harshit_profile/blog.py

@@ -0,0 +1,95 @@
+"""Read the published blog straight from Supabase's REST API using only the standard library.
+
+Set two environment variables (or edit the constants below before publishing):
+
+    HARSHIT_SUPABASE_URL       e.g. https://abcdxyz.supabase.co
+    HARSHIT_SUPABASE_ANON_KEY  the public anon key (safe to ship; row level security
+                               only lets it read published posts)
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from typing import List, Optional
+
+SUPABASE_URL = ""
+SUPABASE_ANON_KEY = ""
+
+
+class BlogNotConfigured(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True)
+class Post:
+    slug: str
+    title: str
+    genre: str
+    excerpt: str
+    published_at: str
+    reading_minutes: int
+    body_md: str = ""
+
+    def __str__(self) -> str:
+        return f"{self.published_at[:10]}  [{self.genre}]  {self.title}"
+
+
+def _config():
+    url = os.environ.get("HARSHIT_SUPABASE_URL") or SUPABASE_URL
+    key = os.environ.get("HARSHIT_SUPABASE_ANON_KEY") or SUPABASE_ANON_KEY
+    if not url or not key:
+        raise BlogNotConfigured(
+            "Blog is not configured. Set HARSHIT_SUPABASE_URL and HARSHIT_SUPABASE_ANON_KEY."
+        )
+    return url.rstrip("/"), key
+
+
+def _get(path: str, params: dict) -> list:
+    url, key = _config()
+    query = urllib.parse.urlencode(params, safe="(),.*")
+    req = urllib.request.Request(
+        f"{url}/rest/v1/{path}?{query}",
+        headers={"apikey": key, "Authorization": f"Bearer {key}", "Accept": "application/json"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.URLError as exc:
+        raise ConnectionError(f"Could not reach the blog: {exc}") from exc
+
+
+def _to_post(row: dict) -> Post:
+    return Post(
+        slug=row["slug"],
+        title=row["title"],
+        genre=row.get("genre", ""),
+        excerpt=row.get("excerpt", ""),
+        published_at=row.get("published_at") or "",
+        reading_minutes=row.get("reading_minutes") or 1,
+        body_md=row.get("body_md", ""),
+    )
+
+
+def posts(genre: Optional[str] = None, limit: int = 20) -> List[Post]:
+    """Latest published posts, newest first. Optionally filter by genre."""
+    params = {
+        "select": "slug,title,genre,excerpt,published_at,reading_minutes",
+        "order": "published_at.desc",
+        "limit": str(limit),
+    }
+    if genre:
+        params["genre"] = f"eq.{genre}"
+    return [_to_post(r) for r in _get("posts", params)]
+
+
+def post(slug: str) -> Post:
+    """One full post, including its Markdown body."""
+    rows = _get("posts", {"select": "*", "slug": f"eq.{slug}", "limit": "1"})
+    if not rows:
+        raise KeyError(f"No published post with slug {slug!r}")
+    return _to_post(rows[0])

harshitsingh-0.1.0/src/harshit_profile/cli.py

@@ -0,0 +1,49 @@
+"""Command line interface for scoring a job description."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__, match_description
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="harshitsingh",
+        description="Score how closely a job description matches Harshit's profile.",
+    )
+    parser.add_argument("--version", action="version", version=f"harshitsingh {__version__}")
+    parser.add_argument("description", nargs="*", help="job description text")
+    parser.add_argument("--file", "-f", help="read a long job description from a UTF-8 text file")
+    args = parser.parse_args(argv)
+
+    if args.file and args.description:
+        parser.error("pass either description text or --file, not both")
+
+    if args.file:
+        try:
+            description = Path(args.file).read_text(encoding="utf-8-sig")
+        except OSError as exc:
+            parser.error(f"cannot read {args.file!r}: {exc}")
+    elif args.description:
+        description = " ".join(args.description)
+    elif sys.stdin.isatty():
+        try:
+            description = input("Job description: ")
+        except EOFError:
+            description = ""
+    else:
+        description = sys.stdin.read()
+
+    if not description.strip():
+        parser.error("provide a job description as text, via --file, or on standard input")
+
+    result = match_description(description)
+    print(f"{result['percentage']}%")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

harshitsingh-0.1.0/src/harshit_profile/matching.py

@@ -0,0 +1,181 @@
+"""Offline job-description matching against a curated skill vocabulary."""
+
+from __future__ import annotations
+
+import re
+from typing import Dict, Iterable, List, Tuple
+
+
+# Alternate spellings and common names used in job descriptions. These aliases
+# map to a single profile skill, so mentioning several aliases never inflates
+# the score.
+PROFILE_ALIASES = {
+    "c++20": ("c++", "cpp", "c plus plus", "c++ 20"),
+    "python": ("python 3", "python3"),
+    "fastapi": ("fast api",),
+    "system design": ("systems design", "system architecture", "systems architecture", "software architecture"),
+    "backend engineering": (
+        "backend development", "back-end engineering", "back end engineering",
+        "server-side engineering", "server side development", "microservice", "microservices",
+        "api design", "api gateway", "api gateways",
+    ),
+    "distributed systems": ("distributed system", "distributed architecture"),
+    "applied ai": ("artificial intelligence", "ai"),
+    "oracle": ("oracle database",),
+    "sql server": ("microsoft sql server", "mssql"),
+    "mongodb": ("mongo db",),
+    "mcp": ("model context protocol",),
+    "agent systems": ("ai agents", "agentic systems", "multi-agent systems"),
+    "execution engines": (
+        "execution engine", "trading engine", "trading systems", "low-latency trading",
+        "low latency trading", "high-frequency trading", "hft",
+    ),
+}
+
+
+# A compact comparison vocabulary lets the score account for commonly stated
+# requirements the profile does not list. Unknown words are deliberately
+# ignored instead of being guessed as skills.
+OTHER_SKILLS = {
+    "Java": ("Java SE",),
+    "JavaScript": ("JS",),
+    "TypeScript": ("TS",),
+    "Rust": (),
+    "C#": ("C sharp",),
+    "Kotlin": (),
+    "Swift": (),
+    "Golang": ("Go language",),
+    "Bash": ("shell scripting",),
+    "Django": (),
+    "Flask": (),
+    "Spring Boot": ("Spring",),
+    "Node.js": ("NodeJS", "Node JS"),
+    "Express.js": ("ExpressJS", "Express JS"),
+    "React": ("React.js", "ReactJS"),
+    "Next.js": ("NextJS", "Next JS"),
+    ".NET": ("dotnet", "ASP.NET"),
+    "REST API": ("REST APIs", "RESTful API", "RESTful APIs"),
+    "GraphQL": (),
+    "gRPC": (),
+    "PostgreSQL": ("Postgres",),
+    "MySQL": (),
+    "Redis": (),
+    "SQLite": (),
+    "Kafka": ("Apache Kafka",),
+    "Apache Spark": ("Spark",),
+    "Docker": (),
+    "Kubernetes": ("K8s",),
+    "AWS": ("Amazon Web Services",),
+    "Azure": ("Microsoft Azure",),
+    "Google Cloud": ("GCP",),
+    "Terraform": (),
+    "Linux": (),
+    "CI/CD": ("continuous integration", "continuous delivery", "continuous deployment"),
+    "machine learning": ("ML",),
+    "deep learning": (),
+    "natural language processing": ("NLP",),
+    "large language models": ("LLM", "LLMs", "large language model"),
+    "PyTorch": (),
+    "TensorFlow": (),
+    "data engineering": (),
+    "algorithmic trading": (),
+    "market microstructure": (),
+    "FIX protocol": ("FIX",),
+}
+
+_REQUIRED_CUE = re.compile(
+    r"\b(?:required|requirements?|must(?:\s+have)?|minimum|essential|mandatory|"
+    r"proficient(?:\s+in)?|expertise|strong\s+(?:experience|knowledge|skills?)\s+(?:with|in))\b",
+    re.IGNORECASE,
+)
+_PREFERRED_CUE = re.compile(
+    r"\b(?:preferred|preferably|nice\s+to\s+have|bonus|ideally|optional|a\s+plus)\b",
+    re.IGNORECASE,
+)
+_NOT_REQUIRED_CUE = re.compile(r"\bnot\s+(?:required|necessary|essential)\b", re.IGNORECASE)
+
+
+def _phrase_pattern(phrase: str) -> re.Pattern:
+    """Compile a case-insensitive phrase matcher with word-safe boundaries."""
+    words = re.split(r"\s+", phrase.strip())
+    body = r"\s+".join(re.escape(word) for word in words if word)
+    return re.compile(r"(?<![\w])" + body + r"(?![\w])", re.IGNORECASE)
+
+
+def _importance(text: str, start: int, end: int) -> float:
+    """Weight explicit must-have language more than optional preferences."""
+    left = text[max(0, start - 96):start]
+    right = text[end:min(len(text), end + 48)]
+    context = left + " " + right
+    if _NOT_REQUIRED_CUE.search(context):
+        return 0.5
+    if _REQUIRED_CUE.search(left) or _REQUIRED_CUE.search(right):
+        return 1.5
+    if _PREFERRED_CUE.search(context):
+        return 0.5
+    return 1.0
+
+
+def _catalog(profile_skills: Iterable) -> List[Tuple[str, bool, Tuple[re.Pattern, ...]]]:
+    profile_names = {skill.name.casefold(): skill.name for skill in profile_skills}
+    aliases_by_name: Dict[str, Tuple[str, ...]] = {}
+
+    for folded_name, canonical in profile_names.items():
+        aliases = PROFILE_ALIASES.get(folded_name, ())
+        aliases_by_name[canonical] = (canonical,) + tuple(aliases)
+
+    for canonical, aliases in OTHER_SKILLS.items():
+        if canonical.casefold() not in profile_names:
+            aliases_by_name[canonical] = (canonical,) + tuple(aliases)
+
+    catalog = []
+    for canonical, aliases in aliases_by_name.items():
+        patterns = tuple(_phrase_pattern(alias) for alias in aliases)
+        catalog.append((canonical, canonical in profile_names.values(), patterns))
+    return catalog
+
+
+def match_description(description: str, profile_skills: Iterable) -> dict:
+    """Score a job description using distinct recognized skills.
+
+    The score is the weighted share of recognized skill requirements that are
+    present in the profile. Repeated mentions count once. Required skills carry
+    1.5 weight, optional/preferred ones carry 0.5, and other mentions carry 1.
+    """
+    if not isinstance(description, str):
+        raise TypeError("description must be a string")
+
+    text = description.strip()
+    if not text:
+        return {
+            "score": 0.0,
+            "percentage": 0,
+            "matched": [],
+            "missing": [],
+            "recognized": [],
+            "recognized_count": 0,
+        }
+
+    detected: Dict[str, Tuple[bool, float]] = {}
+    for canonical, is_profile_skill, patterns in _catalog(profile_skills):
+        weight = 0.0
+        for pattern in patterns:
+            for match in pattern.finditer(text):
+                weight = max(weight, _importance(text, match.start(), match.end()))
+        if weight:
+            detected[canonical] = (is_profile_skill, weight)
+
+    matched = sorted(name for name, (is_profile_skill, _) in detected.items() if is_profile_skill)
+    missing = sorted(name for name, (is_profile_skill, _) in detected.items() if not is_profile_skill)
+    total_weight = sum(weight for _, weight in detected.values())
+    matched_weight = sum(weight for is_profile_skill, weight in detected.values() if is_profile_skill)
+    score = matched_weight / total_weight if total_weight else 0.0
+
+    return {
+        "score": round(score, 4),
+        "percentage": int(round(score * 100)),
+        "matched": matched,
+        "missing": missing,
+        "recognized": sorted(detected),
+        "recognized_count": len(detected),
+    }

harshitsingh-0.1.0/src/harshit_profile/models.py

@@ -0,0 +1,86 @@
+"""Small immutable value types used across the package."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Iterable
+
+
+@dataclass(frozen=True)
+class Skill:
+    name: str
+    category: str
+    note: str = ""
+
+    def __str__(self) -> str:
+        return self.name
+
+
+@dataclass(frozen=True)
+class Project:
+    name: str
+    summary: str
+    tags: tuple = ()
+
+
+@dataclass(frozen=True)
+class Profile:
+    name: str
+    headline: str
+    employer: str
+    role: str
+    education: str
+    location: str
+    site: str
+    skills: tuple = field(default=(), compare=False)
+    projects: tuple = field(default=(), compare=False)
+
+    def has(self, skill: str) -> bool:
+        """Case-insensitive check: does Harshit list this skill?"""
+        wanted = skill.strip().lower()
+        return any(s.name.lower() == wanted for s in self.skills)
+
+    def skills_by_category(self) -> dict:
+        grouped: dict = {}
+        for s in self.skills:
+            grouped.setdefault(s.category, []).append(s.name)
+        return grouped
+
+    def match(self, needed: Iterable[str]) -> dict:
+        """Compare a list of required skills against this profile."""
+        needed = [n for n in needed]
+        have = [n for n in needed if self.has(n)]
+        missing = [n for n in needed if not self.has(n)]
+        return {"have": have, "missing": missing, "score": len(have) / len(needed) if needed else 0.0}
+
+    def match_description(self, description: str) -> dict:
+        """Score a job description against this profile's skills.
+
+        The matcher uses a local, curated vocabulary of skill names and aliases;
+        it does not send the description to an external service.
+        """
+        from .matching import match_description
+
+        return match_description(description, self.skills)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    def card(self) -> str:
+        """A plain-text card for terminals."""
+        rule = "-" * 56
+        lines = [
+            self.name,
+            self.headline,
+            rule,
+            f"{self.role}, {self.employer}",
+            f"{self.education} · {self.location}",
+            self.site,
+            rule,
+        ]
+        for category, names in self.skills_by_category().items():
+            lines.append(f"{category:<10} {', '.join(names)}")
+        lines.append(rule)
+        for p in self.projects:
+            lines.append(f"{p.name}: {p.summary}")
+        return "\n".join(lines)

harshitsingh-0.1.0/src/harshitsingh.egg-info/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: harshitsingh
+Version: 0.1.0
+Summary: Offline job-description relevance scoring against Harshit's profile.
+Author: Harshit
+License-Expression: MIT
+Keywords: profile,portfolio,resume,cli
+Classifier: Programming Language :: Python :: 3
+Classifier: Environment :: Console
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# harshitsingh
+
+Harshit's profile as a small, offline job-description matcher. Give it a job description and it prints one relevance score.
+
+```powershell
+pip install harshitsingh
+harshitsingh "Backend role requiring Python, FastAPI, system design, and distributed systems"
+# 100%
+```
+
+For a longer description, save it as UTF-8 text and run:
+
+```powershell
+harshitsingh --file .\job-description.txt
+```
+
+Or pipe text to it:
+
+```powershell
+Get-Content .\job-description.txt -Raw | harshitsingh
+```
+
+Running `harshitsingh` without arguments opens a one-line prompt. The command prints only the percentage, so its output is easy to copy or use in a script.
+
+## Python API
+
+The distribution name is `harshitsingh`; the import name is `harshit_profile`.
+
+```python
+from harshit_profile import match_description
+
+result = match_description("Python backend role with FastAPI and distributed systems")
+print(result["percentage"])  # 100
+print(result["matched"])     # recognized strengths in Harshit's profile
+print(result["missing"])     # recognized requirements not in the profile
+```
+
+The matcher uses a local vocabulary of profile skills, aliases, and common engineering requirements. It counts each recognized skill once, gives explicit must-have requirements more weight, and discounts preferred skills. It makes no network calls and does not send job descriptions to an AI service. Unrecognized terms are ignored, so the score is a quick comparison aid rather than a hiring decision.
+
+The profile data is also available as `me`, `skills`, and `projects`:
+
+```python
+from harshit_profile import me, projects
+
+me.name       # "Harshit"
+[project.name for project in projects]  # includes "nazarGeo"
+```

harshitsingh-0.1.0/src/harshitsingh.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+src/harshit_profile/__init__.py
+src/harshit_profile/__main__.py
+src/harshit_profile/_data.py
+src/harshit_profile/blog.py
+src/harshit_profile/cli.py
+src/harshit_profile/matching.py
+src/harshit_profile/models.py
+src/harshitsingh.egg-info/PKG-INFO
+src/harshitsingh.egg-info/SOURCES.txt
+src/harshitsingh.egg-info/dependency_links.txt
+src/harshitsingh.egg-info/entry_points.txt
+src/harshitsingh.egg-info/top_level.txt
+tests/test_profile.py

harshitsingh-0.1.0/src/harshitsingh.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

harshitsingh-0.1.0/src/harshitsingh.egg-info/entry_points.txt

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

harshitsingh-0.1.0/src/harshitsingh.egg-info/top_level.txt

@@ -0,0 +1 @@
+harshit_profile

harshitsingh-0.1.0/tests/test_profile.py

@@ -0,0 +1,49 @@
+import json
+import unittest
+
+import harshit_profile as hp
+from harshit_profile import blog, cli
+
+
+class ProfileTests(unittest.TestCase):
+    def test_has_is_case_insensitive(self):
+        self.assertTrue(hp.me.has("python"))
+        self.assertTrue(hp.me.has("  C++20 "))
+        self.assertFalse(hp.me.has("cobol"))
+
+    def test_match_reports_gaps(self):
+        result = hp.me.match(["Python", "Rust", "MongoDB"])
+        self.assertEqual(result["missing"], ["Rust"])
+        self.assertAlmostEqual(result["score"], 2 / 3)
+
+    def test_match_empty_is_zero(self):
+        self.assertEqual(hp.me.match([])["score"], 0.0)
+
+    def test_grouping_covers_every_skill(self):
+        grouped = hp.me.skills_by_category()
+        self.assertEqual(sum(len(v) for v in grouped.values()), len(hp.skills))
+
+    def test_json_roundtrip(self):
+        data = json.loads(json.dumps(hp.me.to_dict()))
+        self.assertEqual(data["name"], "Harshit")
+        self.assertEqual(len(data["projects"]), len(hp.projects))
+
+    def test_card_mentions_projects(self):
+        card = hp.me.card()
+        for p in hp.projects:
+            self.assertIn(p.name, card)
+
+    def test_blog_requires_config(self):
+        import os
+
+        for k in ("HARSHIT_SUPABASE_URL", "HARSHIT_SUPABASE_ANON_KEY"):
+            os.environ.pop(k, None)
+        with self.assertRaises(blog.BlogNotConfigured):
+            blog.posts()
+
+    def test_cli_default_prints_card(self):
+        self.assertEqual(cli.main([]), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()