half-orm-dev 0.17.3a6__tar.gz → 0.17.3a8__tar.gz

{half_orm_dev-0.17.3a6/half_orm_dev.egg-info → half_orm_dev-0.17.3a8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a6
+Version: 0.17.3a8
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later
@@ -23,7 +23,7 @@ Requires-Dist: GitPython
 Requires-Dist: click
 Requires-Dist: pydash
 Requires-Dist: pytest
-Requires-Dist: half_orm<0.18.0,>=0.17.1
+Requires-Dist: half_orm<0.18.0,>=0.17.3
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Requires-Dist: tomli_w>=1.0.0
 Dynamic: license-file

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8}/half_orm_dev/database.py

@@ -1224,126 +1224,12 @@ class Database:
 
         return complete_params
 
-    @classmethod
-    def _load_configuration(cls, database_name):
-        """
-        Load existing database configuration file, replacing DbConn functionality.
-
-        Reads halfORM configuration file and returns connection parameters as a dictionary.
-        This method completely replaces DbConn.__init() logic, supporting both minimal
-        configurations (PostgreSQL trust mode) and complete parameter sets.
-
-        Args:
-            database_name (str): Name of the database to load configuration for
-
-        Returns:
-            dict | None: Connection parameters dictionary with standardized keys:
-                - name (str): Database name (always present)
-                - user (str): Database user (defaults to $USER environment variable)
-                - password (str): Database password (empty string if not set)
-                - host (str): Database host (empty string for Unix socket, 'localhost' otherwise)
-                - port (int): Database port (5432 if not specified)
-                - production (bool): Production environment flag (defaults to False)
-            Returns None if configuration file doesn't exist.
-
-        Raises:
-            FileNotFoundError: If CONF_DIR doesn't exist or isn't accessible
-            PermissionError: If configuration file exists but isn't readable
-            ValueError: If configuration file format is invalid or corrupted
-
-        Examples:
-            # Complete configuration file
-            config = Database._load_configuration("production_db")
-            # Returns: {'name': 'production_db', 'user': 'app_user', 'password': 'secret',
-            #           'host': 'db.company.com', 'port': 5432, 'production': True}
-
-            # Minimal trust mode configuration (only name=database_name)
-            config = Database._load_configuration("local_dev")
-            # Returns: {'name': 'local_dev', 'user': 'joel', 'password': '',
-            #           'host': '', 'port': 5432, 'production': False}
-
-            # Non-existent configuration
-            config = Database._load_configuration("unknown_db")
-            # Returns: None
-
-        Migration Notes:
-            - Completely replaces DbConn.__init() and DbConn.__init logic
-            - Maintains backward compatibility with existing config files
-            - Standardizes return format (int for port, bool for production)
-            - Integrates PostgreSQL trust mode defaults directly into Database class
-            - Eliminates external DbConn dependency while preserving all functionality
-        """
-        from half_orm.model import CONF_DIR
-
-        # Check if configuration directory exists
-        if not os.path.exists(CONF_DIR):
-            raise FileNotFoundError(f"Configuration directory {CONF_DIR} doesn't exist")
-
-        # Build configuration file path
-        config_file = os.path.join(CONF_DIR, database_name)
-
-        # Return None if configuration file doesn't exist
-        if not os.path.exists(config_file):
-            return None
-
-        # Check if file is readable before attempting to parse
-        if not os.access(config_file, os.R_OK):
-            raise PermissionError(f"Configuration file {config_file} is not readable")
-
-        # Read configuration file
-        config = ConfigParser()
-        try:
-            config.read(config_file)
-        except Exception as e:
-            raise ValueError(f"Configuration file format is invalid: {e}")
-
-        # Check if [database] section exists
-        if not config.has_section('database'):
-            raise ValueError("Configuration file format is invalid: missing [database] section")
-
-        # Extract configuration values with PostgreSQL defaults
-        try:
-            name = config.get('database', 'name')
-            user = config.get('database', 'user', fallback=os.environ.get('USER', ''))
-            password = config.get('database', 'password', fallback='')
-            host = config.get('database', 'host', fallback='')
-            port_str = config.get('database', 'port', fallback='')
-            production_str = config.get('database', 'production', fallback='False')
-            docker_container = config.get('database', 'docker_container', fallback='')
-
-            # Convert port to int (default 5432 if empty)
-            if port_str == '':
-                port = 5432
-            else:
-                port = int(port_str)
-
-            # Convert production to bool
-            production = config.getboolean('database', 'production', fallback=False)
-
-            return {
-                'name': name,
-                'user': user,
-                'password': password,
-                'host': host,
-                'port': port,
-                'production': production,
-                'docker_container': docker_container
-            }
-
-        except (ValueError, TypeError) as e:
-            raise ValueError(f"Configuration file format is invalid: {e}")
-
     def _get_connection_params(self):
         """
         Get current connection parameters for this database instance.
 
-        Returns the connection parameters dictionary for this Database instance,
-        replacing direct access to DbConn properties. This method serves as the
-        unified interface for accessing connection parameters during the migration
-        from DbConn to integrated Database functionality.
-
-        Uses instance-level caching to avoid repeated file reads within the same
-        Database instance lifecycle.
+        Returns the connection parameters dictionary using Model._dbinfo,
+        which is already loaded by half_orm from the configuration file.
 
         Returns:
             dict: Connection parameters dictionary with standardized keys:
@@ -1353,59 +1239,37 @@ class Database:
                 - host (str): Database host (empty string for Unix socket)
                 - port (int): Database port (5432 default)
                 - production (bool): Production environment flag
-            Returns dict with defaults if no configuration exists or errors occur.
-
-        Examples:
-            # Get connection parameters for existing database instance
-            db = Database(repo)
-            params = db._get_connection_params()
-            # Returns: {'name': 'my_db', 'user': 'dev', 'password': '',
-            #           'host': 'localhost', 'port': 5432, 'production': False}
-
-            # Access specific parameters (replaces DbConn.property access)
-            user = db._get_connection_params()['user']      # replaces self.__connection_params.user
-            host = db._get_connection_params()['host']      # replaces self.__connection_params.host
-            prod = db._get_connection_params()['production'] # replaces self.__connection_params.production
-
-        Implementation Notes:
-            - Uses _load_configuration() internally but handles all exceptions
-            - Provides stable interface - never raises exceptions
-            - Returns sensible defaults if configuration is missing/invalid
-            - Serves as protective wrapper around _load_configuration()
-            - Exceptions from _load_configuration() are caught and handled gracefully
-            - Uses instance-level cache to avoid repeated file reads
-
-        Migration Notes:
-            - Replaces self.__connection_params.user, .host, .port, .production access
-            - Serves as transition method during DbConn elimination
-            - Maintains compatibility with existing Database instance usage patterns
-            - Will be used by state, production, and execute_pg_command properties
+                - docker_container (str): Docker container name (if configured)
         """
         # Return cached parameters if already loaded
         if hasattr(self, '_Database__connection_params_cache') and self.__connection_params_cache is not None:
             return self.__connection_params_cache
 
-        # Load configuration with defaults
+        # Use connection info from Model._dbinfo (already loaded by half_orm)
+        if self.__model is not None and hasattr(self.__model, '_dbinfo'):
+            dbinfo = self.__model._dbinfo
+            config = {
+                'name': self.__repo.name,
+                'user': dbinfo.get('user', os.environ.get('USER', '')),
+                'password': dbinfo.get('password', ''),
+                'host': dbinfo.get('host', ''),
+                'port': int(dbinfo.get('port', 5432) or 5432),
+                'production': not self.__model._production_mode,  # devel=False means production
+                'docker_container': dbinfo.get('docker_container', ''),
+            }
+            self.__connection_params_cache = config
+            return config
+
+        # Fallback: defaults (should not happen in normal usage)
         config = {
             'name': self.__repo.name,
             'user': os.environ.get('USER', ''),
             'password': '',
             'host': '',
             'port': 5432,
-            'production': False
+            'production': False,
+            'docker_container': '',
         }
-
-        try:
-            # Try to load configuration for this database
-            loaded_config = self._load_configuration(self.__repo.name)
-            if loaded_config is not None:
-                config = loaded_config
-        except (FileNotFoundError, PermissionError, ValueError):
-            # Handle all possible exceptions from _load_configuration gracefully
-            # Return sensible defaults to maintain stable interface
-            pass
-
-        # Cache the result for subsequent calls
         self.__connection_params_cache = config
         return config
 

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8}/half_orm_dev/repo.py

@@ -1199,10 +1199,7 @@ class Repo:
         # Step 1b: Validate git origin URL (EARLY validation)
         self._validate_git_origin_url(git_origin)
 
-        # Step 2: Check database configuration exists
-        self._verify_database_configured(package_name)
-
-        # Step 3: Connect to database and detect mode
+        # Step 2: Connect to database and detect mode
         devel_mode = self._detect_development_mode(package_name)
 
         # Step 4: Setup project directory
@@ -1645,56 +1642,6 @@ class Repo:
         # Store normalized name for later use
         return normalized_name
 
-
-    def _verify_database_configured(self, package_name):
-        """
-        Verify database is configured via init-database command.
-
-        Checks that database configuration file exists and is accessible.
-        Does NOT create the database - assumes init-database was run first.
-
-        Args:
-            package_name (str): Database name to verify
-
-        Raises:
-            DatabaseNotConfiguredError: If configuration file doesn't exist
-            DatabaseConnectionError: If cannot connect to configured database
-
-        Process:
-            1. Check ~/.half_orm/<package_name> exists
-            2. Attempt connection to verify database is accessible
-            3. Store connection for later use
-
-        Examples:
-            # Database configured
-            _verify_database_configured("my_blog")  # Success
-
-            # Database not configured
-            _verify_database_configured("unconfigured_db")
-            # Raises: DatabaseNotConfiguredError with helpful message
-        """
-        # Try to load database configuration
-        config = Database._load_configuration(package_name)
-
-        if config is None:
-            raise ValueError(
-                f"Database '{package_name}' is not configured.\n"
-                f"Please run: half_orm dev init-database {package_name} [OPTIONS]\n"
-                f"See 'half_orm dev init-database --help' for more information."
-            )
-
-        # Try to connect to verify database is accessible
-        try:
-            model = Model(package_name)
-            # Store model for later use
-            return model
-        except OperationalError as e:
-            raise OperationalError(
-                f"Cannot connect to database '{package_name}'.\n"
-                f"Database may not exist or connection parameters may be incorrect.\n"
-                f"Original error: {e}"
-            )
-
     def _detect_development_mode(self, package_name):
         """
         Detect development mode based on metadata presence in database.

half_orm_dev-0.17.3a8/half_orm_dev/scripts/repair-metadata.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Repair script for half-orm-dev metadata files.
+
+This script regenerates all metadata-X.Y.Z.sql files with correct hop_release
+entries by:
+1. Clearing half_orm_meta.hop_release (keeping only 0.0.0)
+2. For each version tag (vX.Y.Z or vX.Y.Z-rcN):
+   - Insert the version with the tag's date
+   - Generate metadata-X.Y.Z.sql (or metadata-X.Y.Z-rcN.sql)
+
+Usage:
+    cd /path/to/your/project
+    python /path/to/half-orm-dev/scripts/repair-metadata.py [--dry-run]
+
+Options:
+    --dry-run    Show what would be done without modifying anything
+    --verbose    Show detailed information
+"""
+
+import argparse
+import re
+import subprocess
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+
+def get_version_tags() -> List[Tuple[str, str, datetime]]:
+    """
+    Get all version tags with their dates from git.
+
+    Returns:
+        List of (tag_name, version_string, date) tuples sorted by version.
+        tag_name: e.g., "v0.1.0", "v0.1.0-rc1"
+        version_string: e.g., "0.1.0", "0.1.0-rc1"
+        date: datetime object
+    """
+    result = subprocess.run(
+        ['git', 'tag', '--format=%(refname:short) %(creatordate:iso)'],
+        capture_output=True, text=True, check=True
+    )
+
+    tags = []
+    for line in result.stdout.strip().split('\n'):
+        if not line.strip():
+            continue
+
+        parts = line.split(' ', 1)
+        if len(parts) != 2:
+            continue
+
+        tag_name, date_str = parts
+
+        # Match vX.Y.Z or vX.Y.Z-rcN
+        match = re.match(r'^v(\d+\.\d+\.\d+(?:-rc\d+)?)$', tag_name)
+        if not match:
+            continue
+
+        version_str = match.group(1)
+
+        # Parse date (format: "2025-11-21 15:09:14 +0100")
+        try:
+            # Remove timezone for simpler parsing
+            date_part = ' '.join(date_str.split()[:2])
+            date = datetime.strptime(date_part, '%Y-%m-%d %H:%M:%S')
+        except ValueError:
+            continue
+
+        tags.append((tag_name, version_str, date))
+
+    # Sort by version (handle X.Y.Z and X.Y.Z-rcN)
+    def version_key(item):
+        version_str = item[1]
+        # Split base version and rc part
+        if '-rc' in version_str:
+            base, rc = version_str.split('-rc')
+            rc_num = int(rc)
+        else:
+            base = version_str
+            rc_num = 9999  # Production comes after all RCs
+
+        parts = [int(p) for p in base.split('.')]
+        return (*parts, rc_num)
+
+    return sorted(tags, key=version_key)
+
+
+def parse_version_string(version_str: str) -> Tuple[int, int, int, str, str]:
+    """
+    Parse version string into components.
+
+    Args:
+        version_str: e.g., "0.1.0" or "0.1.0-rc1"
+
+    Returns:
+        Tuple of (major, minor, patch, pre_release, pre_release_num)
+    """
+    if '-rc' in version_str:
+        base, rc = version_str.split('-rc')
+        pre_release = 'rc'
+        pre_release_num = rc
+    else:
+        base = version_str
+        pre_release = ''
+        pre_release_num = ''
+
+    parts = base.split('.')
+    return (int(parts[0]), int(parts[1]), int(parts[2]), pre_release, pre_release_num)
+
+
+def find_model_dir() -> Optional[Path]:
+    """Find the .hop/model directory in current working directory."""
+    cwd = Path.cwd()
+    model_dir = cwd / ".hop" / "model"
+
+    if model_dir.is_dir():
+        return model_dir
+    return None
+
+
+def get_database_name() -> Optional[str]:
+    """Get database name from half_orm config."""
+    try:
+        from half_orm.model import Model
+        model = Model._model
+        if model:
+            return model._dbname
+    except:
+        pass
+
+    # Try reading from .hop/config
+    config_path = Path.cwd() / ".hop" / "config"
+    if config_path.exists():
+        import configparser
+        config = configparser.ConfigParser()
+        config.read(config_path)
+        if 'database' in config and 'name' in config['database']:
+            return config['database']['name']
+
+    return None
+
+
+def clear_hop_release_table(db_name: str, dry_run: bool = False) -> None:
+    """
+    Clear hop_release table keeping only 0.0.0.
+
+    Args:
+        db_name: Database name
+        dry_run: If True, only show what would be done
+    """
+    sql = "DELETE FROM half_orm_meta.hop_release WHERE NOT (major = 0 AND minor = 0 AND patch = 0);"
+
+    if dry_run:
+        print(f"Would execute: {sql}")
+        return
+
+    subprocess.run(
+        ['psql', '-d', db_name, '-c', sql],
+        check=True, capture_output=True
+    )
+
+
+def insert_version(db_name: str, major: int, minor: int, patch: int,
+                   pre_release: str, pre_release_num: str,
+                   date: datetime, dry_run: bool = False) -> None:
+    """
+    Insert a version into hop_release table.
+
+    Args:
+        db_name: Database name
+        major, minor, patch: Version components
+        pre_release: 'rc' or ''
+        pre_release_num: RC number or ''
+        date: Release date
+        dry_run: If True, only show what would be done
+    """
+    date_str = date.strftime('%Y-%m-%d')
+    time_str = date.strftime('%H:%M:%S')
+
+    sql = f"""INSERT INTO half_orm_meta.hop_release
+              (major, minor, patch, pre_release, pre_release_num, date, time)
+              VALUES ({major}, {minor}, {patch}, '{pre_release}', '{pre_release_num}', '{date_str}', '{time_str}');"""
+
+    if dry_run:
+        print(f"Would execute: {sql}")
+        return
+
+    subprocess.run(
+        ['psql', '-d', db_name, '-c', sql],
+        check=True, capture_output=True
+    )
+
+
+def generate_metadata_file(db_name: str, version_str: str, model_dir: Path,
+                           dry_run: bool = False) -> Path:
+    """
+    Generate metadata-X.Y.Z.sql file using pg_dump.
+
+    Only keeps COPY blocks to avoid version-specific SET commands
+    and ensure compatibility across PostgreSQL versions.
+
+    Args:
+        db_name: Database name
+        version_str: Version string (e.g., "0.1.0" or "0.1.0-rc1")
+        model_dir: Path to model directory
+        dry_run: If True, only show what would be done
+
+    Returns:
+        Path to generated file
+    """
+    metadata_file = model_dir / f"metadata-{version_str}.sql"
+
+    if dry_run:
+        print(f"Would generate: {metadata_file}")
+        return metadata_file
+
+    # Dump to stdout
+    result = subprocess.run([
+        'pg_dump', db_name,
+        '--data-only',
+        '--table=half_orm_meta.database',
+        '--table=half_orm_meta.hop_release',
+        '--table=half_orm_meta.hop_release_issue',
+    ], check=True, capture_output=True, text=True)
+
+    # Filter to keep only COPY blocks (COPY ... FROM stdin; ... \.)
+    filtered_lines = []
+    in_copy_block = False
+    for line in result.stdout.split('\n'):
+        if line.startswith('COPY '):
+            in_copy_block = True
+        if in_copy_block:
+            filtered_lines.append(line)
+        if line == '\\.':
+            in_copy_block = False
+            filtered_lines.append('')  # Empty line between blocks
+
+    metadata_file.write_text('\n'.join(filtered_lines))
+
+    return metadata_file
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Regenerate half-orm-dev metadata files from git tags.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__
+    )
+    parser.add_argument(
+        '--dry-run',
+        action='store_true',
+        help='Show what would be done without modifying anything'
+    )
+    parser.add_argument(
+        '--verbose',
+        action='store_true',
+        help='Show detailed information'
+    )
+    parser.add_argument(
+        '--database',
+        type=str,
+        help='Database name (auto-detected if not specified)'
+    )
+    parser.add_argument(
+        '--model-dir',
+        type=Path,
+        help='Path to model directory (default: .hop/model)'
+    )
+
+    args = parser.parse_args()
+
+    # Find model directory
+    if args.model_dir:
+        model_dir = args.model_dir
+    else:
+        model_dir = find_model_dir()
+
+    if model_dir is None or not model_dir.is_dir():
+        print("Error: Could not find .hop/model directory", file=sys.stderr)
+        print("Make sure you're in a half-orm-dev managed project directory", file=sys.stderr)
+        sys.exit(1)
+
+    # Get database name
+    db_name = args.database or get_database_name()
+    if not db_name:
+        print("Error: Could not determine database name", file=sys.stderr)
+        print("Use --database option to specify it", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Model directory: {model_dir}")
+    print(f"Database: {db_name}")
+    print()
+
+    if args.dry_run:
+        print("=== DRY RUN MODE - No changes will be made ===")
+        print()
+
+    # Get version tags
+    tags = get_version_tags()
+
+    if not tags:
+        print("No version tags found (expected format: vX.Y.Z or vX.Y.Z-rcN)")
+        sys.exit(0)
+
+    print(f"Found {len(tags)} version tags")
+    print()
+
+    # Step 1: Clear hop_release table (keep 0.0.0)
+    print("Step 1: Clearing hop_release table (keeping 0.0.0)...")
+    clear_hop_release_table(db_name, dry_run=args.dry_run)
+    print("  Done")
+    print()
+
+    # Step 2: Process each version
+    print("Step 2: Processing versions...")
+    for tag_name, version_str, date in tags:
+        major, minor, patch, pre_release, pre_release_num = parse_version_string(version_str)
+
+        if args.verbose:
+            print(f"  {tag_name} -> {version_str} ({date})")
+
+        # Insert version with correct date
+        insert_version(
+            db_name, major, minor, patch,
+            pre_release, pre_release_num, date,
+            dry_run=args.dry_run
+        )
+
+        # Generate metadata file
+        metadata_file = generate_metadata_file(
+            db_name, version_str, model_dir,
+            dry_run=args.dry_run
+        )
+
+        print(f"  ✓ {version_str} ({date.strftime('%Y-%m-%d')})")
+
+    print()
+    print("=" * 50)
+    print(f"Summary:")
+    print(f"  Versions processed: {len(tags)}")
+
+    if not args.dry_run:
+        print()
+        print("Next steps:")
+        print("  1. Review the changes: git status")
+        print("  2. Commit: git add .hop/model/metadata-*.sql && git commit -m 'fix: regenerate metadata files'")
+
+
+if __name__ == "__main__":
+    main()

half_orm_dev-0.17.3a8/half_orm_dev/version.txt

@@ -0,0 +1 @@
+0.17.3-a8

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8/half_orm_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a6
+Version: 0.17.3a8
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later
@@ -23,7 +23,7 @@ Requires-Dist: GitPython
 Requires-Dist: click
 Requires-Dist: pydash
 Requires-Dist: pytest
-Requires-Dist: half_orm<0.18.0,>=0.17.1
+Requires-Dist: half_orm<0.18.0,>=0.17.3
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Requires-Dist: tomli_w>=1.0.0
 Dynamic: license-file

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8}/half_orm_dev.egg-info/SOURCES.txt

@@ -45,6 +45,7 @@ half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql
 half_orm_dev/patches/0/1/0/01_alter_half_orm_meta.hop_release.sql
 half_orm_dev/patches/0/1/0/02_half_orm_meta.view.hop_penultimate_release.sql
 half_orm_dev/patches/sql/half_orm_meta.sql
+half_orm_dev/scripts/repair-metadata.py
 half_orm_dev/templates/.gitignore
 half_orm_dev/templates/MANIFEST.in
 half_orm_dev/templates/Pipfile

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8}/half_orm_dev.egg-info/requires.txt

@@ -2,7 +2,7 @@ GitPython
 click
 pydash
 pytest
-half_orm<0.18.0,>=0.17.1
+half_orm<0.18.0,>=0.17.3
 tomli_w>=1.0.0
 
 [:python_version < "3.11"]

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8}/pyproject.toml

@@ -47,6 +47,7 @@ half_orm_dev = [
     "templates/.gitignore",
     "db_patch_system/*",
     "patches/**/*",
+    "scripts/*",
     "version.txt"
 ]
 

{half_orm_dev-0.17.3a6 → half_orm_dev-0.17.3a8}/setup.py

@@ -16,7 +16,7 @@ from setuptools import setup
 # Example: (0, 17, 3, 5, '0.17.1') means:
 #   for half_orm_dev 0.17.x where 3 <= x < 5, require half_orm >= 0.17.1
 HALF_ORM_MIN_VERSIONS = [
-    (0, 17, 3, None, '0.17.1'),  # 0.17.3+ requires half_orm >= 0.17.1 (CustomGroup support)
+    (0, 17, 3, None, '0.17.3'),  # 0.17.3+ requires half_orm >= 0.17.3 (CustomGroup support)
 ]
 
 

half_orm_dev-0.17.3a6/half_orm_dev/version.txt

@@ -1 +0,0 @@
-0.17.3-a6