synthra 0.1.0

data/lib/synthra/export/python.rb

@@ -0,0 +1,560 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Synthra
+  module Export
+    # Exports schema as Python with Pydantic models or dataclasses
+    #
+    # @example Export as Pydantic
+    #   exporter = Python.new(schema, registry: registry, style: :pydantic)
+    #   python = exporter.export
+    #
+    # @example Export as dataclass
+    #   exporter = Python.new(schema, registry: registry, style: :dataclass)
+    #   python = exporter.export
+    #
+    class Python < Base
+      # Type mappings from DSL types to Python types
+      TYPE_MAPPINGS = {
+        # Strings
+        "uuid" => "UUID",
+        "ulid" => "str",
+        "email" => "EmailStr",
+        "url" => "HttpUrl",
+        "ip" => "IPvAnyAddress",
+        "ipv6" => "IPvAnyAddress",
+        "date" => "date",
+        "past_date" => "date",
+        "future_date" => "date",
+        "timestamp" => "datetime",
+        "text" => "str",
+        "name" => "str",
+        "full_name" => "str",
+        "first_name" => "str",
+        "last_name" => "str",
+        "phone" => "str",
+        "city" => "str",
+        "country" => "str",
+        "country_code" => "str",
+        "postal_code" => "str",
+        "state" => "str",
+        "street" => "str",
+        "address" => "str",
+        "username" => "str",
+        "social_handle" => "str",
+        "domain" => "str",
+        "user_agent" => "str",
+        "mac_address" => "str",
+        "iban" => "str",
+        "credit_card" => "str",
+        "currency" => "str",
+        "currency_code" => "str",
+        "paragraph" => "str",
+        "sentence" => "str",
+        "word" => "str",
+        "message_text" => "str",
+        "hashtag_text" => "str",
+        "snowflake_id" => "str",
+        "numeric_string_id" => "str",
+
+        # Numbers (integers)
+        "number" => "int",
+        "integer" => "int",
+        "age" => "int",
+        "airport_elevation" => "int",
+        "discount" => "int",
+        "formula" => "int",
+        "row_number" => "int",
+        "sequence" => "int",
+        "id_sequence" => "int",
+
+        # Numbers (floats)
+        "float" => "float",
+        "money" => "Decimal",
+        "latitude" => "float",
+        "longitude" => "float",
+        "airport_latitude" => "float",
+        "airport_longitude" => "float",
+        "product_price" => "float",
+        "tax_rate" => "float",
+        "transaction_amount" => "float",
+
+        # Boolean
+        "boolean" => "bool",
+
+        # Date (generate Date objects)
+        "date_between" => "date",
+        "mobile_device_release_date" => "date",
+        "now" => "date",
+
+        # Date/Time
+        "datetime" => "datetime",
+
+        # Objects
+        "object" => "Dict[str, Any]",
+        "map_by_field" => "Dict[str, Any]",
+
+        # Arrays
+        "array" => "List[Any]",
+        "empty_array" => "List[Any]",
+        "json_array" => "List[Any]",
+        "indices_pair" => "Tuple[int, int]"
+      }.freeze
+
+      # Pydantic imports needed based on types used
+      PYDANTIC_IMPORTS = {
+        "UUID" => "from uuid import UUID",
+        "EmailStr" => "from pydantic import EmailStr",
+        "HttpUrl" => "from pydantic import HttpUrl",
+        "IPvAnyAddress" => "from pydantic import IPvAnyAddress",
+        "date" => "from datetime import date",
+        "datetime" => "from datetime import datetime",
+        "Decimal" => "from decimal import Decimal"
+      }.freeze
+
+      def export
+        style = options[:style] || :pydantic
+        
+        case style
+        when :pydantic
+          export_pydantic
+        when :dataclass
+          export_dataclass
+        when :typed_dict
+          export_typed_dict
+        else
+          export_pydantic # fallback
+        end
+      end
+
+      # Export all schemas in a registry
+      #
+      # @param registry [Registry] the registry
+      # @param options [Hash] export options
+      # @return [String] Python code
+      #
+      def self.export_all(registry, **options)
+        style = options[:style] || :pydantic
+        
+        lines = []
+        lines << "# Generated from Synthra schemas"
+        lines << "# Schemas: #{registry.names.join(', ')}"
+        lines << ""
+
+        # Collect all types used
+        all_types = Set.new
+        registry.schemas.each do |name, schema|
+          schema.fields.each { |f| all_types << TYPE_MAPPINGS[f.type_name] }
+        end
+
+        # Add imports - use first schema to create instance for build_imports
+        first_schema = registry.schemas.values.first
+        if first_schema
+          exporter = new(first_schema, registry: registry, **options)
+          lines << exporter.send(:build_imports, all_types, style)
+          lines << ""
+        end
+
+        registry.schemas.each do |name, schema|
+          exporter = new(schema, registry: registry, **options)
+          lines << exporter.build_model(schema, style)
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      def build_model(target_schema, style)
+        case style
+        when :pydantic
+          build_pydantic_model(target_schema)
+        when :dataclass
+          build_dataclass(target_schema)
+        when :typed_dict
+          build_typed_dict(target_schema)
+        else
+          build_pydantic_model(target_schema)
+        end
+      end
+
+      private
+
+      def export_pydantic
+        lines = []
+        
+        # Header
+        lines << '"""'
+        lines << "Generated from Synthra schema: #{schema.name}"
+        lines << "Version: #{schema.version}" if schema.version
+        lines << '"""'
+        lines << ""
+
+        # Collect types used
+        types_used = collect_types_used
+        
+        # Imports
+        lines << build_imports(types_used, :pydantic)
+        lines << ""
+
+        # Export referenced schemas first
+        exported = Set.new
+        collect_referenced_schemas.each do |ref_schema|
+          lines << build_pydantic_model(ref_schema)
+          lines << ""
+          exported << ref_schema.name
+        end
+
+        # Export main schema
+        lines << build_pydantic_model(schema) unless exported.include?(schema.name)
+
+        lines.join("\n")
+      end
+
+      def export_dataclass
+        lines = []
+        
+        lines << '"""'
+        lines << "Generated from Synthra schema: #{schema.name}"
+        lines << '"""'
+        lines << ""
+
+        types_used = collect_types_used
+        lines << build_imports(types_used, :dataclass)
+        lines << ""
+
+        exported = Set.new
+        collect_referenced_schemas.each do |ref_schema|
+          lines << build_dataclass(ref_schema)
+          lines << ""
+          exported << ref_schema.name
+        end
+
+        lines << build_dataclass(schema) unless exported.include?(schema.name)
+        lines.join("\n")
+      end
+
+      def export_typed_dict
+        lines = []
+        
+        lines << '"""'
+        lines << "Generated from Synthra schema: #{schema.name}"
+        lines << '"""'
+        lines << ""
+
+        types_used = collect_types_used
+        lines << build_imports(types_used, :typed_dict)
+        lines << ""
+
+        exported = Set.new
+        collect_referenced_schemas.each do |ref_schema|
+          lines << build_typed_dict(ref_schema)
+          lines << ""
+          exported << ref_schema.name
+        end
+
+        lines << build_typed_dict(schema) unless exported.include?(schema.name)
+        lines.join("\n")
+      end
+
+      def build_pydantic_model(target_schema)
+        lines = []
+        
+        if target_schema.deprecated?
+          lines << "# DEPRECATED: #{target_schema.deprecation_message || 'This model is deprecated'}"
+        end
+
+        lines << "class #{target_schema.name}(BaseModel):"
+        
+        if target_schema.version
+          lines << "    \"\"\"#{target_schema.name} model (v#{target_schema.version})\"\"\""
+        end
+
+        if target_schema.fields.empty?
+          lines << "    pass"
+        else
+          target_schema.fields.each do |field|
+            lines << "    #{build_pydantic_field(field)}"
+          end
+
+          # Add Config if needed
+          if options[:orm_mode] || options[:validate_assignment]
+            lines << ""
+            lines << "    class Config:"
+            lines << "        orm_mode = True" if options[:orm_mode]
+            lines << "        validate_assignment = True" if options[:validate_assignment]
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      def build_pydantic_field(field)
+        py_type = field_to_python(field)
+        field_name = to_snake_case(field.name)
+        
+        if field.optional?
+          "#{field_name}: Optional[#{py_type}] = None"
+        elsif field.nullable?
+          "#{field_name}: Optional[#{py_type}]"
+        else
+          default = get_field_default(field)
+          if default
+            "#{field_name}: #{py_type} = #{default}"
+          else
+            "#{field_name}: #{py_type}"
+          end
+        end
+      end
+
+      def build_dataclass(target_schema)
+        lines = []
+        
+        lines << "@dataclass"
+        lines << "class #{target_schema.name}:"
+        
+        # Required fields first, then optional
+        required_fields = target_schema.fields.reject { |f| f.optional? || f.nullable? }
+        optional_fields = target_schema.fields.select { |f| f.optional? || f.nullable? }
+
+        if target_schema.fields.empty?
+          lines << "    pass"
+        else
+          required_fields.each do |field|
+            py_type = field_to_python(field)
+            lines << "    #{to_snake_case(field.name)}: #{py_type}"
+          end
+
+          optional_fields.each do |field|
+            py_type = field_to_python(field)
+            lines << "    #{to_snake_case(field.name)}: Optional[#{py_type}] = None"
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      def build_typed_dict(target_schema)
+        lines = []
+        
+        # Check if we need total=False for optional fields
+        has_optional = target_schema.fields.any? { |f| f.optional? }
+        
+        if has_optional
+          # Create two TypedDicts - required and optional
+          required_fields = target_schema.fields.reject(&:optional?)
+          optional_fields = target_schema.fields.select(&:optional?)
+
+          lines << "class #{target_schema.name}Required(TypedDict):"
+          if required_fields.empty?
+            lines << "    pass"
+          else
+            required_fields.each do |field|
+              py_type = field_to_python(field)
+              lines << "    #{to_snake_case(field.name)}: #{py_type}"
+            end
+          end
+          lines << ""
+
+          lines << "class #{target_schema.name}(#{target_schema.name}Required, total=False):"
+          if optional_fields.empty?
+            lines << "    pass"
+          else
+            optional_fields.each do |field|
+              py_type = field_to_python(field)
+              lines << "    #{to_snake_case(field.name)}: #{py_type}"
+            end
+          end
+        else
+          lines << "class #{target_schema.name}(TypedDict):"
+          if target_schema.fields.empty?
+            lines << "    pass"
+          else
+            target_schema.fields.each do |field|
+              py_type = field_to_python(field)
+              nullable = " | None" if field.nullable?
+              lines << "    #{to_snake_case(field.name)}: #{py_type}#{nullable}"
+            end
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      def build_imports(types_used, style)
+        lines = []
+        
+        case style
+        when :pydantic
+          lines << "from typing import Optional, List, Dict, Any, Tuple"
+          lines << "from pydantic import BaseModel, Field"
+          
+          # Add specific imports
+          PYDANTIC_IMPORTS.each do |type, import_stmt|
+            lines << import_stmt if types_used.include?(type)
+          end
+          
+          # Add Literal for enums
+          if types_used.include?("Literal")
+            lines << "from typing import Literal"
+          end
+
+        when :dataclass
+          lines << "from dataclasses import dataclass, field"
+          lines << "from typing import Optional, List, Dict, Any, Tuple"
+          
+          PYDANTIC_IMPORTS.each do |type, import_stmt|
+            next if %w[EmailStr HttpUrl IPvAnyAddress].include?(type)
+            lines << import_stmt if types_used.include?(type)
+          end
+
+        when :typed_dict
+          lines << "from typing import TypedDict, Optional, List, Dict, Any, Tuple"
+          
+          PYDANTIC_IMPORTS.each do |type, import_stmt|
+            next if %w[EmailStr HttpUrl IPvAnyAddress].include?(type)
+            lines << import_stmt if types_used.include?(type)
+          end
+        end
+
+        lines.uniq.join("\n")
+      end
+
+      def collect_types_used
+        types = Set.new
+        schema.fields.each do |field|
+          py_type = TYPE_MAPPINGS[field.type_name]
+          types << py_type if py_type
+          types << "Literal" if field.type_name == "enum"
+        end
+        types
+      end
+
+      def collect_referenced_schemas
+        schemas = []
+        schema.fields.each do |field|
+          collect_field_schemas(field, schemas)
+        end
+        schemas.uniq(&:name)
+      end
+
+      def collect_field_schemas(field, schemas)
+        type_name = field.type_name
+
+        if schema_reference?(type_name)
+          ref_schema = get_schema(type_name)
+          if ref_schema && !schemas.any? { |s| s.name == ref_schema.name }
+            schemas << ref_schema
+            ref_schema.fields.each { |f| collect_field_schemas(f, schemas) }
+          end
+        end
+
+        if type_name == "array"
+          element = field.type_args[:element]
+          if element && schema_reference?(element.to_s)
+            ref_schema = get_schema(element.to_s)
+            if ref_schema && !schemas.any? { |s| s.name == ref_schema.name }
+              schemas << ref_schema
+              ref_schema.fields.each { |f| collect_field_schemas(f, schemas) }
+            end
+          end
+        end
+      end
+
+      def field_to_python(field)
+        type_name = field.type_name
+        type_args = field.type_args
+
+        case type_name
+        when "enum"
+          build_enum_type(type_args)
+        when "const"
+          build_const_type(type_args)
+        when "array"
+          build_array_type(type_args)
+        when "one_of"
+          build_union_type(type_args)
+        when "map_by_field"
+          "Dict[str, Any]"
+        else
+          if TYPE_MAPPINGS[type_name]
+            TYPE_MAPPINGS[type_name]
+          elsif schema_reference?(type_name)
+            type_name
+          else
+            # Most Synthra types generate strings, so an unmapped, non-structural
+            # type is a string rather than Any.
+            "str"
+          end
+        end
+      end
+
+      def build_enum_type(args)
+        values = args[:values]&.map { |v| v.respond_to?(:value) ? v.value : v } || []
+        "Literal[#{values.map { |v| "\"#{v}\"" }.join(', ')}]"
+      end
+
+      def build_const_type(args)
+        value = args[:value]
+        case value
+        when String
+          "Literal[\"#{value}\"]"
+        when TrueClass, FalseClass
+          "Literal[#{value}]"
+        when Numeric
+          "Literal[#{value}]"
+        else
+          "Literal[\"#{value}\"]"
+        end
+      end
+
+      def build_array_type(args)
+        element = args[:element]
+        if element
+          if schema_reference?(element.to_s)
+            "List[#{element}]"
+          elsif TYPE_MAPPINGS[element.to_s]
+            "List[#{TYPE_MAPPINGS[element.to_s]}]"
+          else
+            # Unknown element types are string-producing types (e.g. array(string)).
+            "List[str]"
+          end
+        else
+          "List[Any]"
+        end
+      end
+
+      def build_union_type(args)
+        schemas = args[:schemas] || []
+        types = schemas.map do |s|
+          schema_name = s.is_a?(Hash) ? (s[:schema] || s["schema"]) : s.to_s
+          schema_reference?(schema_name) ? schema_name : "Any"
+        end
+        "Union[#{types.join(', ')}]"
+      end
+
+      def get_field_default(field)
+        type_name = field.type_name
+
+        case type_name
+        when "enum"
+          values = field.type_args[:values] || []
+          first = values.first
+          first ? "\"#{first.respond_to?(:value) ? first.value : first}\"" : nil
+        when "const"
+          value = field.type_args[:value]
+          value.is_a?(String) ? "\"#{value}\"" : value.to_s
+        else
+          nil
+        end
+      end
+
+      def to_snake_case(str)
+        str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .downcase
+      end
+    end
+    # :nocov:
+  end
+end
+