valuesets 0.3.1__py3-none-any.whl

valuesets/generators/auto_slot_injector.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+"""
+Automatically inject slot definitions for enums into LinkML schemas.
+
+This script can:
+1. Add a slots section to schemas that define enums
+2. Generate appropriate slot definitions with correct ranges
+3. Optionally create mixin classes that bundle related slots
+"""
+
+import yaml
+from pathlib import Path
+from typing import Dict, Any, List, Optional, Set
+import re
+import click
+from collections import OrderedDict
+
+
+class SlotInjector:
+    """Utility to inject slots for enums into LinkML schemas."""
+
+    @staticmethod
+    def camel_to_snake(name: str) -> str:
+        """Convert CamelCase to snake_case."""
+        s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+        return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+    @staticmethod
+    def snake_to_words(name: str) -> str:
+        """Convert snake_case to human readable words."""
+        return name.replace('_', ' ')
+
+    def generate_slot_name(self, enum_name: str) -> str:
+        """Generate slot name from enum name."""
+        # Remove common suffixes
+        slot_name = enum_name
+        for suffix in ['Enum', 'Type', 'Class', 'Code']:
+            if slot_name.endswith(suffix):
+                slot_name = slot_name[:-len(suffix)]
+                break
+
+        return self.camel_to_snake(slot_name)
+
+    def generate_slot_definition(self, enum_name: str,
+                                enum_def: Dict[str, Any]) -> Dict[str, Any]:
+        """Generate a complete slot definition for an enum."""
+        slot_name = self.generate_slot_name(enum_name)
+
+        # Extract description from enum
+        enum_desc = enum_def.get('description', '')
+        if enum_desc:
+            # Clean up multi-line descriptions
+            enum_desc = ' '.join(enum_desc.split())
+            # Get first sentence
+            first_sentence = enum_desc.split('.')[0]
+            slot_desc = first_sentence[:1].upper() + first_sentence[1:] if first_sentence else ''
+        else:
+            # Generate generic description
+            readable_name = self.snake_to_words(slot_name)
+            slot_desc = f"The {readable_name} classification"
+
+        slot_def = {
+            'description': slot_desc,
+            'range': enum_name
+        }
+
+        # Check if enum has many values (might be multivalued)
+        if 'permissible_values' in enum_def:
+            num_values = len(enum_def['permissible_values'])
+            # If it's a target/feature/metric type enum, might be multivalued
+            if any(keyword in slot_name for keyword in ['target', 'feature', 'metric', 'constraint']):
+                slot_def['multivalued'] = True
+                slot_def['comments'] = [f"Multiple {self.snake_to_words(slot_name)}s may apply"]
+
+        return slot_def
+
+    def inject_slots_into_schema(self, schema_path: Path,
+                                output_path: Optional[Path] = None,
+                                preserve_existing: bool = True) -> Dict[str, Any]:
+        """
+        Inject slots into a schema file.
+
+        Args:
+            schema_path: Path to the input schema
+            output_path: Path to write modified schema (if None, prints to stdout)
+            preserve_existing: If True, don't override existing slots
+
+        Returns:
+            Dictionary of generated slots
+        """
+        # Load schema
+        with open(schema_path, 'r') as f:
+            schema_data = yaml.safe_load(f)
+
+        # Skip if no enums
+        if 'enums' not in schema_data:
+            return {}
+
+        # Initialize or get existing slots
+        if 'slots' not in schema_data:
+            schema_data['slots'] = {}
+
+        generated_slots = {}
+
+        # Generate slots for each enum
+        for enum_name, enum_def in schema_data['enums'].items():
+            slot_name = self.generate_slot_name(enum_name)
+
+            # Skip if exists and preserving
+            if preserve_existing and slot_name in schema_data['slots']:
+                continue
+
+            slot_def = self.generate_slot_definition(enum_name, enum_def)
+            generated_slots[slot_name] = slot_def
+            schema_data['slots'][slot_name] = slot_def
+
+        # Write output
+        if output_path:
+            self.write_schema(schema_data, output_path)
+        else:
+            # Just return for preview
+            return generated_slots
+
+        return generated_slots
+
+    def write_schema(self, schema_data: Dict[str, Any], output_path: Path):
+        """Write schema preserving key order."""
+        # Define preferred key order
+        key_order = [
+            'name', 'title', 'description', 'id', 'version', 'status',
+            'imports', 'prefixes', 'default_prefix', 'default_curi_maps',
+            'slots', 'classes', 'enums'
+        ]
+
+        # Create ordered dict
+        ordered_data = OrderedDict()
+
+        # Add keys in preferred order
+        for key in key_order:
+            if key in schema_data:
+                ordered_data[key] = schema_data[key]
+
+        # Add any remaining keys
+        for key in schema_data:
+            if key not in ordered_data:
+                ordered_data[key] = schema_data[key]
+
+        # Write with nice formatting
+        with open(output_path, 'w') as f:
+            yaml.dump(dict(ordered_data), f,
+                     default_flow_style=False,
+                     sort_keys=False,
+                     allow_unicode=True,
+                     width=120)
+
+    def generate_typed_slots_schema(self, schema_dir: Path,
+                                   output_path: Path) -> None:
+        """
+        Generate a comprehensive slots schema from all enums in a directory.
+
+        This creates a single schema file with all slot definitions that
+        reference the appropriate enums.
+        """
+        all_slots = {}
+        enum_to_module = {}  # Track which module each enum comes from
+
+        # Scan all schema files
+        yaml_files = list(schema_dir.rglob("*.yaml"))
+
+        for yaml_file in yaml_files:
+            # Skip meta files
+            if yaml_file.name in ['linkml-meta.yaml', 'types.yaml', 'slot_mixins.yaml']:
+                continue
+
+            try:
+                with open(yaml_file, 'r') as f:
+                    schema_data = yaml.safe_load(f)
+
+                if 'enums' not in schema_data:
+                    continue
+
+                # Get module name from schema
+                module_name = schema_data.get('name', yaml_file.stem)
+
+                # Process each enum
+                for enum_name, enum_def in schema_data['enums'].items():
+                    slot_name = self.generate_slot_name(enum_name)
+                    slot_def = self.generate_slot_definition(enum_name, enum_def)
+
+                    # Add module reference
+                    slot_def['comments'] = slot_def.get('comments', [])
+                    slot_def['comments'].append(f"Defined in module: {module_name}")
+
+                    all_slots[slot_name] = slot_def
+                    enum_to_module[enum_name] = module_name
+
+            except Exception as e:
+                print(f"Error processing {yaml_file}: {e}")
+                continue
+
+        # Create comprehensive slots schema
+        slots_schema = {
+            'name': 'generated_slots',
+            'title': 'Auto-generated Slots for Value Sets',
+            'description': 'Automatically generated slot definitions for all enums in the value sets collection.',
+            'id': 'https://w3id.org/linkml-common/generated-slots',
+            'version': '1.0.0',
+            'status': 'release',
+            'imports': ['linkml:types'],
+            'prefixes': {
+                'linkml': 'https://w3id.org/linkml/',
+                'cval': 'https://w3id.org/linkml-common/'
+            },
+            'default_prefix': 'cval',
+            'default_curi_maps': ['semweb_context'],
+            'slots': all_slots
+        }
+
+        # Write the slots schema
+        self.write_schema(slots_schema, output_path)
+        print(f"Generated {len(all_slots)} slot definitions in {output_path}")
+
+
+@click.command()
+@click.argument('schema_path', type=click.Path(exists=True, path_type=Path))
+@click.option('--output', '-o', type=click.Path(path_type=Path),
+              help='Output path for modified schema or generated slots file')
+@click.option('--mode', '-m',
+              type=click.Choice(['inject', 'generate', 'preview']),
+              default='preview',
+              help='Mode: inject (modify files), generate (create slots file), preview (dry run)')
+@click.option('--preserve/--overwrite', default=True,
+              help='Preserve existing slots when injecting')
+def main(schema_path: Path, output: Optional[Path], mode: str, preserve: bool):
+    """
+    Generate or inject LinkML slots for enums.
+
+    SCHEMA_PATH: Path to schema file or directory
+    """
+    injector = SlotInjector()
+
+    if mode == 'inject':
+        if schema_path.is_file():
+            # Single file injection
+            if not output:
+                output = schema_path  # In-place modification
+            slots = injector.inject_slots_into_schema(
+                schema_path, output, preserve_existing=preserve
+            )
+            print(f"Injected {len(slots)} slots into {output}")
+        else:
+            print("Inject mode requires a single file. Use generate mode for directories.")
+
+    elif mode == 'generate':
+        if schema_path.is_dir():
+            # Generate comprehensive slots file
+            if not output:
+                output = schema_path / 'generated_slots.yaml'
+            injector.generate_typed_slots_schema(schema_path, output)
+        else:
+            print("Generate mode requires a directory.")
+
+    elif mode == 'preview':
+        # Preview mode - just show what would be generated
+        if schema_path.is_file():
+            slots = injector.inject_slots_into_schema(
+                schema_path, None, preserve_existing=preserve
+            )
+            print(f"Would generate {len(slots)} slots:")
+            for slot_name, slot_def in slots.items():
+                print(f"  - {slot_name}: {slot_def.get('description', 'No description')}")
+                print(f"    Range: {slot_def.get('range')}")
+                if slot_def.get('multivalued'):
+                    print(f"    Multivalued: true")
+        else:
+            print("Preview mode requires a single file.")
+
+
+if __name__ == '__main__':
+    main()

valuesets/generators/enhanced_pydantic_generator.py

@@ -0,0 +1,100 @@
+"""
+Enhanced Pydantic Generator that includes metadata (meanings, annotations) for enum values.
+
+This custom generator extends the LinkML PydanticGenerator to pass additional
+metadata fields to the templates, enabling rich enum generation with ontology
+mappings and annotations.
+"""
+
+from typing import Dict, Any, Optional
+from dataclasses import dataclass
+from linkml.generators.pydanticgen import PydanticGenerator
+from linkml.generators.pydanticgen.template import PydanticEnum, EnumValue
+from linkml_runtime.linkml_model.meta import EnumDefinition, PermissibleValue
+
+
+@dataclass
+class EnhancedEnumValue(EnumValue):
+    """Extended EnumValue that includes meaning and annotations fields."""
+    meaning: Optional[str] = None
+    annotations: Optional[Dict[str, Any]] = None
+
+
+class EnhancedPydanticGenerator(PydanticGenerator):
+    """
+    Enhanced Pydantic generator that preserves enum metadata.
+    
+    This generator extends the base PydanticGenerator to include
+    meaning (ontology mappings) and annotations in the enum template context.
+    """
+    
+    def generate_enums(self) -> None:
+        """Generate enums with enhanced metadata."""
+        enums = self.schemaview.all_enums()
+        
+        for enum_name, enum_def in enums.items():
+            if enum_def.permissible_values:
+                # Create enhanced enum values with metadata
+                enum_values = {}
+                for pv_name, pv in enum_def.permissible_values.items():
+                    # Convert permissible value to enhanced enum value
+                    label = self._get_enum_label(pv_name, pv)
+                    value = pv.text if pv.text is not None else pv_name
+                    
+                    # Create enhanced enum value with all metadata
+                    enhanced_value = EnhancedEnumValue(
+                        label=label,
+                        value=value,
+                        description=pv.description,
+                        meaning=pv.meaning,
+                        annotations=dict(pv.annotations) if pv.annotations else None
+                    )
+                    enum_values[pv_name] = enhanced_value
+                
+                # Create the enum with enhanced values
+                enum_model = PydanticEnum(
+                    name=self._get_class_name(enum_name),
+                    description=enum_def.description,
+                    values=enum_values
+                )
+                
+                # Add to the module's enums
+                self.enums[enum_name] = enum_model
+    
+    def _get_enum_label(self, pv_name: str, pv: PermissibleValue) -> str:
+        """Get the label for an enum value."""
+        # Use the same logic as the base generator
+        if hasattr(self, 'camelcase_enums') and self.camelcase_enums:
+            from linkml.utils.formatutils import camelcase
+            return camelcase(pv_name)
+        else:
+            # Convert to valid Python identifier
+            import re
+            label = re.sub(r'[^a-zA-Z0-9_]', '_', pv_name)
+            if label[0].isdigit():
+                label = f'_{label}'
+            return label
+    
+    def _get_class_name(self, name: str) -> str:
+        """Get the class name for an enum."""
+        # Use the base generator's logic if available
+        if hasattr(super(), '_get_class_name'):
+            return super()._get_class_name(name)
+        else:
+            # Default: just return the name as-is
+            return name
+
+
+def generate_enhanced_pydantic(schema_path: str, **kwargs) -> str:
+    """
+    Generate enhanced Pydantic models with metadata-rich enums.
+    
+    Args:
+        schema_path: Path to the LinkML schema file
+        **kwargs: Additional arguments to pass to the generator
+        
+    Returns:
+        Generated Python code as a string
+    """
+    generator = EnhancedPydanticGenerator(schema_path, **kwargs)
+    return generator.serialize()

valuesets/generators/enum_slot_generator.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""
+Utility to generate LinkML slots for each enum in a schema.
+
+For each enum, creates a corresponding slot with:
+- Slot name: enum name (removing 'Enum' suffix if present)
+- Range: the enum itself
+- Description: auto-generated from enum description
+"""
+
+import yaml
+from pathlib import Path
+from typing import Dict, Any, List, Optional
+import re
+import click
+from linkml_runtime.utils.schemaview import SchemaView
+from linkml_runtime.linkml_model import SchemaDefinition
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert CamelCase to snake_case."""
+    # Insert underscore before uppercase letters that follow lowercase letters
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', name)
+    # Insert underscore before uppercase letters that follow lowercase or uppercase letters
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+
+def generate_slot_name(enum_name: str) -> str:
+    """
+    Generate a slot name from an enum name.
+
+    Rules:
+    - Remove 'Enum' suffix if present
+    - Remove 'Type' suffix if present
+    - Convert to snake_case
+    """
+    # Remove common suffixes
+    slot_name = enum_name
+    if slot_name.endswith('Enum'):
+        slot_name = slot_name[:-4]
+    elif slot_name.endswith('Type'):
+        slot_name = slot_name[:-4]
+
+    # Convert to snake_case
+    return camel_to_snake(slot_name)
+
+
+def generate_slot_description(enum_name: str, enum_desc: Optional[str]) -> str:
+    """Generate a description for the slot based on the enum."""
+    if enum_desc:
+        # Use first sentence of enum description
+        first_sentence = enum_desc.split('.')[0]
+        return f"The {generate_slot_name(enum_name).replace('_', ' ')} classification"
+    else:
+        return f"The {generate_slot_name(enum_name).replace('_', ' ')} for this entity"
+
+
+def generate_slots_for_schema(schema_path: Path, in_place: bool = False,
+                            output_path: Optional[Path] = None) -> Dict[str, Any]:
+    """
+    Generate slots for all enums in a schema.
+
+    Args:
+        schema_path: Path to the LinkML schema YAML file
+        in_place: If True, modify the schema file in place
+        output_path: If provided, write to this path instead
+
+    Returns:
+        Dictionary of generated slots
+    """
+    # Load schema
+    with open(schema_path, 'r') as f:
+        schema_data = yaml.safe_load(f)
+
+    # Check if schema has enums
+    if 'enums' not in schema_data or not schema_data['enums']:
+        print(f"No enums found in {schema_path}")
+        return {}
+
+    # Initialize slots section if not present
+    if 'slots' not in schema_data:
+        schema_data['slots'] = {}
+
+    generated_slots = {}
+
+    # Generate slot for each enum
+    for enum_name, enum_def in schema_data['enums'].items():
+        slot_name = generate_slot_name(enum_name)
+
+        # Skip if slot already exists
+        if slot_name in schema_data['slots']:
+            print(f"  Slot '{slot_name}' already exists, skipping")
+            continue
+
+        # Create slot definition
+        slot_def = {
+            'description': generate_slot_description(enum_name, enum_def.get('description')),
+            'range': enum_name
+        }
+
+        # Add optional fields if useful
+        if enum_def.get('description'):
+            # Add a more detailed description if available
+            slot_def['comments'] = [f"Value set: {enum_name}"]
+
+        generated_slots[slot_name] = slot_def
+        schema_data['slots'][slot_name] = slot_def
+        print(f"  Generated slot '{slot_name}' for enum '{enum_name}'")
+
+    # Write output if requested
+    if in_place or output_path:
+        output_file = schema_path if in_place else output_path
+
+        # Preserve order and formatting as much as possible
+        with open(output_file, 'w') as f:
+            yaml.dump(schema_data, f,
+                     default_flow_style=False,
+                     sort_keys=False,
+                     allow_unicode=True,
+                     width=120)
+        print(f"Updated schema written to {output_file}")
+
+    return generated_slots
+
+
+def process_directory(schema_dir: Path, in_place: bool = False,
+                     output_dir: Optional[Path] = None) -> None:
+    """
+    Process all schema files in a directory.
+
+    Args:
+        schema_dir: Directory containing LinkML schema files
+        in_place: If True, modify files in place
+        output_dir: If provided, write modified schemas to this directory
+    """
+    # Find all YAML files
+    yaml_files = list(schema_dir.rglob("*.yaml")) + list(schema_dir.rglob("*.yml"))
+
+    print(f"Found {len(yaml_files)} YAML files in {schema_dir}")
+
+    total_slots = 0
+    processed_files = 0
+
+    for yaml_file in yaml_files:
+        # Skip certain files
+        if yaml_file.name in ['linkml-meta.yaml', 'meta.yaml', 'types.yaml']:
+            continue
+
+        print(f"\nProcessing {yaml_file.relative_to(schema_dir)}...")
+
+        try:
+            # Determine output path
+            output_path = None
+            if output_dir and not in_place:
+                # Maintain directory structure in output
+                rel_path = yaml_file.relative_to(schema_dir)
+                output_path = output_dir / rel_path
+                output_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Generate slots
+            slots = generate_slots_for_schema(yaml_file, in_place=in_place,
+                                            output_path=output_path)
+
+            if slots:
+                total_slots += len(slots)
+                processed_files += 1
+
+        except Exception as e:
+            print(f"  Error processing {yaml_file}: {e}")
+
+    print(f"\n{'='*50}")
+    print(f"Summary: Generated {total_slots} slots across {processed_files} files")
+
+
+@click.command()
+@click.argument('schema_path', type=click.Path(exists=True, path_type=Path))
+@click.option('--in-place', '-i', is_flag=True,
+              help='Modify schema files in place')
+@click.option('--output', '-o', type=click.Path(path_type=Path),
+              help='Output directory for modified schemas')
+@click.option('--single-file', '-s', is_flag=True,
+              help='Process single file instead of directory')
+def main(schema_path: Path, in_place: bool, output: Optional[Path], single_file: bool):
+    """
+    Generate LinkML slots for enums in schema files.
+
+    SCHEMA_PATH: Path to schema file or directory
+    """
+    if single_file or schema_path.is_file():
+        # Process single file
+        print(f"Processing single file: {schema_path}")
+        slots = generate_slots_for_schema(schema_path, in_place=in_place,
+                                         output_path=output)
+        print(f"Generated {len(slots)} slots")
+    else:
+        # Process directory
+        process_directory(schema_path, in_place=in_place, output_dir=output)
+
+
+if __name__ == '__main__':
+    main()