half-orm-dev 0.16.0a9__py3-none-any.whl

half_orm_dev/patch_validator.py

@@ -0,0 +1,335 @@
+"""
+Patch ID validation and normalization for half-orm-dev.
+
+This module provides validation and normalization of patch identifiers
+used in the patch-centric workflow.
+"""
+
+import re
+import unicodedata
+from typing import Optional
+from dataclasses import dataclass
+
+
+class InvalidPatchIdError(Exception):
+    """Raised when patch ID format is invalid."""
+    pass
+
+
+class DuplicatePatchIdError(Exception):
+    """Raised when patch ID already exists."""
+    pass
+
+
+@dataclass
+class PatchInfo:
+    """Information about a validated patch ID."""
+    original_id: str
+    normalized_id: str
+    ticket_number: Optional[str]
+    description: Optional[str]
+    is_numeric_only: bool
+
+
+class PatchValidator:
+    """
+    Validates and normalizes patch IDs for the patch-centric workflow.
+
+    Handles both formats:
+    - Numeric only: "456" -> generates description if possible
+    - Full format: "456-user-authentication" -> validates format
+
+    Examples:
+        validator = PatchValidator()
+
+        # Numeric patch ID
+        info = validator.validate_patch_id("456")
+        # Returns: PatchInfo(original_id="456", normalized_id="456", ...)
+
+        # Full patch ID
+        info = validator.validate_patch_id("456-user-authentication")
+        # Returns: PatchInfo(original_id="456-user-authentication",
+        #                   normalized_id="456-user-authentication", ...)
+
+        # Invalid format raises exception
+        try:
+            validator.validate_patch_id("invalid@patch")
+        except InvalidPatchIdError as e:
+            print(f"Invalid patch ID: {e}")
+    """
+
+    # Regex patterns for validation
+    NUMERIC_PATTERN = re.compile(r'^\d+$')
+    FULL_PATTERN = re.compile(r'^\d+-[a-z0-9]+(?:-[a-z0-9]+)*$')
+    DESCRIPTION_PATTERN = re.compile(r'^[a-z0-9]+(?:-[a-z0-9]+)*$')
+
+    def __init__(self):
+        """Initialize patch validator."""
+        pass
+
+    def validate_patch_id(self, patch_id: str) -> PatchInfo:
+        """
+        Validate and parse a patch ID.
+
+        Args:
+            patch_id: The patch identifier to validate
+
+        Returns:
+            PatchInfo object with parsed information
+
+        Raises:
+            InvalidPatchIdError: If patch ID format is invalid
+
+        Examples:
+            # Numeric ID
+            info = validator.validate_patch_id("456")
+            assert info.ticket_number == "456"
+            assert info.is_numeric_only == True
+
+            # Full ID
+            info = validator.validate_patch_id("456-user-auth")
+            assert info.ticket_number == "456"
+            assert info.description == "user-auth"
+            assert info.is_numeric_only == False
+        """
+        if not patch_id or not patch_id.strip():
+            raise InvalidPatchIdError("Patch ID cannot be empty")
+
+        patch_id = patch_id.strip()
+
+        # Check for numeric-only format
+        if self.NUMERIC_PATTERN.match(patch_id):
+            return PatchInfo(
+                original_id=patch_id,
+                normalized_id=patch_id,
+                ticket_number=patch_id,
+                description=None,
+                is_numeric_only=True
+            )
+
+        # Check for full format (number-description)
+        if self.FULL_PATTERN.match(patch_id):
+            parts = patch_id.split('-', 1)
+            ticket_number = parts[0]
+            description = parts[1]
+
+            return PatchInfo(
+                original_id=patch_id,
+                normalized_id=patch_id,
+                ticket_number=ticket_number,
+                description=description,
+                is_numeric_only=False
+            )
+
+        # If we get here, format is invalid
+        if not patch_id[0].isdigit():
+            raise InvalidPatchIdError("Patch ID must start with a ticket number")
+        else:
+            raise InvalidPatchIdError(
+                f"Invalid patch ID format: '{patch_id}'. "
+                f"Expected formats: '123' or '123-description' (lowercase, hyphens only)"
+            )
+
+    def normalize_patch_id(self, patch_id: str, suggested_description: Optional[str] = None) -> str:
+        """
+        Normalize a patch ID to the standard format.
+
+        For numeric IDs, tries to generate a meaningful description.
+        For full IDs, validates format and returns as-is.
+
+        Args:
+            patch_id: The patch identifier to normalize
+            suggested_description: Optional description to use for numeric IDs
+
+        Returns:
+            Normalized patch ID in format "number-description"
+
+        Raises:
+            InvalidPatchIdError: If patch ID format is invalid
+
+        Examples:
+            # Numeric with suggestion
+            result = validator.normalize_patch_id("456", "user-authentication")
+            assert result == "456-user-authentication"
+
+            # Numeric without suggestion (uses fallback)
+            result = validator.normalize_patch_id("456")
+            assert result == "456"  # or "456-feature" based on context
+
+            # Already normalized
+            result = validator.normalize_patch_id("456-existing")
+            assert result == "456-existing"
+        """
+        # First validate the input format
+        patch_info = self.validate_patch_id(patch_id)
+
+        # If it's already in full format, return as-is
+        if not patch_info.is_numeric_only:
+            return patch_info.normalized_id
+
+        # For numeric-only IDs, we need to add a description
+        if suggested_description:
+            # Sanitize the suggested description
+            clean_description = self.sanitize_description(suggested_description)
+            return f"{patch_info.ticket_number}-{clean_description}"
+        else:
+            # Use fallback description
+            fallback_description = self.generate_fallback_description(patch_info.ticket_number)
+            return f"{patch_info.ticket_number}-{fallback_description}"
+
+    def extract_ticket_number(self, patch_id: str) -> Optional[str]:
+        """
+        Extract ticket number from patch ID.
+
+        Args:
+            patch_id: The patch identifier
+
+        Returns:
+            Ticket number if found, None otherwise
+
+        Examples:
+            assert validator.extract_ticket_number("456-auth") == "456"
+            assert validator.extract_ticket_number("456") == "456"
+            assert validator.extract_ticket_number("invalid") is None
+        """
+        if not patch_id or not patch_id.strip():
+            return None
+
+        patch_id = patch_id.strip()
+
+        # Check numeric-only format
+        if self.NUMERIC_PATTERN.match(patch_id):
+            return patch_id
+
+        # Check full format and extract number part
+        if self.FULL_PATTERN.match(patch_id):
+            return patch_id.split('-', 1)[0]
+
+        # Invalid format
+        return None
+
+    def extract_description(self, patch_id: str) -> Optional[str]:
+        """
+        Extract description part from patch ID.
+
+        Args:
+            patch_id: The patch identifier
+
+        Returns:
+            Description if found, None for numeric-only IDs
+
+        Examples:
+            assert validator.extract_description("456-user-auth") == "user-auth"
+            assert validator.extract_description("456") is None
+        """
+        if not patch_id or not patch_id.strip():
+            return None
+
+        patch_id = patch_id.strip()
+
+        # Numeric-only format has no description
+        if self.NUMERIC_PATTERN.match(patch_id):
+            return None
+
+        # Extract description from full format
+        if self.FULL_PATTERN.match(patch_id):
+            parts = patch_id.split('-', 1)
+            return parts[1]  # Return everything after first hyphen
+
+        # Invalid format
+        return None
+
+    def is_valid_description(self, description: str) -> bool:
+        """
+        Check if description part follows naming conventions.
+
+        Args:
+            description: Description to validate
+
+        Returns:
+            True if description is valid, False otherwise
+
+        Examples:
+            assert validator.is_valid_description("user-authentication") == True
+            assert validator.is_valid_description("user_auth") == False  # no underscores
+            assert validator.is_valid_description("UserAuth") == False   # no uppercase
+        """
+        if not description:
+            return False
+
+        # Use the DESCRIPTION_PATTERN regex to validate format
+        return bool(self.DESCRIPTION_PATTERN.match(description))
+
+    def generate_fallback_description(self, ticket_number: str) -> str:
+        """
+        Generate a fallback description for numeric patch IDs.
+
+        Returns a simple default description. Developers should provide
+        meaningful descriptions themselves for better clarity.
+
+        Args:
+            ticket_number: The numeric ticket identifier
+
+        Returns:
+            Default description "patch"
+
+        Examples:
+            desc = validator.generate_fallback_description("456")
+            assert desc == "patch"
+        """
+        return "patch"
+
+    def sanitize_description(self, description: str) -> str:
+        """
+        Sanitize a description to follow naming conventions.
+
+        - Convert to lowercase
+        - Replace spaces/underscores with hyphens
+        - Remove invalid characters
+        - Truncate if too long
+
+        Args:
+            description: Raw description to sanitize
+
+        Returns:
+            Sanitized description following conventions
+
+        Examples:
+            assert validator.sanitize_description("User Authentication") == "user-authentication"
+            assert validator.sanitize_description("user_auth_system") == "user-auth-system"
+            assert validator.sanitize_description("Fix Bug #123") == "fix-bug-123"
+        """
+        if not description:
+            return "patch"
+
+        # Convert to lowercase
+        result = description.lower()
+
+        # Remove accents (transliteration)
+        result = unicodedata.normalize('NFD', result)
+        result = ''.join(c for c in result if unicodedata.category(c) != 'Mn')
+
+        # Replace spaces and underscores with hyphens
+        result = re.sub(r'[\s_]+', '-', result)
+
+        # Replace other separators (dots, @, etc.) with hyphens before removing them
+        result = re.sub(r'[^\w\-]', '-', result)
+
+        # Now remove invalid characters (keep only letters, numbers, hyphens)
+        result = re.sub(r'[^a-z0-9\-]', '', result)
+
+        # Clean up multiple consecutive hyphens
+        result = re.sub(r'-+', '-', result)
+
+        # Remove leading and trailing hyphens
+        result = result.strip('-')
+
+        # If result is empty after cleaning, use fallback
+        if not result:
+            return "patch"
+
+        # Truncate if too long (reasonable limit)
+        if len(result) > 50:
+            result = result[:50].rstrip('-')
+
+        return result

half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql

@@ -0,0 +1,34 @@
+create extension if not exists pgcrypto;
+
+create table if not exists half_orm_meta.database (
+    id text primary key,
+    name text not null,
+    description text
+);
+
+
+create or replace function half_orm_meta.check_database(old_dbid text default null) returns text as $$
+DECLARE
+    dbname text;
+    dbid text;
+BEGIN
+    select current_database() into dbname;
+    --XXX: use a materialized view.
+    BEGIN
+        select encode(hmac(dbname, pg_read_file('hop_key'), 'sha1'), 'hex') into dbid;
+    EXCEPTION
+        when undefined_file then
+            raise NOTICE 'No hop_key file for the cluster. Will use % for dbid', dbname;
+            dbid := dbname;
+    END;
+    if old_dbid is not null and old_dbid != dbid
+    then
+        raise Exception 'Not the same database!';
+    end if;
+    return dbid;
+END;
+$$ language plpgsql;
+
+insert into half_orm_meta.database (id, name) values ((select half_orm_meta.check_database()), (select current_database()));
+
+comment on table half_orm_meta.database is 'id identifies the database in the cluster. It uses the key in hop_key.';

half_orm_dev/patches/0/1/0/01_alter_half_orm_meta.hop_release.sql

@@ -0,0 +1,2 @@
+alter table half_orm_meta.hop_release add column dbid text references half_orm_meta.database(id) on update cascade;
+alter table half_orm_meta.hop_release add column hop_release text;

half_orm_dev/patches/0/1/0/02_half_orm_meta.view.hop_penultimate_release.sql

@@ -0,0 +1,3 @@
+drop view if exists "half_orm_meta.view".hop_penultimate_release;
+create view "half_orm_meta.view".hop_penultimate_release as
+select * from (select major, minor, patch from half_orm_meta.hop_release order by major desc, minor desc, patch desc limit 2 ) as penultimate order by major, minor, patch limit 1;

half_orm_dev/patches/log

@@ -0,0 +1,2 @@
+0.0.26 t581fd33
+0.1.0

half_orm_dev/patches/sql/half_orm_meta.sql

@@ -0,0 +1,208 @@
+--
+-- PostgreSQL database dump
+--
+
+-- Dumped from database version 13.11 (Debian 13.11-1.pgdg110+1)
+-- Dumped by pg_dump version 13.11 (Debian 13.11-1.pgdg110+1)
+
+SET statement_timeout = 0;
+SET lock_timeout = 0;
+SET idle_in_transaction_session_timeout = 0;
+SET client_encoding = 'UTF8';
+SET standard_conforming_strings = on;
+SELECT pg_catalog.set_config('search_path', '', false);
+SET check_function_bodies = false;
+SET xmloption = content;
+SET client_min_messages = warning;
+SET row_security = off;
+
+--
+-- Name: half_orm_meta; Type: SCHEMA; Schema: -; Owner: -
+--
+
+CREATE SCHEMA half_orm_meta;
+
+
+--
+-- Name: half_orm_meta.view; Type: SCHEMA; Schema: -; Owner: -
+--
+
+CREATE SCHEMA "half_orm_meta.view";
+
+
+--
+-- Name: check_database(text); Type: FUNCTION; Schema: half_orm_meta; Owner: -
+--
+
+CREATE FUNCTION half_orm_meta.check_database(old_dbid text DEFAULT NULL::text) RETURNS text
+    LANGUAGE plpgsql
+    AS $$
+DECLARE
+    dbname text;
+    dbid text;
+BEGIN
+    select current_database() into dbname;
+    --XXX: use a materialized view.
+    BEGIN
+        select encode(hmac(dbname, pg_read_file('hop_key'), 'sha1'), 'hex') into dbid;
+    EXCEPTION
+        when undefined_file then
+            raise NOTICE 'No hop_key file for the cluster. Will use % for dbid', dbname;
+            dbid := dbname;
+    END;
+    if old_dbid is not null and old_dbid != dbid
+    then
+        raise Exception 'Not the same database!';
+    end if;
+    return dbid;
+END;
+$$;
+
+
+SET default_tablespace = '';
+
+SET default_table_access_method = heap;
+
+--
+-- Name: database; Type: TABLE; Schema: half_orm_meta; Owner: -
+--
+
+CREATE TABLE half_orm_meta.database (
+    id text NOT NULL,
+    name text NOT NULL,
+    description text
+);
+
+
+--
+-- Name: TABLE database; Type: COMMENT; Schema: half_orm_meta; Owner: -
+--
+
+COMMENT ON TABLE half_orm_meta.database IS '
+id identifies the database in the cluster. It uses the key
+in hop_key.
+';
+
+
+--
+-- Name: hop_release; Type: TABLE; Schema: half_orm_meta; Owner: -
+--
+
+CREATE TABLE half_orm_meta.hop_release (
+    major integer NOT NULL,
+    minor integer NOT NULL,
+    patch integer NOT NULL,
+    pre_release text DEFAULT ''::text NOT NULL,
+    pre_release_num text DEFAULT ''::text NOT NULL,
+    date date DEFAULT CURRENT_DATE,
+    "time" time(0) with time zone DEFAULT CURRENT_TIME,
+    changelog text,
+    commit text,
+    dbid text,
+    hop_release text,
+    CONSTRAINT hop_release_major_check CHECK ((major >= 0)),
+    CONSTRAINT hop_release_minor_check CHECK ((minor >= 0)),
+    CONSTRAINT hop_release_patch_check CHECK ((patch >= 0)),
+    CONSTRAINT hop_release_pre_release_check CHECK ((pre_release = ANY (ARRAY['alpha'::text, 'beta'::text, 'rc'::text, ''::text]))),
+    CONSTRAINT hop_release_pre_release_num_check CHECK (((pre_release_num = ''::text) OR (pre_release_num ~ '^\d+$'::text)))
+);
+
+
+--
+-- Name: hop_release_issue; Type: TABLE; Schema: half_orm_meta; Owner: -
+--
+
+CREATE TABLE half_orm_meta.hop_release_issue (
+    num integer NOT NULL,
+    issue_release integer DEFAULT 0 NOT NULL,
+    release_major integer NOT NULL,
+    release_minor integer NOT NULL,
+    release_patch integer NOT NULL,
+    release_pre_release text NOT NULL,
+    release_pre_release_num text NOT NULL,
+    changelog text,
+    CONSTRAINT hop_release_issue_num_check CHECK ((num >= 0))
+);
+
+
+--
+-- Name: hop_last_release; Type: VIEW; Schema: half_orm_meta.view; Owner: -
+--
+
+CREATE VIEW "half_orm_meta.view".hop_last_release AS
+ SELECT hop_release.major,
+    hop_release.minor,
+    hop_release.patch,
+    hop_release.pre_release,
+    hop_release.pre_release_num,
+    hop_release.date,
+    hop_release."time",
+    hop_release.changelog,
+    hop_release.commit
+   FROM half_orm_meta.hop_release
+  ORDER BY hop_release.major DESC, hop_release.minor DESC, hop_release.patch DESC, hop_release.pre_release DESC, hop_release.pre_release_num DESC
+ LIMIT 1;
+
+
+--
+-- Name: hop_penultimate_release; Type: VIEW; Schema: half_orm_meta.view; Owner: -
+--
+
+CREATE VIEW "half_orm_meta.view".hop_penultimate_release AS
+ SELECT penultimate.major,
+    penultimate.minor,
+    penultimate.patch
+   FROM ( SELECT hop_release.major,
+            hop_release.minor,
+            hop_release.patch
+           FROM half_orm_meta.hop_release
+          ORDER BY hop_release.major DESC, hop_release.minor DESC, hop_release.patch DESC
+         LIMIT 2) penultimate
+  ORDER BY penultimate.major, penultimate.minor, penultimate.patch
+ LIMIT 1;
+
+
+--
+-- Name: database database_pkey; Type: CONSTRAINT; Schema: half_orm_meta; Owner: -
+--
+
+ALTER TABLE ONLY half_orm_meta.database
+    ADD CONSTRAINT database_pkey PRIMARY KEY (id);
+
+
+--
+-- Name: hop_release_issue hop_release_issue_pkey; Type: CONSTRAINT; Schema: half_orm_meta; Owner: -
+--
+
+ALTER TABLE ONLY half_orm_meta.hop_release_issue
+    ADD CONSTRAINT hop_release_issue_pkey PRIMARY KEY (num, issue_release);
+
+
+--
+-- Name: hop_release hop_release_pkey; Type: CONSTRAINT; Schema: half_orm_meta; Owner: -
+--
+
+ALTER TABLE ONLY half_orm_meta.hop_release
+    ADD CONSTRAINT hop_release_pkey PRIMARY KEY (major, minor, patch, pre_release, pre_release_num);
+
+
+--
+-- Name: hop_release hop_release_dbid_fkey; Type: FK CONSTRAINT; Schema: half_orm_meta; Owner: -
+--
+
+ALTER TABLE ONLY half_orm_meta.hop_release
+    ADD CONSTRAINT hop_release_dbid_fkey FOREIGN KEY (dbid) REFERENCES half_orm_meta.database(id) ON UPDATE CASCADE;
+
+
+--
+-- Name: hop_release_issue hop_release_issue_release_major_release_minor_release_patc_fkey; Type: FK CONSTRAINT; Schema: half_orm_meta; Owner: -
+--
+
+ALTER TABLE ONLY half_orm_meta.hop_release_issue
+    ADD CONSTRAINT hop_release_issue_release_major_release_minor_release_patc_fkey FOREIGN KEY (release_major, release_minor, release_patch, release_pre_release, release_pre_release_num) REFERENCES half_orm_meta.hop_release(major, minor, patch, pre_release, pre_release_num);
+
+
+--
+-- PostgreSQL database dump complete
+--
+