career-emulator-engine 1.0.1__tar.gz

career_emulator_engine-1.0.1/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: career_emulator_engine
+Version: 1.0.1
+Summary: TechArena English track: career simulation engine (CLI + MCP). PyPI: career-emulator-engine.
+Author-email: Yuwei <yuwei.willow.z@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/RAI-Internal/techarena-career-sim
+Project-URL: Documentation, https://career-emulator.readthedocs.io
+Project-URL: Source, https://github.com/RAI-Internal/career-emulator-engine
+Project-URL: Issues, https://github.com/RAI-Internal/techarena-career-sim/issues
+Keywords: python,career-sim,simulation,agent,llm,techarena,competition,mcp client,client,mcp,fastmcp,mcp server,model context protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: msgpack>=1.0.0
+Requires-Dist: aiosqlite>=0.22.1
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: career-emulator-techarena==1.0.*
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2; extra == "mcp"
+
+# career-emulator-engine
+
+English **TechArena** simulation engine (CLI + MCP).  
+Separate from [`career-emulator`](https://pypi.org/project/career-emulator/) (BDCI / Chinese) and from the dataset [`career-emulator-techarena`](https://pypi.org/project/career-emulator-techarena/).
+
+## Install
+
+```bash
+pip install "career-emulator-engine[mcp]"
+```
+
+## Quick use
+
+```bash
+career-emulator-engine update --source distribution --split dev
+career-emulator-engine play
+career-emulator-engine-mcp --help
+```
+
+Participant starter: [techarena-career-sim](https://github.com/RAI-Internal/techarena-career-sim)

career_emulator_engine-1.0.1/README.md

@@ -0,0 +1,20 @@
+# career-emulator-engine
+
+English **TechArena** simulation engine (CLI + MCP).  
+Separate from [`career-emulator`](https://pypi.org/project/career-emulator/) (BDCI / Chinese) and from the dataset [`career-emulator-techarena`](https://pypi.org/project/career-emulator-techarena/).
+
+## Install
+
+```bash
+pip install "career-emulator-engine[mcp]"
+```
+
+## Quick use
+
+```bash
+career-emulator-engine update --source distribution --split dev
+career-emulator-engine play
+career-emulator-engine-mcp --help
+```
+
+Participant starter: [techarena-career-sim](https://github.com/RAI-Internal/techarena-career-sim)

career_emulator_engine-1.0.1/career_emulator/storage.py

@@ -0,0 +1,359 @@
+"""SQLite persistence for Career Emulator sessions and logs."""
+
+import asyncio
+import importlib.util
+import json
+import logging
+import os
+import shutil
+import subprocess
+from collections.abc import Callable
+from importlib.metadata import version
+from pathlib import Path
+from typing import Literal, cast
+
+import aiosqlite
+
+from career_emulator.pretty_print import _red
+from career_emulator.server.models import GameSession, LogEntry
+
+DatasetSplit = Literal["dev", "dev_final", "test", "test_final", "*"]
+DatasetSource = Literal["distribution", "github"]
+
+DATASET_REPO_URL = "https://github.com/Flash-Tomato/TomatoEmuData-Test"
+DATA_DIR = Path(__file__).with_name("data")
+DATASET_DIR = DATA_DIR / "dataset"
+DATASET_SPLIT: DatasetSplit = cast(DatasetSplit, os.environ.get("CAREER_EMULATOR_DATASET", "dev"))
+DEFAULT_DATASET_SOURCE: DatasetSource = cast(DatasetSource, os.getenv("CAREER_EMULATOR_DATASET_SOURCE") or "distribution")
+DISTRIBUTION_PACKAGE_MODULE = "career_emulator_techarena"
+DEFAULT_DB_PATH = Path(os.environ.get("CAREER_EMULATOR_DB", DATA_DIR / ".career_emulator.sqlite3"))
+DEFAULT_LOG_DIR = Path(os.environ.get("CAREER_EMULATOR_LOG_DIR", DATA_DIR / "logs"))
+MAX_NOTE_LENGTH = max(1, int(os.environ.get("CAREER_EMULATOR_MAX_NOTE_LENGTH", "1000")))
+MAX_SESSIONS = max(1, int(os.environ.get("CAREER_EMULATOR_MAX_SESSIONS", "20")))
+
+_session_loggers: dict[str, logging.Logger] = {}
+
+
+def truncate_note(note: str, max_length: int = MAX_NOTE_LENGTH) -> str:
+    """Return a note trimmed to the configured maximum length.
+
+    :param note: Raw agent note text.
+    :param max_length: Maximum allowed note length.
+    :returns: Trimmed note text.
+    """
+    compact = note.strip()
+    if len(compact) <= max_length:
+        return compact
+    return f"{compact[: max_length - 3]}..."
+
+
+def _normalize_git_remote_url(url: str) -> str:
+    """Return a canonical form for comparing git remote URLs."""
+    return url.strip().removesuffix(".git").rstrip("/")
+
+
+def _dataset_origin_matches(expected_url: str, dataset_dir: Path) -> bool:
+    """Return whether ``origin`` points at the expected dataset repository."""
+    result = subprocess.run(
+        ["git", "-C", str(dataset_dir), "remote", "get-url", "origin"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    origin_url = result.stdout.strip()
+    return _normalize_git_remote_url(origin_url) == _normalize_git_remote_url(expected_url)
+
+
+def _resolve_distribution_dataset() -> Path:
+    """Locate the dataset directory from ``career_emulator_techarena``.
+
+    :returns: Absolute path to the split-specific dataset directory inside the package.
+    :raises RuntimeError: If the package is not installed or the split directory is missing.
+    """
+    module_name = DISTRIBUTION_PACKAGE_MODULE
+    spec = importlib.util.find_spec(module_name)
+    if spec is None or spec.origin is None:
+        msg = (
+            "Package 'career-emulator-techarena' is not installed. "
+            "Install it with: pip install career-emulator-engine"
+        )
+        raise RuntimeError(_red(msg))
+
+    package_root = Path(spec.origin).parent
+    split_dataset = package_root / DATASET_SPLIT / "dataset"
+    if not split_dataset.is_dir():
+        pkg_ver = version(module_name)
+        msg = f"Dataset split '{DATASET_SPLIT}' not found in {module_name} ({pkg_ver}) at {split_dataset}"
+        raise RuntimeError(_red(msg))
+    return split_dataset.resolve()
+
+
+def update_dataset(source: Literal["github", "distribution"] = DEFAULT_DATASET_SOURCE) -> Path:
+    """Clone, force-update, or symlink the Career Emulator event dataset.
+
+    When source is ``"github"``, the dataset is cloned/updated from the remote
+    repository.  When ``"distribution"``, a symlink is created pointing to the
+    dataset directory bundled inside ``career_emulator_techarena`` for the active
+    :data:`DATASET_SPLIT`.
+
+    :param source: Where to obtain the dataset from.
+    :returns: Absolute path to the local dataset directory.
+    """
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    absolute_dataset_dir = DATASET_DIR.absolute()
+
+    if source == "distribution":
+        pkg_dataset = _resolve_distribution_dataset()
+        if absolute_dataset_dir.is_symlink():
+            if absolute_dataset_dir.resolve() == pkg_dataset:
+                return absolute_dataset_dir
+            absolute_dataset_dir.unlink()
+        elif absolute_dataset_dir.is_dir():
+            shutil.rmtree(absolute_dataset_dir)
+        absolute_dataset_dir.symlink_to(pkg_dataset, target_is_directory=True)
+        return absolute_dataset_dir
+
+    if absolute_dataset_dir.is_symlink():
+        absolute_dataset_dir.unlink()
+
+    if not absolute_dataset_dir.exists():
+        subprocess.run(
+            ["git", "clone", DATASET_REPO_URL, str(absolute_dataset_dir)],
+            check=True,
+        )
+        return absolute_dataset_dir
+
+    if not (absolute_dataset_dir / ".git").exists():
+        msg = f"Dataset path exists but is not a git checkout: {absolute_dataset_dir}"
+        raise RuntimeError(_red(msg))
+
+    if not _dataset_origin_matches(DATASET_REPO_URL, absolute_dataset_dir):
+        shutil.rmtree(absolute_dataset_dir)
+        return update_dataset()
+
+    subprocess.run(["git", "-C", str(absolute_dataset_dir), "fetch", "origin"], check=True)
+    subprocess.run(["git", "-C", str(absolute_dataset_dir), "reset", "--hard", "origin/main"], check=True)
+    subprocess.run(["git", "-C", str(absolute_dataset_dir), "clean", "-fd"], check=True)
+    return absolute_dataset_dir
+
+
+def _close_session_logger(session_id: str) -> None:
+    """Close and remove a cached session logger."""
+    logger = _session_loggers.pop(session_id, None)
+    if logger is None:
+        return
+    for handler in logger.handlers[:]:
+        handler.close()
+        logger.removeHandler(handler)
+
+
+def _session_logger(session_id: str, log_path: Path) -> logging.Logger:
+    """Return a file logger for one session log file."""
+    cached = _session_loggers.get(session_id)
+    if cached is not None:
+        return cached
+
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    logger = logging.getLogger(f"career_emulator.session.{session_id}")
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    handler = logging.FileHandler(log_path, encoding="utf-8")
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    logger.addHandler(handler)
+    _session_loggers[session_id] = logger
+    return logger
+
+
+class SessionStore:
+    """Persist game sessions and player logs in SQLite."""
+
+    def __init__(self, db_path: Path = DEFAULT_DB_PATH, log_dir: Path = DEFAULT_LOG_DIR) -> None:
+        """Initialize the session store.
+
+        :param db_path: SQLite database path.
+        :param log_dir: Directory for per-session log files.
+        """
+        self.db_path = db_path
+        self.log_dir = log_dir
+
+    def log_file_path(self, session_id: str) -> Path:
+        """Return the on-disk log file path for a session."""
+        return self.log_dir / f"{session_id}.log"
+
+    async def initialize(self) -> None:
+        """Create database tables if they do not exist."""
+        if self.db_path.parent != Path("."):
+            self.db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.log_dir.mkdir(parents=True, exist_ok=True)
+        async with aiosqlite.connect(self.db_path) as database:
+            await database.execute(
+                """
+                CREATE TABLE IF NOT EXISTS sessions (
+                    session_id TEXT PRIMARY KEY,
+                    payload TEXT NOT NULL,
+                    updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+            await database.execute(
+                """
+                CREATE TABLE IF NOT EXISTS logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    session_id TEXT NOT NULL,
+                    entry_type TEXT NOT NULL,
+                    message TEXT NOT NULL,
+                    created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+            await self._ensure_sessions_timestamp_column(database)
+            await database.commit()
+
+    async def _ensure_sessions_timestamp_column(self, database: aiosqlite.Connection) -> None:
+        """Add ``updated_at`` to legacy session tables when missing."""
+        cursor = await database.execute("PRAGMA table_info(sessions)")
+        rows = await cursor.fetchall()
+        column_names = {str(row[1]) for row in rows}
+        if "updated_at" not in column_names:
+            # SQLite only allows constant defaults in ALTER TABLE ADD COLUMN.
+            await database.execute("ALTER TABLE sessions ADD COLUMN updated_at TEXT NOT NULL DEFAULT ''")
+            await database.execute("UPDATE sessions SET updated_at = CURRENT_TIMESTAMP WHERE updated_at = ''")
+
+    async def save_session(self, session: GameSession) -> None:
+        """Insert or update a session."""
+        await self.initialize()
+        payload = json.dumps(session.to_dict(), sort_keys=True)
+        async with aiosqlite.connect(self.db_path) as database:
+            await database.execute(
+                """
+                INSERT INTO sessions (session_id, payload, updated_at)
+                VALUES (?, ?, CURRENT_TIMESTAMP)
+                ON CONFLICT(session_id) DO UPDATE SET
+                    payload = excluded.payload,
+                    updated_at = CURRENT_TIMESTAMP
+                """,
+                (session.session_id, payload),
+            )
+            await self._enforce_max_sessions(database)
+            await database.commit()
+
+    async def _enforce_max_sessions(self, database: aiosqlite.Connection) -> None:
+        """Delete oldest sessions when the store exceeds ``MAX_SESSIONS``."""
+        cursor = await database.execute("SELECT COUNT(*) FROM sessions")
+        row = await cursor.fetchone()
+        session_count = int(row[0]) if row is not None else 0
+        overflow = session_count - MAX_SESSIONS
+        if overflow <= 0:
+            return
+
+        cursor = await database.execute(
+            """
+            SELECT session_id FROM sessions
+            ORDER BY updated_at ASC, session_id ASC
+            LIMIT ?
+            """,
+            (overflow,),
+        )
+        rows = await cursor.fetchall()
+        for row in rows:
+            session_id = str(row[0])
+            await database.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
+            await database.execute("DELETE FROM logs WHERE session_id = ?", (session_id,))
+            self._remove_session_log_file(session_id)
+
+    async def delete_session(self, session_id: str) -> None:
+        """Delete persisted session state and log entries for one session."""
+        await self.initialize()
+        async with aiosqlite.connect(self.db_path) as database:
+            await database.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
+            await database.execute("DELETE FROM logs WHERE session_id = ?", (session_id,))
+            await database.commit()
+        self._remove_session_log_file(session_id)
+
+    def delete_session_callback(self) -> Callable[[str, object], None]:
+        """Return a callback that deletes persisted data for one session id.
+
+        The callback matches :class:`~career_emulator.lru_dict.LRUDict` eviction
+        signatures and schedules :meth:`delete_session` on the running loop.
+        """
+        store = self
+
+        def callback(session_id: str, _value: object) -> None:
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                store._remove_session_log_file(session_id)
+                return
+            loop.create_task(store.delete_session(session_id))
+
+        return callback
+
+    def _remove_session_log_file(self, session_id: str) -> None:
+        """Remove a session log file and close its logger."""
+        _close_session_logger(session_id)
+        log_path = self.log_file_path(session_id)
+        if log_path.exists():
+            log_path.unlink()
+
+    async def load_session(self, session_id: str) -> GameSession | None:
+        """Load a session by id."""
+        await self.initialize()
+        async with aiosqlite.connect(self.db_path) as database:
+            cursor = await database.execute("SELECT payload FROM sessions WHERE session_id = ?", (session_id,))
+            row = await cursor.fetchone()
+        if row is None:
+            return None
+        payload = json.loads(str(row[0]))
+        return GameSession.from_dict(payload)
+
+    async def append_log(self, entry: LogEntry) -> None:
+        """Append one log entry to SQLite and the session log file."""
+        await self.initialize()
+        log_path = self.log_file_path(entry.session_id)
+        logger = _session_logger(entry.session_id, log_path)
+        if not log_path.exists() or log_path.stat().st_size == 0:
+            logger.info(f"Log file: {log_path.resolve()}")
+
+        formatted = f"[{entry.entry_type}] {entry.message}"
+        logger.info(formatted)
+
+        async with aiosqlite.connect(self.db_path) as database:
+            await database.execute(
+                "INSERT INTO logs (session_id, entry_type, message) VALUES (?, ?, ?)",
+                (entry.session_id, entry.entry_type, entry.message),
+            )
+            await database.commit()
+
+    async def load_logs(self, session_id: str) -> list[LogEntry]:
+        """Load logs for a session in insertion order."""
+        await self.initialize()
+        async with aiosqlite.connect(self.db_path) as database:
+            cursor = await database.execute(
+                "SELECT session_id, entry_type, message FROM logs WHERE session_id = ? ORDER BY id",
+                (session_id,),
+            )
+            rows = await cursor.fetchall()
+        return [LogEntry(session_id=str(row[0]), entry_type=str(row[1]), message=str(row[2])) for row in rows]
+
+    async def load_latest_logs(self, session_id: str, count: int = 10) -> list[LogEntry]:
+        """Load the most recent log entries for a session in insertion order."""
+        await self.initialize()
+        limit = max(1, count)
+        async with aiosqlite.connect(self.db_path) as database:
+            cursor = await database.execute(
+                """
+                SELECT session_id, entry_type, message FROM logs
+                WHERE session_id = ?
+                ORDER BY id DESC
+                LIMIT ?
+                """,
+                (session_id, limit),
+            )
+            rows = await cursor.fetchall()
+        entries = [LogEntry(session_id=str(row[0]), entry_type=str(row[1]), message=str(row[2])) for row in rows]
+        entries.reverse()
+        return entries
+
+    def log_file_header(self, session_id: str) -> str:
+        """Return the log file path header for a session."""
+        return f"Log file: {self.log_file_path(session_id).resolve()}"

career_emulator_engine-1.0.1/career_emulator_engine.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: career_emulator_engine
+Version: 1.0.1
+Summary: TechArena English track: career simulation engine (CLI + MCP). PyPI: career-emulator-engine.
+Author-email: Yuwei <yuwei.willow.z@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/RAI-Internal/techarena-career-sim
+Project-URL: Documentation, https://career-emulator.readthedocs.io
+Project-URL: Source, https://github.com/RAI-Internal/career-emulator-engine
+Project-URL: Issues, https://github.com/RAI-Internal/techarena-career-sim/issues
+Keywords: python,career-sim,simulation,agent,llm,techarena,competition,mcp client,client,mcp,fastmcp,mcp server,model context protocol
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Intended Audience :: Developers
+Classifier: Typing :: Typed
+Requires-Python: <4,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: msgpack>=1.0.0
+Requires-Dist: aiosqlite>=0.22.1
+Requires-Dist: aiofiles>=25.1.0
+Requires-Dist: career-emulator-techarena==1.0.*
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=2; extra == "mcp"
+
+# career-emulator-engine
+
+English **TechArena** simulation engine (CLI + MCP).  
+Separate from [`career-emulator`](https://pypi.org/project/career-emulator/) (BDCI / Chinese) and from the dataset [`career-emulator-techarena`](https://pypi.org/project/career-emulator-techarena/).
+
+## Install
+
+```bash
+pip install "career-emulator-engine[mcp]"
+```
+
+## Quick use
+
+```bash
+career-emulator-engine update --source distribution --split dev
+career-emulator-engine play
+career-emulator-engine-mcp --help
+```
+
+Participant starter: [techarena-career-sim](https://github.com/RAI-Internal/techarena-career-sim)

career_emulator_engine-1.0.1/career_emulator_engine.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+pyproject.toml
+career_emulator/storage.py
+career_emulator_engine.egg-info/PKG-INFO
+career_emulator_engine.egg-info/SOURCES.txt
+career_emulator_engine.egg-info/dependency_links.txt
+career_emulator_engine.egg-info/entry_points.txt
+career_emulator_engine.egg-info/requires.txt
+career_emulator_engine.egg-info/top_level.txt

career_emulator_engine-1.0.1/career_emulator_engine.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

career_emulator_engine-1.0.1/career_emulator_engine.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+career-emulator-engine = career_emulator.cli:main
+career-emulator-engine-mcp = career_emulator.run_mcp:main

career_emulator_engine-1.0.1/career_emulator_engine.egg-info/requires.txt

@@ -0,0 +1,7 @@
+msgpack>=1.0.0
+aiosqlite>=0.22.1
+aiofiles>=25.1.0
+career-emulator-techarena==1.0.*
+
+[mcp]
+fastmcp>=2

career_emulator_engine-1.0.1/career_emulator_engine.egg-info/top_level.txt

@@ -0,0 +1 @@
+career_emulator

career_emulator_engine-1.0.1/pyproject.toml

@@ -0,0 +1,107 @@
+[project]
+name = "career_emulator_engine"
+version = "1.0.1"
+description = "TechArena English track: career simulation engine (CLI + MCP). PyPI: career-emulator-engine."
+keywords = [
+    "python", "career-sim", "simulation", "agent", "llm", "techarena", "competition",
+    "mcp client", "client", "mcp", "fastmcp", "mcp server", "model context protocol",
+]
+readme = "README.md"
+requires-python = ">=3.11,<4"
+license = "MIT"
+authors = [
+    {name = "Yuwei", email = "yuwei.willow.z@gmail.com"}]
+classifiers = [
+    'Development Status :: 4 - Beta',
+    'Programming Language :: Python',
+    'Programming Language :: Python :: Implementation :: CPython',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3 :: Only',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3.14',
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Intended Audience :: Developers",
+    "Typing :: Typed",
+]
+dependencies = [
+    "msgpack>=1.0.0",
+    "aiosqlite>=0.22.1",
+    "aiofiles>=25.1.0",
+    "career-emulator-techarena==1.0.*",
+]
+
+[project.optional-dependencies]
+mcp = ["fastmcp>=2"]
+
+[dependency-groups]
+test = [
+    "pytest", "pytest-asyncio", "pytest-mock", "numpy==2.*", "scipy", "scikit-learn",
+]
+
+docs = [
+    "sphinx",
+    "sphinx-rtd-theme",
+    "beautifulsoup4",
+    "myst-parser>=3.0.1,<4",
+    "career-emulator-engine[mcp]",
+]
+
+format = [
+    "ruff",
+    "mypy",
+    "types-aiofiles",
+    "msgpack-types",
+]
+
+binary = [
+    "career-emulator-engine[mcp]",
+    "pyinstaller>=6.0,<7",
+    "python-minifier>=3.2,<4",
+]
+
+dev = [
+    { include-group = "test" },
+    { include-group = "format" },
+    { include-group = "docs" },
+    "setuptools",
+]
+
+[project.urls]
+Homepage = "https://github.com/RAI-Internal/techarena-career-sim"
+Documentation = "https://career-emulator.readthedocs.io"
+Source = "https://github.com/RAI-Internal/career-emulator-engine"
+Issues = "https://github.com/RAI-Internal/techarena-career-sim/issues"
+
+[project.scripts]
+career-emulator-engine = "career_emulator.cli:main"
+career-emulator-engine-mcp = "career_emulator.run_mcp:main"
+
+[tool.uv]
+default-groups = ['dev']
+
+[tool.setuptools.package-data]
+career_emulator = ["**/py.typed", "**/.gitkeep"]
+
+[tool.coverage.run]
+omit = ["tests/*"]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+testpaths = ["tests"]
+addopts = ["-v"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+
+[tool.ruff.lint.pydocstyle]
+convention = "pep257"
+
+[tool.pylint.MAIN]
+ignore-paths = ["^(examples|tests|docs|scripts)/.*"]
+py-version = "3.11"
+
+[tool.pylint.FORMAT]
+max-line-length = 120

career_emulator_engine-1.0.1/setup.cfg

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