sql-assignment-generator 0.0.16__tar.gz → 0.0.17__tar.gz

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql_assignment_generator
-Version: 0.0.16
+Version: 0.0.17
 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

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sql_assignment_generator"
-version = "0.0.16"
+version = "0.0.17"
 authors = [
   { name="Davide Ponzini", email="davide.ponzini95@gmail.com" },
 ]

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_004.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
 from ..constraints import schema as schema_constraints, query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err004_UndefinedColumn(SqlErrorRequirements):
     def dataset_constraints(self, difficulty: DifficultyLevel) -> list[schema_constraints.SchemaConstraint]:
@@ -49,5 +50,8 @@ class Err004_UndefinedColumn(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return 'This exercise should require students to reference a large number of columns in solution.'
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'This exercise should require students to reference a large number of columns in solution.',
+            it='Questo esercizio dovrebbe richiedere agli studenti di fare riferimento a un gran numero di colonne nella soluzione.'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_010.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err010_Synonyms(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,6 +31,10 @@ class Err010_Synonyms(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def dataset_extra_details(self) -> str:
-        return 'The identifier column name must NOT be <entity>_id; pick a plausible synonym instead (e.g., <entity>_code, <entity>_key, <entity>_ref, <entity>_number,  etc). ' \
-        'Additionally, I want naming conventions NOT to be consistent across tables; different tables must have different naming conventions for similar concepts: e.g. if Table1 uses (first_name, last_name), Table2 uses (name, surname)'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'The identifier column name must NOT be <entity>_id; pick a plausible synonym instead (e.g., <entity>_code, <entity>_key, <entity>_ref, <entity>_number,  etc). ' \
+            'Additionally, I want naming conventions NOT to be consistent across tables; different tables must have different naming conventions for similar concepts: e.g. if Table1 uses (first_name, last_name), Table2 uses (name, surname)',
+            it='Il nome della colonna identificatore non deve essere <entità>_id; scegliere un sinonimo plausibile invece (es. <entità>_codice, <entità>_chiave, <entità>_rif, <entità>_numero,  ecc). ' \
+               'Inoltre, voglio che le convenzioni di denominazione NON siano coerenti tra tabelle; diverse tabelle devono avere convenzioni di denominazione diverse per concetti simili: es. se Tabella1 usa (first_name, last_name), Tabella2 usa (name, surname)'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_011.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err011_OmittingQuotesAroundCharacterData(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,5 +31,8 @@ class Err011_OmittingQuotesAroundCharacterData(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def dataset_extra_details(self) -> str:
-        return 'All the dataset tables must have at least one string attribute.'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'All the dataset tables must have at least one string attribute.',
+            it='Tutte le tabelle del dataset devono avere almeno un attributo di tipo stringa.'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_012.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err012_FailureToSpecifyColumnNameTwice(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,7 +31,12 @@ class Err012_FailureToSpecifyColumnNameTwice(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "Solution query must have multiple simple conditions on the SAME COLUMN (e.g. p.film='Alien' OR p.film='Superman'. This represents one column with MULTIPLE CONDITION). " \
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "Solution query must have multiple simple conditions on the SAME COLUMN (e.g. p.film='Alien' OR p.film='Superman'. This represents one column with MULTIPLE CONDITION). " \
             "Solution must not have IN formatted like 'position IN ('Manager', 'Supervisor')' but I want this formatted as 'position ='Manager' OR position = 'Supervisor''" \
-            "exercise should naturally tempts student to make a mistake that can cause 'miss column name' errors (e.g. WHERE city='Boston' OR 'Chicago')."
+            "exercise should naturally tempts student to make a mistake that can cause 'miss column name' errors (e.g. WHERE city='Boston' OR 'Chicago').",
+            it="La query soluzione deve avere più condizioni semplici sulla STESSA COLONNA (es. p.film='Alien' OR p.film='Superman'. Questo rappresenta una colonna con CONDIZIONI MULTIPLE). " \
+               "La soluzione non deve usare IN formattato come 'position IN ('Manager', 'Supervisor')', ma voglio che sia formattato come 'position ='Manager' OR position = 'Supervisor''" \
+               "l'esercizio dovrebbe naturalmente tentare lo studente a commettere un errore che può causare errori di tipo 'colonna mancante' (es. WHERE city='Boston' OR 'Chicago')."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_015.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err015_AggregateFunctionsCannotBeNested(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,6 +31,8 @@ class Err015_AggregateFunctionsCannotBeNested(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation(2)
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "Generate a query in natural language that seems to involve one AGGREGATION " \
-        "inside another (e.g. 'the book that has the maximum number of sales' -- and the database doesn't store the sales count)."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "Generate a query in natural language that seems to involve one AGGREGATION inside another (e.g. 'the book that has the maximum number of sales' -- and the database doesn't store the sales count).",
+            it="Genera una query in linguaggio naturale che sembra coinvolgere un AGGREGATO dentro un altro (es. 'il libro che ha il massimo numero di vendite' -- e il database non memorizza il conteggio delle vendite)."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_019.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err019_UsingWhereTwice(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_021.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err021_ComparisonWithNull(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,5 +31,8 @@ class Err021_ComparisonWithNull(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation(2)
         ]
 
-    def dataset_extra_details(self) -> str:
-        return 'Some non-key columns in the dataset must have NULL values.'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "Some non-key columns in the dataset must have NULL values.",
+            it="Alcune colonne non chiave nel dataset devono avere valori NULL."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_026.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err026_TooManyColumnsInSubquery(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,6 +31,8 @@ class Err026_TooManyColumnsInSubquery(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation(2)
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "The exercise should require comparing each row with " \
-        "a value from the same row or subset of rows (e.g. 'WHERE balance <comparison operator> (SELECT balance ... WHERE name = 'John')')"
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The exercise should require comparing each row with a value from the same row or subset of rows (e.g. 'WHERE balance <comparison operator> (SELECT balance ... WHERE name = 'John')')",
+            it="L'esercizio dovrebbe richiedere il confronto di ogni riga con un valore della stessa riga o di un sottoinsieme di righe (es. 'WHERE bilancio <operatore di confronto> (SELECT bilancio ... WHERE nome = 'Mario')')"
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_035.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err035_IsWhereNotApplicable(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,5 +31,8 @@ class Err035_IsWhereNotApplicable(SqlErrorRequirements):
             query_constraints.subquery.Subqueries()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "The exercise must require equality comparisons (i.e. '=') in WHERE conditions"
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The exercise must require equality comparisons (i.e. '=') in WHERE conditions",
+            it="L'esercizio deve richiedere confronti di uguaglianza (cioè '=') nelle condizioni WHERE"
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_039.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err039_AndInsteadOfOr(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,7 +31,12 @@ class Err039_AndInsteadOfOr(SqlErrorRequirements):
             query_constraints.subquery.Subqueries()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "The exercise must require multiple OR conditions on the same column " \
-        "(e.g. p.bornCity='Rome' OR p.bornCity='Genoa'. This represent one column with multiple conditions). " \
-        "It is mandatory use the parentesis to give precedence to a separate condition. "
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The exercise must require multiple OR conditions on the same column " \
+            "(e.g. p.bornCity='Rome' OR p.bornCity='Genoa'. This represent one column with multiple conditions). " \
+            "It is mandatory use the parentesis to give precedence to a separate condition. ",
+            it="L'esercizio deve richiedere condizioni OR multiple sulla stessa colonna " \
+               "(es. p.cittàNascita='Roma' OR p.cittàNascita='Genova'. Questo rappresenta una colonna con più condizioni). " \
+               "E' obbligatorio usare le parentesi per dare precedenza a una condizione separata."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_040.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
 from ..constraints import schema as schema_constraints, query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err040_ImpliedTautologicalOrInconsistentExpressions(SqlErrorRequirements):
     def dataset_constraints(self, difficulty: DifficultyLevel) -> list[schema_constraints.SchemaConstraint]:
@@ -50,6 +51,10 @@ class Err040_ImpliedTautologicalOrInconsistentExpressions(SqlErrorRequirements):
             query_constraints.subquery.Subqueries()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "Exercise should require multiple conditions on the same column " \
-         "(e.g. p.age < 18 OR p.age >= 0 this represent one column with multiple conditions)."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "Exercise should require multiple conditions on the same column " \
+            "(e.g. p.age < 18 AND p.age >= 0 this represent one column with multiple conditions).",
+            it="L'esercizio deve richiedere condizioni multiple sulla stessa colonna " \
+               "(es. p.età < 18 AND p.età >= 0 questo rappresenta una colonna con più condizioni)."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_041.py

@@ -1,7 +1,8 @@
 import random
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err041_DistinctInSumOrAvg(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -42,9 +43,16 @@ class Err041_DistinctInSumOrAvg(SqlErrorRequirements):
             query_constraints.rows.Duplicates()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "The natural language request must contain the word 'distinct' " \
-        "but the DISTINCT keyword should not be used in the SQL query."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The natural language request must contain the word 'distinct' " \
+            "but the DISTINCT keyword should not be used in the SQL query.",
+            it="La richiesta in linguaggio naturale deve contenere la parola 'distinti' " \
+               "ma la parola chiave DISTINCT non deve essere usata nella query SQL."
+        )
 
-    def dataset_extra_details(self) -> str:
-        return 'The table must have non-key numeric attributes'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'The table must have non-key numeric attributes',
+            it='La tabella deve avere attributi numerici non chiave'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_042.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err042_DistinctThatMightRemoveImportantDuplicates(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -38,6 +39,10 @@ class Err042_DistinctThatMightRemoveImportantDuplicates(SqlErrorRequirements):
             
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "The exercise must require selecting attributes that can cause duplicates such as cities, names, etc." \
-        "Attributes that can identify a record (i.e. primary keys or unique attributes) MUST NOT be selected (e.g. phone number, address, etc.)."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The exercise must require selecting attributes that can cause duplicates such as cities, names, etc." \
+            "Attributes that can identify a record (i.e. primary keys or unique attributes) MUST NOT be selected (e.g. phone number, address, etc.).",
+            it="L'esercizio deve richiedere la selezione di attributi che possono causare duplicati come città, nomi, ecc." \
+               "Attributi che possono identificare un record (i.e. chiavi primarie o attributi univoci) NON DEVONO essere selezionati (es. numero di telefono, indirizzo, ecc.)."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_043.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err043_WildcardsWithoutLike(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -31,5 +32,8 @@ class Err043_WildcardsWithoutLike(SqlErrorRequirements):
             query_constraints.subquery.Subqueries()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return 'In the exercise there are WILDCARD with whole words longer than 5 characters.'
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'In the exercise there are WILDCARD with whole words longer than 5 characters.',
+            it='Nell\'esercizio ci sono WILDCARD con parole intere più lunghe di 5 caratteri.'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_044.py

@@ -1,11 +1,12 @@
 import random
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err044_IncorrectWildcard(SqlErrorRequirements):
-    def __init__(self):
-        super().__init__()
+    def __init__(self, language: str):
+        super().__init__(language=language)
         self._selected_symbols = ''
 
     def _prepare_symbols(self, difficulty: DifficultyLevel):
@@ -53,6 +54,8 @@ class Err044_IncorrectWildcard(SqlErrorRequirements):
             query_constraints.subquery.Subqueries()
         ]
 
-    def exercise_extra_details(self) -> str:
-        symbols_str = ' and '.join([f'\'{s}\'' for s in self._selected_symbols])
-        return f'''Creates queries that must include {symbols_str} symbol in LIKE wildcard.'''
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            f'Creates queries that must include the following symbols in LIKE wildcard: {" and ".join(self._selected_symbols)}',
+            it=f'Crea query che devono includere i seguenti simboli nei wildcard di LIKE: {" e ".join(self._selected_symbols)}'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_045.py

@@ -1,8 +1,8 @@
 import random
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
-
+from ..translatable_text import TranslatableText
 class Err045_MixingGT0WithIsNotNullOrEmptyStringWithNull(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
         constraints = super().exercise_constraints(difficulty)
@@ -38,5 +38,8 @@ class Err045_MixingGT0WithIsNotNullOrEmptyStringWithNull(SqlErrorRequirements):
         ]
 
 
-    def dataset_extra_details(self) -> str:
-        return 'Table must have some NULL, non-NULL, and NUMERIC attributes. Some string values must also be empty strings.'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'Table must have some NULL, non-NULL, and NUMERIC attributes. Some string values must also be empty strings.',
+            it='La tabella deve avere alcuni valori NULL, non NULL e NUMERIC. Alcuni valori stringa devono essere anche stringhe vuote.'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_046.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err046_NullInInAnyAllSubquery(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -27,8 +28,14 @@ class Err046_NullInInAnyAllSubquery(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return 'The exercise must involve a subquery that returns at least one nullable value.'
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'The exercise must involve a subquery that returns at least one nullable value.',
+            it='L\'esercizio deve coinvolgere una subquery che restituisce almeno un valore NULL.'
+        )
 
-    def dataset_extra_details(self) -> str:
-        return 'Dataset must contain NULL values.'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'Dataset must contain NULL values.',
+            it='Il dataset deve contenere valori NULL.'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_049.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err049_ManyDuplicates(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_052.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err052_OrInsteadOfAnd(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,5 +31,8 @@ class Err052_OrInsteadOfAnd(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "Solution query must have multiple AND conditions (e.g. p.film='Eragon' AND p.type='Fantasy')."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "Solution query must have multiple AND conditions (e.g. p.film='Eragon' AND p.type='Fantasy').",
+            it="La query soluzione deve avere più condizioni AND (es. p.film='Eragon' AND p.type='Fantasy')."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_053.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
 from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err053_ExtraneousNot(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -30,5 +31,8 @@ class Err053_ExtraneousNot(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation(2)
         ]
 
-    def exercise_extra_details(self) -> str:
-        return 'The exercise must require at least one WHERE condition without NOT"'
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'The exercise must require at least one WHERE condition without NOT.',
+            it='L\'esercizio deve richiedere almeno una condizione WHERE senza NOT.'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_054.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err054_MissingNot(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -33,5 +34,8 @@ class Err054_MissingNot(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return 'The exercise should require multiple NOT conditions in WHERE clauses'
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'The exercise should require multiple NOT conditions in WHERE clauses',
+            it='L\'esercizio deve richiedere più condizioni NOT nelle clausole WHERE'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_055.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err055_SubstitutingExistanceNegation(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -31,6 +32,8 @@ class Err055_SubstitutingExistanceNegation(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation(2),
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "The exercise must require selecting all Xs that are associated with all Ys (e.g. customers who " \
-        "bought all products in category C, customer who bought all products that cost more than 50, etc.)."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The exercise must require selecting all Xs that are associated with all Ys (e.g. customers who bought all products in category C, customer who bought all products that cost more than 50, etc.).",
+            it="L'esercizio deve richiedere la selezione di tutti gli X associati a tutti gli Y (es. clienti che hanno comprato tutti i prodotti nella categoria C, cliente che ha comprato tutti i prodotti che costano più di 50, ecc.)."
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_057.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err057_IncorrectComparisonOperatorOrIncorrectValueCompared(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_058.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err058_JoinOnIncorrectTable(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_059.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err059_JoinWhenJoinNeedsToBeOmitted(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_060.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err060_JoinOnIncorrectColumn(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -32,9 +33,14 @@ class Err060_JoinOnIncorrectColumn(SqlErrorRequirements):
             query_constraints.clause_from.TableReferences(3)
         ]
 
-    def exercise_extra_details(self) -> str:
-        return "Solution MUST USE composite FOREIGN KEY in join " \
-        "(e.g. column1 a JOIN column2 b ON (a.col1= b.col1) AND (a.col2 = b.col2))"
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "Solution MUST USE composite FOREIGN KEY in join (e.g. column1 a JOIN column2 b ON (a.col1= b.col1) AND (a.col2 = b.col2))",
+            it="La soluzione DEVE USARE una chiave esterna composta in un join (es. column1 a JOIN column2 b ON (a.col1= b.col1) AND (a.col2 = b.col2))"
+        )
 
-    def dataset_extra_details(self) -> str:
-        return 'Composite foreign keys must be used in CREATE TABLE statements'
+    def dataset_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            'Composite foreign keys must be used in CREATE TABLE statements',
+            it='Le chiavi esterne composte devono essere usate nelle istruzioni CREATE TABLE'
+        )

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_062.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err062_MissingJoin(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_063.py

@@ -1,6 +1,7 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
+from ..translatable_text import TranslatableText
 
 class Err063_ImproperNestingOfExpressions(SqlErrorRequirements):
     def exercise_constraints(self, difficulty: DifficultyLevel) -> list[query_constraints.QueryConstraint]:
@@ -29,11 +30,9 @@ class Err063_ImproperNestingOfExpressions(SqlErrorRequirements):
             query_constraints.aggregation.Aggregation()
         ]
 
-    def exercise_extra_details(self) -> str:
-        return (
-            "The WHERE clause must require nested logical expressions where parentheses are mandatory "
-            "to ensure correct operator precedence (e.g., '(condition1 OR condition2) AND condition3'). "
-            "The logic must be realistic and the parentheses must be essential for the query's "
-            "correctness, not redundant."
+    def exercise_extra_details(self) -> TranslatableText:
+        return TranslatableText(
+            "The WHERE clause must require nested logical expressions where parentheses are mandatory to ensure correct operator precedence (e.g., '(condition1 OR condition2) AND condition3'). The logic must be realistic and the parentheses must be essential for the query's correctness, not redundant.",
+            it="La clausola WHERE deve richiedere espressioni logiche annidate dove le parentesi sono obbligatorie per garantire la corretta precedenza degli operatori (es. '(condizione1 OR condizione2) AND condizione3'). La logica deve essere realistica e le parentesi devono essere essenziali per la correttezza della query, non ridondanti."
         )
     

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_064.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err064_ImproperNestingOfSubqueries(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_066.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err066_MissingExpression(SqlErrorRequirements):

{sql_assignment_generator-0.0.16 → sql_assignment_generator-0.0.17}/src/sql_assignment_generator/error_requirements/err_067.py

@@ -1,5 +1,5 @@
 from .base import SqlErrorRequirements
-from ..constraints import schema as schema_constraints, query as query_constraints
+from ..constraints import query as query_constraints
 from ..difficulty_level import DifficultyLevel
 
 class Err067_ExpressionOnIncorrectColumn(SqlErrorRequirements):