sql-assignment-generator 0.0.9__tar.gz → 0.0.11__tar.gz

sql_assignment_generator-0.0.11/.gitattributes

@@ -0,0 +1 @@
+* text eol=lf

{sql_assignment_generator-0.0.9 → sql_assignment_generator-0.0.11}/Makefile

@@ -36,10 +36,13 @@ build: $(VENV) .env
 uninstall: $(VENV)
 	$(VENV_BIN)/python -m pip uninstall -y $(NAME)
 
+test: install
+	$(VENV_BIN)/python -m pytest
+
 documentation:
 	make html SPHINXBUILD="../$(VENV_BIN)/sphinx-build" -C docs/
 
-upload: build documentation
+upload: test documentation
 	$(VENV_BIN)/python -m pip install --upgrade twine
 	$(VENV_BIN)/python -m twine upload --verbose dist/*
 

{sql_assignment_generator-0.0.9 → sql_assignment_generator-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_assignment_generator
-Version: 0.0.9
+Version: 0.0.11
 Summary: This project generates SQL assignments based on common mistakes made by learners.
 Project-URL: Repository, https://github.com/DavidePonzini/sql_assignment_generator
 Project-URL: Documentation, https://sql-assignment-generator.readthedocs.io/en/latest/index.html
@@ -11,9 +11,12 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
-Requires-Dist: dotenv
+Requires-Dist: openai
 Requires-Dist: pydantic
-Requires-Dist: sql-error-categorizer>=0.1.10
+Requires-Dist: sql-error-taxonomy>=1.0.2
+Requires-Dist: sqlglot>=11.5.6
+Requires-Dist: sqlscope
+Requires-Dist: sqlscope>=0.3.5
 Description-Content-Type: text/markdown
 
 # sql-assignment-generation

{sql_assignment_generator-0.0.9 → sql_assignment_generator-0.0.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql_assignment_generator"
-version = "0.0.9"
+version = "0.0.11"
 authors = [
   { name="Davide Ponzini", email="davide.ponzini95@gmail.com" },
 ]
@@ -18,8 +18,11 @@ classifiers = [
 ]
 dependencies = [
     "pydantic",
-    "sql_error_categorizer>=0.1.10",
-    "dotenv",
+    "sqlglot>=11.5.6",
+    "sqlscope>=0.3.5",
+    "sql-error-taxonomy>=1.0.2",
+    "sqlscope",
+    "openai",
 ]
 
 [project.urls]

{sql_assignment_generator-0.0.9 → sql_assignment_generator-0.0.11}/requirements.txt

@@ -1,7 +1,9 @@
 dav_tools>=0.4.22
 # progress>=1.6
 pydantic>=2.10.4
-sql-error-categorizer>=0.1.10
+sql-error-taxonomy>=1.0.2
+sqlscope>=1.0.7
+sqlglot
 dotenv
 openai
 
@@ -12,5 +14,4 @@ ipython
 build
 autoapi
 pytest
-pytest-cov
 sphinx-autoapi

sql_assignment_generator-0.0.11/src/sql_assignment_generator/__init__.py

@@ -0,0 +1,155 @@
+'''Generate SQL assignments based on specified SQL errors and difficulty levels.'''
+
+from __future__ import annotations
+
+from typing import Callable
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
+import random
+
+from .difficulty_level import DifficultyLevel
+from .domains import random_domain
+from .assignments import Assignment, Dataset, Exercise
+from .constraints import SchemaConstraint, QueryConstraint
+from .error_requirements import SqlErrorRequirements, ERROR_REQUIREMENTS_MAP
+from .exceptions import ExerciseGenerationError
+
+import dav_tools
+from sql_error_taxonomy import SqlErrors
+
+
+def generate_assignment(
+        errors: list[tuple[SqlErrors, DifficultyLevel]],
+        domain: str | None = None,
+        *,
+        shuffle_exercises: bool = False,
+        naming_func: Callable[[SqlErrors, DifficultyLevel], str] = lambda error, difficulty: f'{error.name} - {difficulty.name}',
+        max_unique_attempts: int = 3,
+        max_workers: int | None = None
+    ) -> Assignment:
+    '''
+    Generate SQL assignments based on the given SQL errors and their corresponding difficulty levels.
+
+    - Exercises are returned in the same order as the input `errors`.
+    - Logging happens as soon as possible (during generation), and each message uses the exercise title as its id.
+    - Deduplication is global across all generated exercises (thread-safe).
+
+    Args:
+        errors (list[tuple[SqlErrors, DifficultyLevel]]): A list of (error, difficulty) pairs.
+        domain (str | None): The domain for the assignments. If None, a random domain will be selected.
+        shuffle_exercises (bool): Whether to shuffle exercises to prevent ordering bias (shuffles input order).
+        naming_func (Callable[[SqlErrors, DifficultyLevel], str]): Generates exercise titles.
+        max_unique_attempts (int): Maximum retries to avoid duplicate solutions per (error, difficulty).
+        max_workers (int | None): Thread pool size. If None, uses ThreadPoolExecutor default.
+
+    Returns:
+        Assignment: The generated assignment (stable order).
+    '''
+
+    dav_tools.messages.info(f'Starting assignment generation for {len(errors)} exercises...')
+
+    if domain is None:
+        domain = random_domain()
+
+    if shuffle_exercises:
+        random.shuffle(errors)
+
+    # convert SqlErrors -> SqlErrorRequirements, keeping difficulty levels
+    requirements: list[tuple[SqlErrors, SqlErrorRequirements, DifficultyLevel]] = []
+    for error, difficulty in errors:
+        if error not in ERROR_REQUIREMENTS_MAP:
+            raise NotImplementedError(f'Error requirements not implemented for error: {error.name}')
+        
+        requirements.append((error, ERROR_REQUIREMENTS_MAP[error], difficulty))
+
+    # initialize requirements and extra details
+    dataset_requirements: list[SchemaConstraint] = []
+    for _, req, difficulty in requirements:
+        dataset_requirements.extend(req.dataset_constraints(difficulty))
+
+    dataset_extra_details: list[str] = [
+        req.dataset_extra_details()
+        for _, req, _ in requirements
+    ]
+    dataset_extra_details = [detail for detail in dataset_extra_details if detail.strip()]  # filter out empty details
+    dataset_extra_details = list(set(dataset_extra_details))  # deduplicate details
+
+    dav_tools.messages.info(f'Generating dataset for domain: {domain}')
+    dataset = Dataset.generate(domain, dataset_requirements, dataset_extra_details)
+
+    generated_solutions_hashes: set[str] = set()
+    hashes_lock = threading.Lock()
+
+    # Serialize log output to avoid interleaving (and to keep dav_tools usage thread-safe).
+    log_lock = threading.Lock()
+
+    def _worker(
+            idx: int,
+            error: SqlErrors,
+            difficulty: DifficultyLevel,
+            constraints: list[QueryConstraint],
+            extra_details: str
+    ) -> tuple[int, Exercise | None]:
+        title = naming_func(error, difficulty)
+
+        dav_tools.messages.info(f'Starting generation for exercise: {title}')
+
+        last_generated_exercise: Exercise | None = None
+
+        for attempt in range(max_unique_attempts):
+            try:
+                generated_exercise = Exercise.generate(error, difficulty, constraints, extra_details, dataset=dataset, title=title)
+            except ExerciseGenerationError:
+                with log_lock:
+                    dav_tools.messages.warning(f'{title}: Skipping exercise generation for {error.name} due to validation failures.')
+                return (idx, None)
+
+            last_generated_exercise = generated_exercise
+            raw_solution = generated_exercise.solutions[0]
+            normalized_solution = raw_solution.sql.lower().strip()
+
+            with hashes_lock:
+                is_duplicate = normalized_solution in generated_solutions_hashes
+                if not is_duplicate:
+                    generated_solutions_hashes.add(normalized_solution)
+
+            if is_duplicate:
+                with log_lock:
+                    dav_tools.messages.warning(f'{title}: Duplicate solution detected for {error.name} (Attempt {attempt + 1}/{max_unique_attempts}). Regenerating...')
+                continue
+
+            return (idx, generated_exercise)
+
+        if last_generated_exercise is not None:
+            with log_lock:
+                dav_tools.messages.error(f'{title}: Could not generate a UNIQUE exercise for {error.name} after {max_unique_attempts} retries. Skipping.')
+        return (idx, None)
+
+    # Pre-allocate so we can preserve ordering no matter completion order.
+    ordered_results: list[Exercise | None] = [None] * len(errors)
+
+    if max_workers == 1:
+        for idx, (error, requirement, difficulty) in enumerate(requirements):
+            i, ex = _worker(idx, error, difficulty, requirement.exercise_constraints(difficulty), requirement.exercise_extra_details())
+            ordered_results[i] = ex
+    else:
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [
+                executor.submit(_worker, idx, error, difficulty, requirement.exercise_constraints(difficulty), requirement.exercise_extra_details())
+                for idx, (error, requirement, difficulty) in enumerate(requirements)
+            ]
+            for fut in as_completed(futures):
+                idx, ex = fut.result()
+                ordered_results[idx] = ex
+
+    exercises: list[Exercise] = [ex for ex in ordered_results if ex is not None]
+
+    if len(exercises) < len(errors):
+        dav_tools.messages.warning(f'Finished generating exercises with some failures. Generated {len(exercises)} out of {len(errors)} requested.')
+    else:
+        dav_tools.messages.success(f'Successfully generated all {len(exercises)} exercises.')
+
+    return Assignment(
+        dataset=dataset,
+        exercises=exercises
+    )

sql_assignment_generator-0.0.11/src/sql_assignment_generator/assignments/dataset/__init__.py

@@ -0,0 +1 @@
+from .dataset import Dataset

sql_assignment_generator-0.0.11/src/sql_assignment_generator/assignments/dataset/dataset.py

@@ -0,0 +1,145 @@
+from collections.abc import Sequence
+from dataclasses import dataclass
+import dav_tools
+import sqlglot
+from sqlscope import Catalog, build_catalog_from_sql
+
+from . import strings
+from ...constraints.schema import SchemaConstraint
+from ... import llm
+from ...constraints import SchemaConstraint, schema as schema_constraints
+from ...exceptions import SQLParsingError, ConstraintValidationError, DatasetGenerationError
+
+
+@dataclass
+class Dataset:
+    '''A SQL dataset related to a specific domain, including schema creation and data insertion commands.'''
+
+    create_commands: list[str]
+    '''SQL commands to create the database schema.'''
+
+    insert_commands: list[str]
+    '''SQL commands to insert data into the database.'''
+
+    domain: str
+    '''The domain associated with the dataset.'''
+
+    _catalog_cache: Catalog | None = None
+    '''Cached SQLScope Catalog for the dataset.'''
+
+    _catalog_cache_commands_hash: int | None = None
+    '''Hash of the CREATE TABLE commands used to build the cached Catalog.'''
+
+    @property
+    def catalog(self) -> Catalog:
+        '''
+        Build and return a SQLScope Catalog from the dataset's SQL commands.
+        The result is cached for handling multiple accesses efficiently.
+        Cache is properly invalidated if the CREATE TABLE commands change.
+        '''
+        if self._catalog_cache is None or self._catalog_cache_commands_hash != hash(tuple(self.create_commands)):
+            full_sql = '\n'.join(self.create_commands)
+            self._catalog_cache = build_catalog_from_sql(full_sql)
+            self._catalog_cache_commands_hash = hash(tuple(self.create_commands))
+        
+        return self._catalog_cache
+    
+    def to_sql_no_context(self) -> str:
+        '''Generate the SQL commands to create and populate the dataset without schema context.'''
+
+        create_cmds = '\n'.join(self.create_commands)
+        insert_cmds = '\n'.join(self.insert_commands)
+
+        return f'''{create_cmds}\n\n{insert_cmds}'''
+
+    def to_sql(self, schema: str) -> str:
+        '''Generate the SQL commands to create and populate the dataset within the specified schema.'''
+
+        # Normalize schema name
+        schema = schema.lower().replace(' ', '_')
+
+        create_cmds = '\n\n'.join(self.create_commands)
+        insert_cmds = '\n\n'.join(self.insert_commands)
+
+        return strings.to_sql_format(schema=schema, create_cmds=create_cmds, insert_cmds=insert_cmds)
+    
+    @staticmethod
+    def generate(domain: str,
+                 constraints: Sequence[SchemaConstraint],
+                 extra_details: list[str] = [],
+                 *,
+                 max_attempts: int = 5
+        ) -> 'Dataset':
+        '''Generate a SQL dataset based on the specified parameters.'''
+
+        # merge similar constraints
+        constraints = schema_constraints.merge_constraints(constraints)
+
+        prompt_text = strings.prompt_generate(
+            domain=domain,
+            extra_details=extra_details,
+            constraints=constraints
+        )
+
+        # query LLM to generate dataset
+        messages = llm.Message()
+        messages.add_message_user(prompt_text)
+        
+        for attempt in range(max_attempts):
+            try:
+                answer = llm.generate_answer(messages, json_format=llm.models.Schema) 
+                assert isinstance(answer, llm.models.Schema), "The response is not in the expected JSON format."
+
+                # parse CREATE TABLEs
+                parsed_tables = []
+                for create_table in answer.schema_tables:
+                    try:
+                        parsed = sqlglot.parse_one(create_table, read="postgres")
+                        parsed_tables.append(parsed)
+                    except Exception as e:
+                        raise SQLParsingError(f"Syntax error in CREATE TABLE generated: {e}", create_table)
+                create_commands = [f'{cmd.sql(pretty=True, dialect="postgres")};' for cmd in parsed_tables]
+
+                # parse INSERT INTOs
+                parsed_inserts = []
+                for create_table in answer.insert_commands:
+                    try:
+                        parsed = sqlglot.parse_one(create_table, read="postgres")
+                        parsed_inserts.append(parsed)
+                    except Exception as e:
+                        raise SQLParsingError(f"Syntax error in INSERT COMMANDS generated: {e}", create_table)
+                insert_commands = [f'{cmd.sql(pretty=True, dialect="postgres")};' for cmd in parsed_inserts]
+
+                catalog = build_catalog_from_sql('; '.join(cmd.sql() for cmd in parsed_tables))
+
+                # check if constraints are satisfied
+                errors = []
+                for constraint in constraints:
+                    try:
+                        constraint.validate(catalog, parsed_tables, parsed_inserts)
+                    except ConstraintValidationError as e:
+                        errors.append(str(e))
+                        continue
+
+                # no errors, return dataset
+                if not errors:
+                    result = Dataset(
+                        create_commands=create_commands,
+                        insert_commands=insert_commands,
+                        domain=domain
+                    )
+                    # fill cache, since we already have the catalog
+                    result._catalog_cache = catalog
+                    result._catalog_cache_commands_hash = hash(tuple(create_commands))
+                    
+                    return result
+                
+                dav_tools.messages.error(f'Validation failed for attempt {attempt + 1}. Missing requirements: {", ".join(errors)}')
+                
+                messages.add_message_user(strings.feedback_constraint_violations(errors))
+
+            except SQLParsingError as e:
+                dav_tools.messages.error(f"Error during generation (Attempt {attempt + 1}): {e}")
+                messages.add_message_user(f"SQL code is not syntactically valid: {str(e)}. Please regenerate valid SQL.")
+        
+        raise DatasetGenerationError(f'Failed to generate a valid dataset after {max_attempts} attempts.')

sql_assignment_generator-0.0.11/src/sql_assignment_generator/assignments/dataset/strings.py

@@ -0,0 +1,64 @@
+from typing import Sequence
+from ...constraints import SchemaConstraint
+
+def to_sql_format(schema: str, create_cmds: str, insert_cmds: str) -> str:
+    return f'''BEGIN;
+
+DROP SCHEMA IF EXISTS {schema} CASCADE;
+CREATE SCHEMA {schema};
+SET search_path TO {schema};
+
+{create_cmds}
+
+{insert_cmds}
+
+COMMIT;'''
+
+
+def prompt_generate(domain: str, extra_details: list[str], constraints: Sequence[SchemaConstraint]) -> str:
+    formatted_constraints = '\n'.join(f'- {c.description}' for c in constraints)
+   
+    # remove empty extra details        
+    extra_details = [detail for detail in extra_details if detail.strip() != '']
+    # dataset characteristics str
+    if len(extra_details) > 0:
+        extra_details_str = "The dataset must have the following characteristics:\n"
+        for detail in extra_details:
+            extra_details_str += f"- {detail}\n"
+    else:
+        extra_details_str = ''
+    
+    return f'''
+Generate a SQL dataset about the following domain: "{domain}".
+{extra_details_str}
+
+MANDATORY CONSTRAINTS:
+- FOREIGN KEY attributes should have the REFERENCES keyword inline (e.g. "col TYPE REFERENCES table_name(column_name)").
+{formatted_constraints}
+
+MANDATORY OUTPUT (JSON) - each line in both lists must correspond to a single table:
+{{
+    "schema_tables": [
+        "CREATE TABLE t1(...);",
+        "CREATE TABLE t2(...);"
+    ],
+    "insert_commands": [
+        "INSERT INTO t1(...) VALUES(val_1, val_2, ...), (...), (val_n, val_n+1, ...);",
+        "INSERT INTO t2(...) VALUES(val_1, val_2, ...), (...), (val_n, val_n+1, ...);"
+    ]
+}}
+
+INSERT INTO statements must have following format (Multi-row insert): 
+INSERT INTO tableName(<all columns except SERIAL/AUTO_INCREMENT>) VALUES 
+    (val_1, val_2, ...),
+    (val_n, val_n+1, ...);
+
+For each table, insert at least 5 rows of data.
+Skip any SERIAL/AUTO_INCREMENT columns in the INSERT statements.
+'''
+
+def feedback_constraint_violations(errors: list[str]) -> str:
+    return (
+        f"The previous JSON output was rejected because the SQL violated these constraints: {', '.join(errors)}\n"
+        "Regenerate the JSON correcting the SQL to satisfy all mandatory constraints."
+    )

sql_assignment_generator-0.0.11/src/sql_assignment_generator/assignments/exercise/__init__.py

@@ -0,0 +1 @@
+from .exercise import Exercise

sql_assignment_generator-0.0.11/src/sql_assignment_generator/assignments/exercise/exercise.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass
+from sql_error_taxonomy import SqlErrors
+from sqlscope import Query
+import dav_tools
+
+from . import strings
+from ..dataset import Dataset
+from ...constraints import QueryConstraint
+from ...difficulty_level import DifficultyLevel
+from ... import llm
+from ...exceptions import ExerciseGenerationError, SQLParsingError, ConstraintValidationError
+
+
+@dataclass
+class Exercise:
+    '''A SQL exercise consisting of a title, request, and solutions.'''
+
+    title: str
+    '''The title of the exercise.'''
+
+    request: str
+    '''The natural language request or question for the exercise.'''
+
+    solutions: list[Query]
+    '''The list of SQL query solutions for the exercise.'''
+
+    difficulty: DifficultyLevel
+    '''The difficulty level of the exercise.'''
+
+    error: SqlErrors
+    '''The SQL error type associated with the exercise.'''
+
+    @staticmethod
+    def generate(
+        error: SqlErrors,
+        difficulty: DifficultyLevel,
+        constraints: list[QueryConstraint],
+        extra_details: str,
+        dataset: Dataset,
+        title: str,
+        *,
+        max_attempts: int = 3,
+    ) -> 'Exercise':
+        '''Generate a SQL exercise based on the specified parameters.'''
+
+        messages = llm.Message()
+        messages.add_message_user(strings.prompt_generate(
+            dataset_str=dataset.to_sql_no_context(),
+            extra_details=extra_details,
+            constraints=constraints
+        ))
+
+        for attempt in range(max_attempts):
+            try:
+                answer = llm.generate_answer(messages, json_format=llm.models.Assignment)
+                assert isinstance(answer, llm.models.Assignment)
+                
+                # check syntax correctness of solution
+                try:
+                    query = Query(answer.solution, catalog=dataset.catalog)
+                except Exception as e:
+                    raise SQLParsingError(f"Generated SQL solution contains syntax errors: {e}", answer.solution)
+
+                # constraint validation
+                constraint_errors = []
+                
+                for constraint in constraints:
+                    try:
+                        constraint.validate(query)
+                    except ConstraintValidationError:
+                        constraint_errors.append(constraint.description)
+
+                if constraint_errors:
+                    dav_tools.messages.error(f'Validation failed for attempt {attempt + 1} (error: {error.name}). Missing requirements: {", ".join(constraint_errors)}')
+                    messages.add_message_user(strings.feedback_validation_errors(constraint_errors))
+                    continue
+
+                # refine natural language request to remove hints
+                messages_refinement = llm.Message()
+                messages_refinement.add_message_user(strings.prompt_refine_request(answer.request, query))
+                answer_refinement = llm.generate_answer(
+                    messages_refinement,
+                    json_format=llm.models.RemoveHints
+                )
+
+                assert isinstance(answer_refinement, llm.models.RemoveHints)
+                # dav_tools.messages.debug(f"Old Request: {answer.request}")
+                # dav_tools.messages.debug(f"Refined Request: {answer_refinement.request_without_hints}")
+                answer.request = answer_refinement.request_without_hints
+
+                return Exercise(
+                    title=title,
+                    request=answer.request,
+                    solutions=[query],
+                    difficulty=difficulty,
+                    error=error
+                )
+            except Exception as e:
+                dav_tools.messages.error(f"Error during exercise generation (Attempt {attempt + 1}): {e}")
+                messages.add_message_user(f"An error occurred: {str(e)}. Please regenerate valid JSON/SQL.")
+
+        raise ExerciseGenerationError(f'Failed to generate a valid exercise for {error.name} after {max_attempts} attempts.')

sql_assignment_generator-0.0.11/src/sql_assignment_generator/assignments/exercise/strings.py

@@ -0,0 +1,72 @@
+from ...constraints import QueryConstraint
+from sqlscope import Query
+
+def prompt_generate(dataset_str: str, extra_details: str, constraints: list[QueryConstraint]) -> str:
+
+    formatted_constraints = '\n'.join(f'- {constraint.description}' for constraint in constraints)
+
+    if extra_details.strip():
+        extra_details_formatted = f"The exercise must have the following characteristics:\n{extra_details}"
+    else:
+        extra_details_formatted = ""
+
+    return f'''
+### CONTEXT (DATABASE SCHEMA AND DATA) ###
+{dataset_str}
+
+### GUIDELINES ###
+Generate a SQL exercise based on the dataset above.
+{extra_details_formatted}
+
+### MANDATORY REQUIREMENTS FOR THE EXERCISE ###
+{formatted_constraints}
+
+#### JSON REQUIRED OUTPUT FORMAT ####
+{{
+    "request": "Extract and return ONLY the natural language query request, following the specified constraints. Never ask to include mistakes. Be concise and clear. Do not provide hints or explanations.",
+    "solution": "Only a single syntactically and semantically correct (i.e. executable with minimum 1 returned row) SQL query that solves the exercise."
+}}
+'''
+
+
+def feedback_validation_errors(errors: list[str]) -> str:
+    return (
+        f"The previous JSON output was rejected because it violated these constraints: {', '.join(errors)}\n"
+        "Regenerate the JSON to satisfy all constraints."
+    )
+
+
+def prompt_refine_request(request: str, query: Query) -> str:
+    result = f'''For the following query solution:
+--- SOLUTION START ---
+{query.sql}
+--- SOLUTION END ---
+
+Reword the natural language request to remove any kind of hints on how to write it. 
+Keep the condition purely at the problem level, not the SQL level.
+Keep it realistic, simple and straightforward. It doesn't have to sound like a school exercise, but like a real-world request.
+Do not use generic phrases like "a certain amount"; instead specify exact terms.
+Avoid mentioning tables explicitly. Remove any reference to joins or join keys.
+Do not use any formatting on the answer.
+'''
+
+    # Aliases
+    result += 'Make it clear which columns should be selected. If any columns are aliased in the solution, make sure to reflect that in the request, otherwise students might be confused.'    
+    aliases: list[tuple[str, str]] = []
+    for col in query.main_query.output.columns:
+        if col.name != col.real_name:
+            aliases.append((col.real_name, col.name))
+
+    if aliases:
+        aliases_str = ', '.join([f'"{alias}"' for real_name, alias in aliases])
+        result += f"\nIn particular, you must specify the need to use the following aliases: {aliases_str}."
+
+    result += f'''
+
+Natural Language Request:
+--- REQUEST START ---
+{request}
+--- REQUEST END ---
+'''
+    
+    return result

{sql_assignment_generator-0.0.9 → sql_assignment_generator-0.0.11}/src/sql_assignment_generator/constraints/__init__.py

@@ -1,5 +1,7 @@
 '''Constraints for assignment generation.'''
 
 from .base import BaseConstraint
+from .query import QueryConstraint
+from .schema import SchemaConstraint
 from . import query
 from . import schema

sql_assignment_generator-0.0.11/src/sql_assignment_generator/constraints/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from sqlscope import Query
+from sqlglot import exp
+
+class BaseConstraint(ABC):
+    '''Abstract base class for SQL query constraints.'''
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        '''Textual description of the constraint, to be used in prompts.'''
+        pass

sql_assignment_generator-0.0.11/src/sql_assignment_generator/constraints/costraintType.py

@@ -0,0 +1,19 @@
+from enum import Enum
+
+class WhereConstraintType(Enum):
+    # CLASSIC = "WHERE conditions"
+    # STRING = "WHERE STRING conditions"
+    # EMPTY = "WHERE EMPTY conditions"
+    # NULL = "WHERE NULL conditions"
+    # NOT_NULL = "WHERE NOT NULL conditions"
+    # MULTIPLE = "MULTIPLE WHERE conditions"
+    NESTED = "NESTED WHERE conditions"
+    # WILDCARD = "WHERE conditions with WILDCARD that must have minimum 4 letters"
+    # NO_WILDCARD = "WHERE conditions without WILDCARD"
+    # EXIST = "EXIST in WHERE conditions"
+    # NOT_EXIST = "NOT EXIST in WHERE conditions"
+    # EXIST_OR_IN = "EXIST and NOT EXIST or IN and NOT IN into WHERE conditions"
+    # NOT = "NOT in WHERE conditions"
+    # COMPARISON_OPERATORS = "COMPARISON OPERATORS in WHERE conditions"
+    ANY_ALL_IN = "ANY or ALL or IN in WHERE conditions"
+    # HAVING = "WHERE or HAVING conditions"

sql_assignment_generator-0.0.11/src/sql_assignment_generator/constraints/query/__init__.py

@@ -0,0 +1,4 @@
+'''Constraints related to SQL queries.'''
+
+from .base import QueryConstraint
+from . import aggregation, clause_select, clause_from, clause_where, clause_group_by, clause_having, clause_order_by, rows, set_operations, subquery