mukulcore 0.1.0__py3-none-any.whl

mukulcore/__init__.py

@@ -0,0 +1,7 @@
+"""
+MukulCore
+
+A Python toolkit for AI Engineers.
+"""
+
+from .version import __version__

mukulcore/agents/__init__.py

@@ -0,0 +1 @@
+"""Agents package."""

mukulcore/agents/base_agent.py

@@ -0,0 +1,14 @@
+"""Base agent abstraction."""
+
+from typing import Any
+
+
+class BaseAgent:
+    """Simple base class for agents."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def run(self, task: str, **kwargs: Any) -> str:
+        """Execute a task and return a string result."""
+        return f"{self.name}: {task}"

mukulcore/agents/critic.py

@@ -0,0 +1,10 @@
+"""Critic agent."""
+
+from .base_agent import BaseAgent
+
+
+class CriticAgent(BaseAgent):
+    """Agent for critique tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("critic")

mukulcore/agents/planner.py

@@ -0,0 +1,10 @@
+"""Planner agent."""
+
+from .base_agent import BaseAgent
+
+
+class PlannerAgent(BaseAgent):
+    """Agent for planning tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("planner")

mukulcore/agents/researcher.py

@@ -0,0 +1,10 @@
+"""Researcher agent."""
+
+from .base_agent import BaseAgent
+
+
+class ResearcherAgent(BaseAgent):
+    """Agent for research tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("researcher")

mukulcore/agents/writer.py

@@ -0,0 +1,10 @@
+"""Writer agent."""
+
+from .base_agent import BaseAgent
+
+
+class WriterAgent(BaseAgent):
+    """Agent for writing tasks."""
+
+    def __init__(self) -> None:
+        super().__init__("writer")

mukulcore/ai/__init__.py

@@ -0,0 +1 @@
+"""AI package."""

mukulcore/ai/embeddings.py

@@ -0,0 +1,8 @@
+"""Embedding helpers."""
+
+from typing import List
+
+
+def embed_text(text: str) -> List[float]:
+    """Return a simple placeholder embedding."""
+    return [float(len(text)), float(sum(ord(ch) for ch in text) % 100)]

mukulcore/ai/llm.py

@@ -0,0 +1,11 @@
+"""Simple LLM abstraction interface."""
+
+from typing import Any
+
+
+class BaseLLM:
+    """Base class for LLM integrations."""
+
+    def generate(self, prompt: str, **kwargs: Any) -> str:
+        """Generate a response from a prompt."""
+        return prompt

mukulcore/ai/markdown.py

@@ -0,0 +1,6 @@
+"""Markdown helpers."""
+
+
+def to_markdown(text: str) -> str:
+    """Wrap text as a markdown paragraph."""
+    return f"{text}\n"

mukulcore/ai/memory.py

@@ -0,0 +1,16 @@
+"""Simple memory store."""
+
+from typing import Any, Dict
+
+
+class MemoryStore:
+    """Store key/value pairs in memory."""
+
+    def __init__(self) -> None:
+        self._store: Dict[str, Any] = {}
+
+    def set(self, key: str, value: Any) -> None:
+        self._store[key] = value
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._store.get(key, default)

mukulcore/ai/parser.py

@@ -0,0 +1,10 @@
+"""Output parsing helpers."""
+
+from typing import Any
+
+
+def parse_json(text: str) -> Any:
+    """Parse JSON from a string."""
+    import json
+
+    return json.loads(text)

mukulcore/ai/prompts.py

@@ -0,0 +1,8 @@
+"""Prompt management utilities."""
+
+from pathlib import Path
+
+
+def load_prompt(path: str | Path) -> str:
+    """Load a prompt from disk."""
+    return Path(path).read_text(encoding="utf-8")

mukulcore/ai/templates.py

@@ -0,0 +1,6 @@
+"""Template helpers."""
+
+
+def render(template: str, **values: str) -> str:
+    """Render a basic template string."""
+    return template.format(**values)

mukulcore/ai/tokenizer.py

@@ -0,0 +1,6 @@
+"""Tokenization helpers."""
+
+
+def tokenize(text: str) -> list[str]:
+    """Split text into tokens."""
+    return text.split()

mukulcore/api/__init__.py

@@ -0,0 +1 @@
+"""API package."""

mukulcore/api/auth.py

@@ -0,0 +1,6 @@
+"""Authentication helpers."""
+
+
+def get_auth_header(token: str) -> dict[str, str]:
+    """Return a bearer token header."""
+    return {"Authorization": f"Bearer {token}"}

mukulcore/api/client.py

@@ -0,0 +1,8 @@
+"""API client placeholder."""
+
+
+class APIClient:
+    """Minimal API client stub."""
+
+    def __init__(self, base_url: str = "") -> None:
+        self.base_url = base_url

mukulcore/api/requests.py

@@ -0,0 +1,11 @@
+"""API request models."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class APIRequest:
+    """Simple request payload."""
+
+    method: str = "GET"
+    url: str = ""

mukulcore/api/responses.py

@@ -0,0 +1,11 @@
+"""API response models."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class APIResponse:
+    """Simple response payload."""
+
+    status_code: int = 200
+    body: str = ""

mukulcore/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI package."""

mukulcore/cli/doctor.py

@@ -0,0 +1,6 @@
+"""CLI doctor command."""
+
+
+def doctor() -> str:
+    """Return a health-check message."""
+    return "Everything looks healthy"

mukulcore/cli/init.py

@@ -0,0 +1,6 @@
+"""Initialize the package from the CLI."""
+
+
+def init_project() -> str:
+    """Return a setup message."""
+    return "Project initialized"

mukulcore/cli/main.py

@@ -0,0 +1,6 @@
+"""CLI entry point."""
+
+
+def main() -> None:
+    """Print a welcome message."""
+    print("mukulcore CLI")

mukulcore/config/__init__.py

@@ -0,0 +1 @@
+"""Configuration package."""

mukulcore/config/constants.py

@@ -0,0 +1,4 @@
+"""Common constants."""
+
+DEFAULT_TIMEOUT = 30
+DEFAULT_RETRIES = 3

mukulcore/config/env.py

@@ -0,0 +1,8 @@
+"""Environment helpers."""
+
+import os
+
+
+def get_env(name: str, default: str | None = None) -> str | None:
+    """Return an environment variable value."""
+    return os.getenv(name, default)

mukulcore/config/settings.py

@@ -0,0 +1,17 @@
+"""Pydantic-based settings helpers."""
+
+from typing import Optional
+
+try:
+    from pydantic import BaseModel
+except ImportError:  # pragma: no cover
+    class BaseModel:  # type: ignore
+        pass
+
+
+class Settings(BaseModel):
+    """Simple application settings container."""
+
+    app_name: str = "mukulcore"
+    debug: bool = False
+    api_key: Optional[str] = None

mukulcore/database/__init__.py

@@ -0,0 +1 @@
+"""Database package."""

mukulcore/database/mongodb.py

@@ -0,0 +1,6 @@
+"""MongoDB helpers."""
+
+
+def get_connection_string(host: str, db: str) -> str:
+    """Create a simple MongoDB connection string."""
+    return f"mongodb://{host}/{db}"

mukulcore/database/postgres.py

@@ -0,0 +1,6 @@
+"""PostgreSQL helpers."""
+
+
+def get_connection_string(host: str, db: str, user: str, password: str) -> str:
+    """Create a simple PostgreSQL connection string."""
+    return f"postgresql://{user}:{password}@{host}/{db}"

mukulcore/database/sqlite.py

@@ -0,0 +1,9 @@
+"""SQLite helpers."""
+
+import sqlite3
+from pathlib import Path
+
+
+def connect(path: str | Path) -> sqlite3.Connection:
+    """Connect to a SQLite database."""
+    return sqlite3.connect(str(path))

mukulcore/database/vectorstore.py

@@ -0,0 +1,8 @@
+"""Vector store helpers."""
+
+from typing import List, Tuple
+
+
+def create_index(items: List[Tuple[str, List[float]]]) -> List[Tuple[str, List[float]]]:
+    """Return the provided items as a simple index."""
+    return items

mukulcore/decorators/__init__.py

@@ -0,0 +1 @@
+"""Decorators package."""

mukulcore/decorators/cache.py

@@ -0,0 +1,20 @@
+"""Caching decorator."""
+
+from functools import wraps
+from typing import Any, Callable, Dict, TypeVar
+
+T = TypeVar("T")
+
+
+def cache(func: Callable[..., T]) -> Callable[..., T]:
+    """Cache the result of a function for repeated calls."""
+    cache_store: Dict[tuple, Any] = {}
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> T:
+        key = (args, tuple(sorted(kwargs.items())))
+        if key not in cache_store:
+            cache_store[key] = func(*args, **kwargs)
+        return cache_store[key]
+
+    return wrapper

mukulcore/decorators/retry.py

@@ -0,0 +1,29 @@
+"""Retry helpers."""
+
+import time
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def retry(max_attempts: int = 3, delay: float = 0.1):
+    """Retry a function a few times on failure."""
+
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> T:
+            last_error = None
+            for attempt in range(1, max_attempts + 1):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as exc:  # pragma: no cover - simple helper
+                    last_error = exc
+                    if attempt == max_attempts:
+                        raise
+                    time.sleep(delay)
+            raise last_error
+
+        return wrapper
+
+    return decorator

mukulcore/decorators/singleton.py

@@ -0,0 +1,19 @@
+"""Singleton decorator."""
+
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def singleton(cls: type[T]) -> type[T]:
+    """Ensure a class only has one instance."""
+    instances = {}
+
+    @wraps(cls)
+    def wrapper(*args, **kwargs) -> T:
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return wrapper

mukulcore/decorators/timer.py

@@ -0,0 +1,22 @@
+"""Timer decorator."""
+
+import time
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def timer(func: Callable[..., T]) -> Callable[..., T]:
+    """Measure the execution time of a function."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> T:
+        start = time.perf_counter()
+        try:
+            return func(*args, **kwargs)
+        finally:
+            elapsed = time.perf_counter() - start
+            print(f"{func.__name__} took {elapsed:.4f}s")
+
+    return wrapper

mukulcore/decorators/validate.py

@@ -0,0 +1,16 @@
+"""Validation decorator."""
+
+from functools import wraps
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+
+
+def validate(func: Callable[..., T]) -> Callable[..., T]:
+    """Placeholder validator decorator."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs) -> T:
+        return func(*args, **kwargs)
+
+    return wrapper

mukulcore/exceptions/__init__.py

@@ -0,0 +1,8 @@
+"""Exceptions package."""
+
+from .ai import AIError
+from .api import APIError
+from .graph import GraphError
+from .validation import ValidationError
+
+__all__ = ["AIError", "APIError", "GraphError", "ValidationError"]

mukulcore/exceptions/ai.py

@@ -0,0 +1,5 @@
+"""AI-related exceptions."""
+
+
+class AIError(Exception):
+    """Raised for AI-related failures."""

mukulcore/exceptions/api.py

@@ -0,0 +1,5 @@
+"""API-related exceptions."""
+
+
+class APIError(Exception):
+    """Raised for API-related failures."""

mukulcore/exceptions/graph.py

@@ -0,0 +1,5 @@
+"""Graph-related exceptions."""
+
+
+class GraphError(Exception):
+    """Raised for workflow graph failures."""

mukulcore/exceptions/validation.py

@@ -0,0 +1,5 @@
+"""Validation-related exceptions."""
+
+
+class ValidationError(Exception):
+    """Raised for validation failures."""

mukulcore/graph/__init__.py

@@ -0,0 +1 @@
+"""Graph package."""

mukulcore/graph/checkpoint.py

@@ -0,0 +1,8 @@
+"""Checkpoint helpers."""
+
+from pathlib import Path
+
+
+def save_checkpoint(path: str | Path, data: str) -> None:
+    """Save a checkpoint string to disk."""
+    Path(path).write_text(data, encoding="utf-8")

mukulcore/graph/edges.py

@@ -0,0 +1,6 @@
+"""Graph edges."""
+
+from typing import Callable
+
+
+Edge = Callable[[dict], dict]

mukulcore/graph/nodes.py

@@ -0,0 +1,8 @@
+"""Graph nodes."""
+
+from .state import GraphState
+
+
+def simple_node(state: GraphState) -> GraphState:
+    """Return the state unchanged."""
+    return state

mukulcore/graph/state.py

@@ -0,0 +1,11 @@
+"""Workflow state definitions."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+
+@dataclass
+class GraphState:
+    """Simple state container for graph workflows."""
+
+    data: Dict[str, Any] = field(default_factory=dict)

mukulcore/graph/workflow.py

@@ -0,0 +1,8 @@
+"""Workflow orchestration helpers."""
+
+from .state import GraphState
+
+
+def run_workflow(initial_state: GraphState) -> GraphState:
+    """Run a simple workflow."""
+    return initial_state

mukulcore/logging/__init__.py

@@ -0,0 +1,5 @@
+"""Logging package."""
+
+from .logger import get_logger
+
+__all__ = ["get_logger"]

mukulcore/logging/file_logger.py

@@ -0,0 +1,15 @@
+"""File-based logging helper."""
+
+import logging
+from pathlib import Path
+
+
+def create_file_logger(name: str, path: str | Path) -> logging.Logger:
+    """Create a logger that writes to a file."""
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.INFO)
+    handler = logging.FileHandler(path)
+    handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+    logger.propagate = False
+    return logger

mukulcore/logging/formatter.py

@@ -0,0 +1,10 @@
+"""Custom formatter helpers."""
+
+import logging
+
+
+class JsonFormatter(logging.Formatter):
+    """Minimal JSON-like formatter for log records."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        return f'{{"level": "{record.levelname}", "message": "{record.getMessage()}"}}'

mukulcore/logging/logger.py

@@ -0,0 +1,15 @@
+"""Logging helpers."""
+
+import logging
+
+
+def get_logger(name: str = "mukulcore") -> logging.Logger:
+    """Create or retrieve a logger instance."""
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s:%(message)s"))
+        logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    return logger

mukulcore/models/__init__.py

@@ -0,0 +1 @@
+"""Data models package."""

mukulcore/models/base.py

@@ -0,0 +1,10 @@
+"""Base model definitions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class BaseModel:
+    """Minimal base model."""
+
+    id: str | None = None

mukulcore/models/requests.py

@@ -0,0 +1,10 @@
+"""Request model definitions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RequestModel:
+    """Simple request container."""
+
+    prompt: str = ""

mukulcore/models/responses.py

@@ -0,0 +1,10 @@
+"""Response model definitions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ResponseModel:
+    """Simple response container."""
+
+    output: str = ""

mukulcore/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools package."""

mukulcore/tools/calculator.py

@@ -0,0 +1,6 @@
+"""Calculator tool placeholder."""
+
+
+def add(a: float, b: float) -> float:
+    """Add two numbers."""
+    return a + b

mukulcore/tools/csv_tool.py

@@ -0,0 +1,10 @@
+"""CSV helper placeholder."""
+
+import csv
+from pathlib import Path
+
+
+def read_csv(path: str | Path) -> list[dict[str, str]]:
+    """Read a CSV file into a list of rows."""
+    with Path(path).open(newline="", encoding="utf-8") as handle:
+        return list(csv.DictReader(handle))

mukulcore/tools/filesystem.py

@@ -0,0 +1,8 @@
+"""Filesystem tool placeholder."""
+
+from pathlib import Path
+
+
+def read_text(path: str | Path) -> str:
+    """Read text from a file."""
+    return Path(path).read_text(encoding="utf-8")

mukulcore/tools/github.py

@@ -0,0 +1,6 @@
+"""GitHub tool placeholder."""
+
+
+def repo_info(owner: str, repo: str) -> dict[str, str]:
+    """Return placeholder repository metadata."""
+    return {"owner": owner, "repo": repo}

mukulcore/tools/pdf.py

@@ -0,0 +1,6 @@
+"""PDF helper placeholder."""
+
+
+def extract_text(path: str) -> str:
+    """Return a placeholder extraction result."""
+    return f"pdf:{path}"

mukulcore/tools/search.py

@@ -0,0 +1,6 @@
+"""Search tool placeholder."""
+
+
+def search(query: str) -> list[str]:
+    """Return a placeholder search result."""
+    return [query]

mukulcore/tools/web.py

@@ -0,0 +1,6 @@
+"""Web tool placeholder."""
+
+
+def fetch(url: str) -> str:
+    """Return a placeholder response for a URL."""
+    return f"fetched {url}"

mukulcore/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for mukulcore."""
+
+from ..version import __version__
+
+__all__ = ["__version__"]

mukulcore/utils/file_utils.py

@@ -0,0 +1,10 @@
+"""File system utility helpers."""
+
+from pathlib import Path
+
+
+def ensure_parent_dir(path: str | Path) -> Path:
+    """Create the parent directory for a file path if needed."""
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path

mukulcore/utils/json_utils.py

@@ -0,0 +1,17 @@
+"""JSON utility helpers."""
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def load_json(path: str | Path) -> Any:
+    """Load JSON data from a file."""
+    with Path(path).open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def dump_json(path: str | Path, data: Any) -> None:
+    """Write JSON data to a file."""
+    with Path(path).open("w", encoding="utf-8") as handle:
+        json.dump(data, handle, indent=2)

mukulcore/version.py

@@ -0,0 +1,3 @@
+"""Package version information."""
+
+__version__ = "0.1.0"

mukulcore-0.1.0.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mukulcore
+Version: 0.1.0
+Summary: A small utility package
+Author: mukulcore
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mukulcore
+
+A small utility package with logging, retry, JSON, file, and config helpers.

mukulcore-0.1.0.dist-info/RECORD

@@ -0,0 +1,76 @@
+mukulcore/__init__.py,sha256=ZO7VOvcJRHRJ7FgKDBs5wbkRcjxP9O7H5q3s_nyM2qk,93
+mukulcore/version.py,sha256=ggWnNH4drSISjW0lG3dBsso9PUVKSCfD-cCG1RB7gpo,61
+mukulcore/agents/__init__.py,sha256=kpaDIdyC6gbwB1NgouGTCpFOlN6wpGZfEuzZCFKoTwY,23
+mukulcore/agents/base_agent.py,sha256=tGHscl76zCP1l6yrHkrgu5RG7uiDsjnRjaVWQ8D4cKE,344
+mukulcore/agents/critic.py,sha256=w0hpQutxqlG05Hvt3xaBf7rw4O5uZCGvufap6uHn10A,201
+mukulcore/agents/planner.py,sha256=xk490dEcUcDQ6LHYC5ju3GYqBhlUJTt9l1U_KCCquJ4,204
+mukulcore/agents/researcher.py,sha256=upHLm__9IHzaAQ5JYlCHb4A70U0OwC46J3OF77_dZ3Q,213
+mukulcore/agents/writer.py,sha256=lhHDdGga_j6VP-koMX2Yc8i4jM56HAi8Igcf4zgeXrc,200
+mukulcore/ai/__init__.py,sha256=JMabe1fVHBvAAsrXbQqSPat2uJCF5Y-IUi-jqw4SDNs,19
+mukulcore/ai/embeddings.py,sha256=-o7sTdOG959tm_1vMYKpucGIrlz38garDv6gT_ysQ58,223
+mukulcore/ai/llm.py,sha256=SbJHdIUABDaNAMwRpnQkOl_VGxiEQeVcoWAygk4CKFQ,266
+mukulcore/ai/markdown.py,sha256=Srxbs6h0sXE71ybqHZUsYZMntfoT_4LTtHqwgTBY0V4,135
+mukulcore/ai/memory.py,sha256=X7uFvgv8puJRnIydHSj6nXADy8fJ5_FCK5A17Smyn5w,397
+mukulcore/ai/parser.py,sha256=K7d4LpkeqTUHLXbuMirZG3o3Z4WZZyRvVLODv3RyIXY,181
+mukulcore/ai/prompts.py,sha256=atZi_SeVNsxuvUiP6FBy021jYHgg-ZJut-RZ6kulqrA,198
+mukulcore/ai/templates.py,sha256=jeWskcb9XyjXaxLwyB0Tmn1-8MpBf9sKqwSnxP-KDIQ,160
+mukulcore/ai/tokenizer.py,sha256=YJy-_3rN7zKHdRrgMBHY50RjtRLmj1ZiNWcIHG5M190,132
+mukulcore/api/__init__.py,sha256=W5bQNZGz2YLMXx1hC9e_eKhbf_GNFVYy3MC3D7gugUc,20
+mukulcore/api/auth.py,sha256=vx0CO3ieoD2LK7npZjoFHUvU9j0evjzUv_aZJvnZ0lA,177
+mukulcore/api/client.py,sha256=p1qyyPiLEWyCgC61cmh23a5YCo6wBCr1R_qUd-ehZEw,178
+mukulcore/api/requests.py,sha256=pTtISUSWHRtNy3cmsnzisxs2Rb4a28-sFs6Ib0U3a8g,180
+mukulcore/api/responses.py,sha256=MjssCsjhCwARBqwpLtGDJShpk6nzc7ceJQsJ73gO998,187
+mukulcore/cli/__init__.py,sha256=EVBgqtvjACyYOpTqfUrgYlLGsgMp1bJlbxQyDxzLypo,20
+mukulcore/cli/doctor.py,sha256=tmU9Z3wLw9sleGk1y4gn8ATiQ7X04GzV1ahuKG23hTM,134
+mukulcore/cli/init.py,sha256=OKjVC-qIwgN0S8MQz_cewUjhZxgaIQxx_9uLZMoKLZU,145
+mukulcore/cli/main.py,sha256=DZRFjYzSKUI8ineQAzF0ntHwW2kGmJ80tXkYQA6O7ag,113
+mukulcore/config/__init__.py,sha256=sE-HksctgL1Ut6O6fuuAiREUHlU60tvKf-5SpZMVRAw,30
+mukulcore/config/constants.py,sha256=yFNbXibPsyJIlg3IpOLWK5Eg9DvSjALj_batQXwOe00,70
+mukulcore/config/env.py,sha256=m-qR5k18xXuGJfVVmsWEiisUBibVzQ_w1tLiPgKaL1w,198
+mukulcore/config/settings.py,sha256=_qiH5cLR2Fzqa86qurRDKkHD4K6l3b0BlRQh08x58Ik,385
+mukulcore/database/__init__.py,sha256=Eo4qZjFu7mJWJ0ZMB1F6p7eXswpVZDxdgA0shdLdn8o,25
+mukulcore/database/mongodb.py,sha256=B7FbojyVfUg1PzZJ_it2ALKdqmP9AAvCN1mR5P-3YC8,174
+mukulcore/database/postgres.py,sha256=gpQfBd0iqhHDq-02I92gQXQQ0kvuAj7obGYobBaatgU,227
+mukulcore/database/sqlite.py,sha256=3UwdRNqIW4SAWpkC9hNacYFwSrd0to1_1oiZd9YDVP0,205
+mukulcore/database/vectorstore.py,sha256=SP_OhYaXF1ehUtjzhzy5JKy_MguRtP239K-bT05o7ow,231
+mukulcore/decorators/__init__.py,sha256=ejFTCZG59rcr_-oO2Vgx5xkSX87jHcmZilFGfQZS7dA,27
+mukulcore/decorators/cache.py,sha256=GXMyks_0Ml1MtcesGvoztsPYEJAKMyabkPMEXThBbc4,546
+mukulcore/decorators/retry.py,sha256=QXKt5PKio9U2HCJ6RUbnQTgGCKCyNhRSiZU1PWENXJE,841
+mukulcore/decorators/singleton.py,sha256=EN4ZriwKEF7rCTpB_IUYNRG8BedgQh2-BdxZ2kLkVXQ,428
+mukulcore/decorators/timer.py,sha256=gD2Agb9Me8Jd-Iw6hITby-zx2jXsUaTFxL4moYWMyTs,542
+mukulcore/decorators/validate.py,sha256=z_xRAh8g1st5vpAecldNwn2kBqF6VH5XtjcFiq-ZVsE,345
+mukulcore/exceptions/__init__.py,sha256=0RCftIVNnbKCU0tqgbh06MfW1nQ6Dql0XOK34Ua5OzU,223
+mukulcore/exceptions/ai.py,sha256=e1F0xn9KqGQ3MnB1PR2oHQAFPPsi0TuYCHtHHWkn-Dw,104
+mukulcore/exceptions/api.py,sha256=9CHxMeswA9h_HV1SvAXsA7Cei2cqh2mjzkZSHFd22EA,107
+mukulcore/exceptions/graph.py,sha256=oyE4mSJJD6DFHt6zUCEW2ejPHIEyxnvQFVhFiM9uhqA,114
+mukulcore/exceptions/validation.py,sha256=OwAiiv3S6aOjxLbIhhDWblXGeKR1-4VWQybsjmdVWIY,120
+mukulcore/graph/__init__.py,sha256=posiNcxsrJe8xfda8j1b1B5RtRU7b-HrHq7USN67tKQ,22
+mukulcore/graph/checkpoint.py,sha256=voCoIpYWKHLKtwhFVgJyrLd1pfpQp_Gqbc3_Rsbi_Bk,214
+mukulcore/graph/edges.py,sha256=H7G1RwXFYZwTro3HpjSaMsii3y6YEGpLzvfI_VV7GhE,86
+mukulcore/graph/nodes.py,sha256=F9d9ucNHFZfBwRejAoVFDepBgihc2vvknLemWb3TkKc,165
+mukulcore/graph/state.py,sha256=10j6vfOX-YdtwQBHEnU9A_HL1zzyU489MOyptpCfnVY,257
+mukulcore/graph/workflow.py,sha256=AKSib3p_esMmF1PMszT3QQQbVaU_Toz-U0-LO2O0PJY,196
+mukulcore/logging/__init__.py,sha256=4iDT5RqNr-0_NSdTzvMIR_jzBKK4DZApnUhAwaqgGfI,86
+mukulcore/logging/file_logger.py,sha256=tLqYUogdEwms8fRLAFHAnwBNta8fHx7HopApEDu8cnM,489
+mukulcore/logging/formatter.py,sha256=1wwLvih-DClf9BvGuFCympLjN11YSSJ7-6MzV2939c8,300
+mukulcore/logging/logger.py,sha256=xbrD0vAumnEWOuxvXH7yL9hYeQOtIzKa0OKv5JLoeGY,472
+mukulcore/models/__init__.py,sha256=_eTOtQfUCRHGAxJKyJzgMxem2DTUcVyNOYtvBsvMhsA,28
+mukulcore/models/base.py,sha256=FUifj7da3Hi8XVpdQGuTj4CJwHflzLDIiOmhmYFSJvU,162
+mukulcore/models/requests.py,sha256=lio4VQg0C5HPhymtlZaiJrIIJ7D6192VX_BkWlk4P6M,169
+mukulcore/models/responses.py,sha256=SZ-pHyTpTuciQFUvl0eNTCS3Q8r63CyhxpykogncYko,172
+mukulcore/tools/__init__.py,sha256=Dq8aBI6e9uBx9S1EX6jqfN-xCZmlk7bmFXsVAd7oT_0,22
+mukulcore/tools/calculator.py,sha256=LZhSWHC8xQOKnv63Wl7h2MuGzEpkEPfwRQlrzXIroks,125
+mukulcore/tools/csv_tool.py,sha256=IKBC4wLJXXCGdL-Ifz_TwBOqhueC8wZAlgNkvctcPtA,292
+mukulcore/tools/filesystem.py,sha256=7xrTwdd-HLPZNlw2WofYQA6ur4k05JJPU6pr2bQmiFk,194
+mukulcore/tools/github.py,sha256=u_U0kjrppK7aGCH9syQl1NYKVYHw1F53YQ02_qdKf0I,187
+mukulcore/tools/pdf.py,sha256=ognA4A4t3qNCtz7Q68rHM-8sepIuUDzuUlZ3fHhys0c,149
+mukulcore/tools/search.py,sha256=2xwO832cibL83F8H2yi3yKk19E8ktstywjAjhr42b3s,141
+mukulcore/tools/web.py,sha256=7p-Sytcf2peWhucIpHALKh7ylcF7r_Z1Vxdi29Mf5n4,143
+mukulcore/utils/__init__.py,sha256=0j3GpnAdACrp53stkZuPGJ47MUqXKZQoK5fugCoGFOc,106
+mukulcore/utils/file_utils.py,sha256=UBuuL12v1g-oB-OH0sOvSpYOjnNM5i9H_OkNZxEMzuQ,276
+mukulcore/utils/json_utils.py,sha256=3aLesOE9uip4wU37pho665W2-ODTsEF-kcXDMcgojps,470
+mukulcore-0.1.0.dist-info/licenses/LICENSE,sha256=_k8t1PUPknBh0X4l14HKy0zsInEZiZJJ4vDbnbnMN_M,1021
+mukulcore-0.1.0.dist-info/METADATA,sha256=VyPJXR7ic-7Zm65PgtMFkwa2TVARxhrycj_mIv1i-Ss,315
+mukulcore-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+mukulcore-0.1.0.dist-info/top_level.txt,sha256=L2DOr9azvU7DvLx8GtEpUZvYh4Dg0n_MzOj9WvV9tdE,10
+mukulcore-0.1.0.dist-info/RECORD,,

mukulcore-0.1.0.dist-info/WHEEL

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

mukulcore-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 mukulcore
+
+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, TO USE, THE SOFTWARE OR OTHER
+DEALINGS IN THE SOFTWARE.

mukulcore-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mukulcore