converting to camelCase

Author: anupkalburgi

dbldatagen/spec/__init__.py

@@ -4,36 +4,42 @@
 in a type-safe, declarative way.
 """
 
+from typing import Any
+
 # Import only the compat layer by default to avoid triggering Spark/heavy dependencies
 from .compat import BaseModel, Field, constr, root_validator, validator
 
+
 # Lazy imports for heavy modules - import these explicitly when needed
 # from .column_spec import ColumnSpec
 # from .generator_spec import GeneratorSpec
 # from .generator_spec_impl import GeneratorSpecImpl
 
 __all__ = [
     "BaseModel",
+    "ColumnDefinition",
+    "DatagenSpec",
     "Field",
+    "Generator",
     "constr",
     "root_validator",
     "validator",
-    "ColumnSpec",
-    "GeneratorSpec",
-    "GeneratorSpecImpl",
 ]
 
 
-def __getattr__(name):
-    """Lazy import heavy modules to avoid triggering Spark initialization."""
+def __getattr__(name: str) -> Any:  # noqa: ANN401
+    """Lazy import heavy modules to avoid triggering Spark initialization.
+
+    Note: Imports are intentionally inside this function to enable lazy loading
+    and avoid importing heavy dependencies (pandas, IPython, Spark) until needed.
+    """
     if name == "ColumnSpec":
-        from .column_spec import ColumnSpec
-        return ColumnSpec
+        from .column_spec import ColumnDefinition  # noqa: PLC0415
+        return ColumnDefinition
     elif name == "GeneratorSpec":
-        from .generator_spec import GeneratorSpec
-        return GeneratorSpec
+        from .generator_spec import DatagenSpec  # noqa: PLC0415
+        return DatagenSpec
     elif name == "GeneratorSpecImpl":
-        from .generator_spec_impl import GeneratorSpecImpl
-        return GeneratorSpecImpl
+        from .generator_spec_impl import Generator  # noqa: PLC0415
+        return Generator
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-

dbldatagen/spec/generator_spec.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Literal, Union
+from typing import Any, Union
 
 import pandas as pd
 from IPython.display import HTML, display
 
 from dbldatagen.spec.column_spec import ColumnDefinition
 
-from .compat import BaseModel, validator
-from .output_targets import UCSchemaTarget, FilePathTarget
-
-logger = logging.getLogger(__name__)
+from .compat import BaseModel
+from .output_targets import FilePathTarget, UCSchemaTarget
 
 
+logger = logging.getLogger(__name__)
 
 
 class TableDefinition(BaseModel):

dbldatagen/spec/generator_spec_impl.py

@@ -60,7 +60,7 @@ def __init__(self, spark: SparkSession, app_name: str = "DataGen_ClassBased") ->
         self.app_name = app_name
         logger.info("Generator initialized with SparkSession")
 
-    def _columnspec_to_datagen_columnspec(self, col_def: ColumnDefinition) -> dict[str, Any]:
+    def _columnSpecToDatagenColumnSpec(self, col_def: ColumnDefinition) -> dict[str, Any]:
         """Convert a ColumnDefinition spec into dbldatagen DataGenerator column arguments.
 
         This internal method translates the declarative ColumnDefinition format into the
@@ -124,7 +124,7 @@ def _columnspec_to_datagen_columnspec(self, col_def: ColumnDefinition) -> dict[s
 
         return kwargs
 
-    def _prepare_data_generators(
+    def _prepareDataGenerators(
         self,
         config: DatagenSpec,
         config_source_name: str = "PydanticConfig"
@@ -151,7 +151,7 @@ def _prepare_data_generators(
         :raises ValueError: If table configuration is invalid (should be caught by validate() first)
 
         .. note::
-            This is an internal method. Use generate_and_write_data() for the complete workflow
+            This is an internal method. Use generateAndWriteData() for the complete workflow
 
         .. note::
             Preparation is separate from building to allow inspection and modification of
@@ -188,7 +188,7 @@ def _prepare_data_generators(
 
                 # Process each column
                 for col_def in table_spec.columns:
-                    kwargs = self._columnspec_to_datagen_columnspec(col_def)
+                    kwargs = self._columnSpecToDatagenColumnSpec(col_def)
                     data_gen = data_gen.withColumn(colName=col_def.name, **kwargs)
                     # Has performance implications.
 
@@ -203,7 +203,7 @@ def _prepare_data_generators(
         logger.info("All data generators prepared successfully")
         return prepared_generators
 
-    def write_prepared_data(
+    def writePreparedData(
         self,
         prepared_generators: dict[str, dg.DataGenerator],
         output_destination: Union[UCSchemaTarget, FilePathTarget, None],
@@ -224,7 +224,7 @@ def write_prepared_data(
         4. Logs row counts and write locations
 
         :param prepared_generators: Dictionary mapping table names to DataGenerator objects
-                                   (typically from _prepare_data_generators())
+                                   (typically from _prepareDataGenerators())
         :param output_destination: Target location for output. Can be UCSchemaTarget,
                                   FilePathTarget, or None (no write, data generated only)
         :param config_source_name: Descriptive name for the config source, used in logging
@@ -275,7 +275,7 @@ def write_prepared_data(
                 raise RuntimeError(f"Failed to write table '{table_name}': {e}") from e
         logger.info("All data writes completed successfully")
 
-    def generate_and_write_data(
+    def generateAndWriteData(
         self,
         config: DatagenSpec,
         config_source_name: str = "PydanticConfig"
@@ -293,7 +293,7 @@ def generate_and_write_data(
         5. Logs progress and completion status
 
         This method is the recommended entry point for most use cases. For more control over
-        the generation process, use _prepare_data_generators() and write_prepared_data() separately.
+        the generation process, use _prepareDataGenerators() and writePreparedData() separately.
 
         :param config: DatagenSpec object defining tables, columns, and output destination.
                       Should be validated with config.validate() before calling this method
@@ -317,21 +317,21 @@ def generate_and_write_data(
             ... )
             >>> spec.validate()  # Check for errors first
             >>> generator = Generator(spark)
-            >>> generator.generate_and_write_data(spec)
+            >>> generator.generateAndWriteData(spec)
         """
         logger.info(f"Starting combined data generation and writing for {len(config.tables)} tables")
 
         try:
             # Phase 1: Prepare data generators
-            prepared_generators_map = self._prepare_data_generators(config, config_source_name)
+            prepared_generators_map = self._prepareDataGenerators(config, config_source_name)
 
             if not prepared_generators_map and list(config.tables.keys()):
                 logger.warning(
                     "No data generators were successfully prepared, though tables were defined")
                 return
 
             # Phase 2: Write data
-            self.write_prepared_data(
+            self.writePreparedData(
                 prepared_generators_map,
                 config.output_destination,
                 config_source_name

dbldatagen/spec/output_targets.py

@@ -1,6 +1,8 @@
-from .compat import BaseModel, validator
-from typing import Literal
 import logging
+from typing import Literal
+
+from .compat import BaseModel, validator
+
 
 logger = logging.getLogger(__name__)