kodit 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

kodit/log.py

@@ -1,20 +1,33 @@
 """Logging configuration for kodit."""
 
 import logging
+import platform
+import re
+import shutil
+import subprocess
 import sys
 import uuid
 from enum import Enum
 from functools import lru_cache
+from pathlib import Path
 from typing import Any
 
+import rudderstack.analytics as rudder_analytics
 import structlog
-from posthog import Posthog
 from structlog.types import EventDict
 
+from kodit import _version
 from kodit.config import AppContext
 
+_MAC_RE = re.compile(r"(?:[0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}")
+
 log = structlog.get_logger(__name__)
 
+rudder_analytics.write_key = "2wm1RmV2GnO92NGSs8yYtmSI0mi"
+rudder_analytics.dataPlaneUrl = (
+    "https://danbmedefzavzlslreyxjgcjwlf.dataplane.rudderstack.com"
+)
+
 
 def drop_color_message_key(_, __, event_dict: EventDict) -> EventDict:  # noqa: ANN001
     """Drop the `color_message` key from the event dict."""
@@ -131,35 +144,124 @@ def configure_logging(app_context: AppContext) -> None:
     sys.excepthook = handle_exception
 
 
-posthog = Posthog(
-    project_api_key="phc_JsX0yx8NLPcIxamfp4Zc7xyFykXjwmekKUQz060cSt3",
-    host="https://eu.i.posthog.com",
-)
+def configure_telemetry(app_context: AppContext) -> None:
+    """Configure telemetry for the application."""
+    if app_context.disable_telemetry:
+        structlog.stdlib.get_logger(__name__).info("Telemetry has been disabled")
+        rudder_analytics.send = False
 
+    rudder_analytics.identify(
+        anonymous_id=get_stable_mac_str(),
+        traits={},
+    )
 
-@lru_cache(maxsize=1)
-def get_mac_address() -> str:
-    """Get the MAC address of the primary network interface.
 
-    Returns:
-        str: The MAC address or a fallback UUID if not available
+def log_event(event: str, properties: dict[str, Any] | None = None) -> None:
+    """Log an event to Rudderstack."""
+    p = properties or {}
+    # Set default posthog properties
+    p["$app_name"] = "kodit"
+    p["$app_version"] = _version.version
+    p["$os"] = sys.platform
+    p["$os_version"] = sys.version
+    rudder_analytics.track(
+        anonymous_id=get_stable_mac_str(),
+        event=event,
+        properties=properties or {},
+    )
+
 
+# ----------------------------------------------------------------------
+# Helper functions
+# ----------------------------------------------------------------------
+def _mac_int(mac: str) -> int:
+    return int(mac.replace(":", "").replace("-", ""), 16)
+
+
+def _is_globally_administered(mac_int: int) -> bool:
+    first_octet = (mac_int >> 40) & 0xFF
+    return not (first_octet & 0b11)  # both bits must be 0
+
+
+def _from_sysfs() -> list[int]:
+    base = Path("/sys/class/net")
+    if not base.is_dir():
+        return []
+    macs: list[int] = []
+    for iface in base.iterdir():
+        try:
+            with (base / iface / "address").open() as f:
+                content = f.read().strip()
+            if _MAC_RE.fullmatch(content):
+                macs.append(_mac_int(content))
+        except (FileNotFoundError, PermissionError):
+            pass
+    return macs
+
+
+def _from_command(cmd: str) -> list[int]:
+    try:
+        out = subprocess.check_output(  # noqa: S602
+            cmd,
+            shell=True,
+            text=True,
+            stderr=subprocess.DEVNULL,
+            encoding="utf-8",
+        )
+    except Exception:  # noqa: BLE001
+        return []
+    return [_mac_int(m.group()) for m in _MAC_RE.finditer(out)]
+
+
+@lru_cache(maxsize=1)
+def get_stable_mac_int() -> int | None:
+    """Return a *hardware* MAC as an int, or None if none can be found.
+
+    Search order:
+        1. /sys/class/net (Linux)
+        2. `ip link show` (Linux), `ifconfig -a` (Linux+macOS)
+        3. `getmac` and `wmic nic` (Windows)
+    The first globally-administered, non-multicast address wins.
     """
-    # Get the MAC address of the primary network interface
-    mac = uuid.getnode()
-    return f"{mac:012x}" if mac != uuid.getnode() else str(uuid.uuid4())
+    system = platform.system()
+    candidates: list[int] = []
+
+    if system == "Linux":
+        candidates += _from_sysfs()
+        if not candidates and shutil.which("ip"):
+            candidates += _from_command("ip link show")
+        if not candidates:  # fall back to ifconfig
+            candidates += _from_command("ifconfig -a")
+
+    elif system == "Darwin":  # macOS
+        candidates += _from_command("ifconfig -a")
+
+    elif system == "Windows":
+        # getmac is present on every supported Windows version
+        candidates += _from_command("getmac /v /fo list")
+        # wmic still exists through at least Win 11
+        candidates += _from_command(
+            'wmic nic where "MACAddress is not null" get MACAddress /format:list'
+        )
 
+    # Prefer globally administered, non-multicast addresses
+    for mac in candidates:
+        if _is_globally_administered(mac):
+            return mac
 
-def configure_telemetry(app_context: AppContext) -> None:
-    """Configure telemetry for the application."""
-    if app_context.disable_telemetry:
-        structlog.stdlib.get_logger(__name__).info("Telemetry has been disabled")
-        posthog.disabled = True
+    # If all we saw were locally-administered MACs, just return the first one
+    if candidates:
+        return candidates[0]
 
+    return None
 
-def log_event(event: str, properties: dict[str, Any] | None = None) -> None:
-    """Log an event to PostHog."""
-    log.debug(
-        "Logging event", id=get_mac_address(), ph_event=event, ph_properties=properties
-    )
-    posthog.capture(get_mac_address(), event, properties or {})
+
+def get_stable_mac_str() -> str:
+    """Return a *stable* 12-digit hex string (lower-case, no separators).
+
+    Falls back to uuid.getnode() if necessary, so it never raises.
+    """
+    mac_int = get_stable_mac_int()
+    if mac_int is None:
+        mac_int = uuid.getnode()  # may still be random in VMs
+    return f"{mac_int:012x}"

kodit/migrations/versions/9e53ea8bb3b0_add_authors.py

@@ -0,0 +1,103 @@
+# ruff: noqa
+"""add authors
+
+Revision ID: 9e53ea8bb3b0
+Revises: c3f5137d30f5
+Create Date: 2025-06-14 10:50:36.058114
+
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision: str = "9e53ea8bb3b0"
+down_revision: Union[str, None] = "c3f5137d30f5"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    # Define the enum type separately so we can explicitly create it when needed
+    source_type = sa.Enum("UNKNOWN", "FOLDER", "GIT", name="sourcetype")
+
+    # Explicitly create the enum type for PostgreSQL (no-op on SQLite)
+    source_type.create(op.get_bind(), checkfirst=True)
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "authors",
+        sa.Column("name", sa.String(length=255), nullable=False),
+        sa.Column("email", sa.String(length=255), nullable=False),
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("name", "email", name="uix_author"),
+    )
+    op.create_index(op.f("ix_authors_email"), "authors", ["email"], unique=False)
+    op.create_index(op.f("ix_authors_name"), "authors", ["name"], unique=False)
+    op.create_table(
+        "author_file_mappings",
+        sa.Column("author_id", sa.Integer(), nullable=False),
+        sa.Column("file_id", sa.Integer(), nullable=False),
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column("created_at", sa.DateTime(timezone=True), nullable=False),
+        sa.Column("updated_at", sa.DateTime(timezone=True), nullable=False),
+        sa.ForeignKeyConstraint(
+            ["author_id"],
+            ["authors.id"],
+        ),
+        sa.ForeignKeyConstraint(
+            ["file_id"],
+            ["files.id"],
+        ),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("author_id", "file_id", name="uix_author_file_mapping"),
+    )
+    op.create_index(
+        op.f("ix_author_file_mappings_author_id"),
+        "author_file_mappings",
+        ["author_id"],
+        unique=False,
+    )
+    op.create_index(
+        op.f("ix_author_file_mappings_file_id"),
+        "author_file_mappings",
+        ["file_id"],
+        unique=False,
+    )
+    op.add_column(
+        "files", sa.Column("extension", sa.String(length=255), nullable=False)
+    )
+    op.create_index(op.f("ix_files_extension"), "files", ["extension"], unique=False)
+    op.add_column("sources", sa.Column("type", source_type, nullable=False))
+    op.create_index(op.f("ix_sources_type"), "sources", ["type"], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f("ix_sources_type"), table_name="sources")
+    op.drop_column("sources", "type")
+    op.drop_index(op.f("ix_files_extension"), table_name="files")
+    op.drop_column("files", "extension")
+    op.drop_index(
+        op.f("ix_author_file_mappings_file_id"), table_name="author_file_mappings"
+    )
+    op.drop_index(
+        op.f("ix_author_file_mappings_author_id"), table_name="author_file_mappings"
+    )
+    op.drop_table("author_file_mappings")
+    op.drop_index(op.f("ix_authors_name"), table_name="authors")
+    op.drop_index(op.f("ix_authors_email"), table_name="authors")
+    op.drop_table("authors")
+
+    # Explicitly drop the enum type (PostgreSQL)
+    source_type = sa.Enum("UNKNOWN", "FOLDER", "GIT", name="sourcetype")
+    source_type.drop(op.get_bind(), checkfirst=True)
+    # ### end Alembic commands ###

kodit/source/git.py

@@ -0,0 +1,16 @@
+"""Git utilities."""
+
+import tempfile
+
+import git
+
+
+def is_valid_clone_target(target: str) -> bool:
+    """Return True if the target is clonable."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        try:
+            git.Repo.clone_from(target, temp_dir)
+        except git.GitCommandError:
+            return False
+        else:
+            return True

kodit/source/ignore.py

@@ -0,0 +1,53 @@
+"""Ignore patterns."""
+
+from pathlib import Path
+
+import git
+import pathspec
+
+from kodit.source.git import is_valid_clone_target
+
+
+class IgnorePatterns:
+    """Ignore patterns."""
+
+    def __init__(self, base_dir: Path) -> None:
+        """Initialize the ignore patterns."""
+        if not base_dir.is_dir():
+            msg = f"Base directory is not a directory: {base_dir}"
+            raise ValueError(msg)
+
+        self.base_dir = base_dir
+
+        # Check if the base_dir is a valid git repository
+        self.git_repo = None
+        if is_valid_clone_target(str(base_dir)):
+            self.git_repo = git.Repo(base_dir)
+
+    def should_ignore(self, path: Path) -> bool:
+        """Check if a path should be ignored."""
+        if path.is_dir():
+            return False
+
+        # Get the path relative to the base_dir
+        relative_path = path.relative_to(self.base_dir)
+
+        # If this file is _part_ of a .git directory, then it should be ignored
+        if relative_path.as_posix().startswith(".git"):
+            return True
+
+        # If it is a git repository, then we need to check if the file is ignored
+        if self.git_repo and len(self.git_repo.ignored(path)) > 0:
+            return True
+
+        # If the repo has a .noindex file
+        noindex_path = Path(self.base_dir / ".noindex")
+        if noindex_path.exists():
+            with noindex_path.open() as f:
+                patterns = [line.strip() for line in f if line.strip()]
+                if patterns:
+                    spec = pathspec.PathSpec.from_lines("gitwildmatch", patterns)
+                    if spec.match_file(relative_path.as_posix()):
+                        return True
+
+        return False