text2model 0.1.0__py3-none-any.whl

text2model/prompts/global_constraint_prompts/lex_less_prompt.txt

@@ -0,0 +1,68 @@
+You are a constraint modeling assistant specialized in MiniZinc, especially in detecting and modeling lexicographic ordering constraints such as `lex_less`.
+
+## Task
+Given a **problem description** and optional **input data**, decide whether the problem **requires a lexicographic constraint** (either `lex_less` or `lex_lesseq`).
+
+- If it does, generate **only MiniZinc code** specifying the appropriate lexicographic constraint and its relevant variables.
+- Do **not** generate any other constraints.
+- If it does **not** require lexicographic ordering, return `FALSE` and a brief reason.
+
+The MiniZinc code should assume that the data needed, will be provided in **input data** through a .dzn file.
+
+## What is a lexicographic constraint?
+Lexicographic constraints (`lex_less`, `lex_lesseq`) compare two sequences (arrays) of variables element-wise in order. They are used to:
+- Eliminate symmetric solutions
+- Impose ordering among configurations or schedules
+- Maintain canonical form
+
+## Detection Guide: Common Clues
+Use `lex_less` or `lex_lesseq` when the problem includes language such as:
+- "Configuration A must be before configuration B"
+- "Sort lexicographically"
+- "Solution vectors must be in order"
+- "Break symmetry by comparing rows"
+
+Heuristic:
+- Use `lex_less(a, b)` if strict ordering is required.
+- Use `lex_lesseq(a, b)` for non-strict (A ≤ B lexicographically).
+
+## Output Format
+- If constraint is needed, output **MiniZinc code only**, using `include "globals.mzn";`
+- If not needed, return:
+  ```text
+  FALSE
+  Reason: <short explanation>
+  ```
+
+## MiniZinc Snippets
+```mzn
+include "globals.mzn";
+
+int: n;
+array[1..n] of var int: a;
+array[1..n] of var int: b;
+
+constraint lex_less(a, b);
+```
+
+## Examples
+### ✅ Lex ordering in a matrix
+"Rows in the matrix must be lexicographically ordered"
+```mzn
+include "globals.mzn";
+
+int: r = 3;
+int: c = 4;
+array[1..r, 1..c] of var 0..1: mat;
+
+constraint forall(i in 1..r-1)(
+  lex_lesseq([mat[i,j] | j in 1..c], [mat[i+1,j] | j in 1..c])
+);
+```
+
+### ❌ Not a lexicographic constraint
+"Ensure each item is assigned a unique time slot"
+```text
+FALSE
+Reason: This is a uniqueness constraint — use all_different, not lex_lesseq or lex_less.
+```

text2model/prompts/grammar_validation_prompt.txt

@@ -0,0 +1,18 @@
+You are given a MiniZinc model that has syntax errors. Your task is to fix these syntax errors using the MiniZinc grammar specification provided below.
+
+**Problem Description:**
+{problem_description}
+
+**Input Data:**
+{input_data}
+
+**Current Code with Syntax Errors:**
+{current_code}
+
+**Error message after execution:**
+{syntax_error_message}
+
+**MiniZinc Grammar Specification:**
+{minizinc_grammar}
+
+Using the grammar specification above, carefully analyze the syntax errors and correct the code. Please provide the corrected MiniZinc code that adheres to the grammar specification and resolves all syntax errors. Output only the complete and corrected MiniZinc code without additional comments.

text2model/prompts/kg_code_generation_prompt.txt

@@ -0,0 +1,20 @@
+You are an expert MiniZinc developer.
+
+Generate Minizinc code from using the following information:
+
+1. Problem Description: A formal description describing the optimization problem.
+2. Knowledge Graph: Detailing Parameters, Variables, Constraints and Objective.
+3. Input Data: The MiniZinc code should assume that the data needed, will be provided in a specific format through a .dzn file, so the generated code should assume the same names defined in the input data nomenclature.
+
+Please do not generate any other token, except the MiniZinc code.
+
+Problem Description:
+{problem_description}
+
+Knowledge Graph:
+```
+{knowledge_graph}
+```
+
+Input Data:
+{input_data}

text2model/prompts/kg_generation_prompt.txt

@@ -0,0 +1,40 @@
+Given an optimization problem description and the nomenclature to be used for parameters.
+
+Please generate a knowledge-graph.
+
+Problem Description:
+{problem_description}
+
+Input Data:
+{input_data}
+
+Steps to Generate a Knowledge Graph (KG):
+
+1. Identify Parameters:
+- Extract each parameter individually, specifying its type and name.
+- Ensure that parameter names are aligned with the predefined nomenclature.
+- Record any explicit bounds for parameters, if specified.
+- Validate against the problem description to ensure that all relevant parameters are included, checking for any implicitly stated ones.
+
+2. Identify Variables:
+- Identify each variable, noting their types and names.
+- Align variable names with the nomenclature provided, ensuring consistency.
+- Determine and document any bounds (explicit or inferred) for the variables.
+- Cross-verify with the problem description to confirm all necessary variables are accounted for, including those not explicitly mentioned in the nomenclature.
+
+3. Identify Constraints:
+- Detail each constraint separately, recording its description, formula, and associated variables.
+- Classify constraints based on their nature (e.g., linear, nonlinear, global etc..).
+- Highlight if any constraints are global, impacting multiple variables or conditions across the model.
+
+4. Identify Objective:
+- Clearly define the objective function, including its description, mathematical representation, and the variables it affects.
+- Note the type of optimization (minimization, maximization, satisfy) and any relevant constraints tied to the objective.
+- Ensure the objective aligns with the overall goal of the optimization problem as described.
+
+5. Generate Turtle (TTL) Representation:
+- Construct the Turtle format representation using the gathered information on parameters, variables, constraints, and the objective.
+- Sequentially organize the definitions of parameters, variables, constraints, and the objective within the Turtle file.
+- Avoid generalizing the problem statement; focus on defining each component distinctly as outlined in the steps.
+
+Please do not generate any other token other than the knowledge graph itself. No titles, description or markup necessary.

text2model/prompts/objective_generation_prompt.txt

@@ -0,0 +1,34 @@
+You are an expert MiniZinc developer.
+
+Generate MiniZinc code for the Objective from a given problem description with additional information about the parameters, variables and constraints provided.
+
+Given the Parameters, Variables, and Constraints sections of the code, generate only the objective.
+
+When generating the code, follow this format:
+
+```minizinc
+% Objective
+```
+
+Also, make sure to follow the following principles when generating the code:
+
+**General Principles**:
+1. Ensure there is only one objective, which will be a maximization, minimization, or a satisfy problem. Do not forget the `solve` keyword.
+2. Ensure the objective function aligns with the problem description.
+3. Verify the correct usage of variables, parameters and constraints in the objective function.
+
+**Problem Description**:
+{problem_description}
+
+**Input Data**:
+{input_data}
+
+**Parameters and Variables**:
+```minizinc
+{parameters_and_variables}
+```
+
+**Constraints**:
+```minizinc
+{constraints}
+```

text2model/prompts/parameter_and_variable_generation_prompt.txt

@@ -0,0 +1,35 @@
+You are an expert MiniZinc developer.
+
+Generate MiniZinc code for the Parameters and Variables from a given problem description with additional information about input data provided.
+
+The MiniZinc code should assume that the data needed will be provided in a specific format through a .dzn file, so the generated code should assume the same names/data-types defined in the **input data nomenclature and examples**.
+
+When generating the code, follow this format:
+
+```minizinc
+% Parameters
+
+% Variables
+```
+
+Also, make sure to follow the following principles when generating the code:
+
+**General Principles**:
+1. The generated code should assume that data will be provided via a ".dzn" file. Do not declare values directly from the input data nomenclature and examples within the MiniZinc model.
+2. Adhere to the input data and examples precisely when declaring input parameter names and their data types.
+3. Use bounded variables whenever possible. If bounds are explicit (e.g., non-negative), include them as constraints.
+4. When defining arrays of variables, ensure bounds are integers. Apply element-wise constraints in a separate constraint block if bounds depend on array elements.
+5. When defining arrays of variables, ensure bounding constraints are applied separately rather than during initialization to avoid type mismatches.
+6. Define explicit bounds for all variables used in linear expressions, either in their declaration or through additional constraints.
+7. Declare all parameters and sets before using them in other declarations to avoid circular dependencies and ordering issues.
+8. Declare all identifiers (such as indices or ranges like `n`) before using them in any array or parameter declarations.
+9. Ensure that all indices and sets used in parameter and variable declarations are declared beforehand.
+10. When declaring variables, ensure they are appropriately typed (e.g., `int`, `float`).
+11. Variables should have meaningful names related to the problem description.
+12. Include comments to briefly describe each parameter and variable for clarity.
+
+**Problem Description**:
+{problem_description}
+
+**Input Data**:
+{input_data}

text2model/utils.py

@@ -0,0 +1,350 @@
+import ast
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import openai
+from langchain_ollama import ChatOllama
+
+# Global OpenAI API configuration
+API_CONFIG = {
+    'model': 'gpt-4',
+    'temperature': 0,
+    'max_tokens': 4096,
+    'sleep_time': 3
+}
+
+# Package installation directory — used to locate bundled data files
+_PACKAGE_DIR = Path(__file__).parent
+
+
+def _resolve_path(rel_path: str) -> Path:
+    """Resolve a data-file path: try CWD first, then the installed package directory."""
+    p = Path(rel_path)
+    if p.exists():
+        return p
+    pkg_p = _PACKAGE_DIR / rel_path
+    if pkg_p.exists():
+        return pkg_p
+    return p  # Return original; callers handle the missing-file case
+
+
+def extract_code_blocks(text: str) -> str:
+    """Extract code blocks from markdown-formatted text"""
+    pattern = re.compile(r'```(?:\w+)?\n(.*?)\n```', re.DOTALL)
+    matches = pattern.findall(text)
+    return matches[0] if matches else text
+
+
+def extract_global_constraint(text):
+    first_line = text.splitlines()[0]
+    return re.findall(r'`(.*?)`', first_line)[0]
+
+
+def call_api(client, model: str, prompt: str) -> Optional[str]:
+    if model in ["gpt-4", "gpt-4o", "gpt-5.2"]:
+        solution = call_openai_api(client, prompt)
+        print(solution)
+        return solution
+    else:
+        solution = call_ollama_api(client, prompt)
+        return solution
+
+
+def call_openai_api(client: openai.OpenAI, prompt: str) -> Optional[str]:
+    """Call OpenAI API with the given prompt"""
+    try:
+        # Map model names - use o3 for gpt-4o, gpt-5.2 uses its own name
+        model_name = API_CONFIG['model']
+        if model_name == 'gpt-4o':
+            model_name = 'o3-2025-04-16'
+        # gpt-5.2 uses its own name directly
+
+        params = {
+            "model": model_name,
+            "messages": [{"role": "user", "content": prompt}]
+        }
+
+        # Add temperature and max_tokens only for non-reasoning models
+        # Reasoning models: gpt-4o (mapped to o3), gpt-5.2
+        if API_CONFIG['model'] not in ['gpt-4o', 'gpt-5.2']:
+            params["temperature"] = API_CONFIG['temperature']
+            params["max_tokens"] = API_CONFIG['max_tokens']
+
+        completion = client.chat.completions.create(**params)
+        result = completion.choices[0].message.content.strip()
+        return extract_code_blocks(result)
+    except Exception as e:
+        print(f"Error calling OpenAI API: {e}")
+        return None
+
+
+def call_ollama_api(client: ChatOllama, prompt: str) -> Optional[str]:
+    """Call ChatOllama with the given prompt"""
+    try:
+        messages = [
+            {"role": "user", "content": prompt},
+        ]
+        result = client.invoke(messages).content.strip()
+        return extract_code_blocks(result)
+    except Exception as e:
+        print(f"Error calling ChatOllama: {e}")
+        return None
+
+
+def check_syntax(mzn_code: str, dzn_data: str, timeout: int = 60) -> Optional[str]:
+    """Check MiniZinc syntax and return error message if any"""
+    with tempfile.NamedTemporaryFile(suffix='.mzn', mode='w', delete=False) as mzn_f:
+        mzn_f.write(mzn_code)
+        temp_mzn = mzn_f.name
+
+    temp_dzn = None
+    try:
+        cmd = [shutil.which("minizinc") or "minizinc", temp_mzn]
+        if dzn_data and dzn_data.strip():
+            with tempfile.NamedTemporaryFile(suffix='.dzn', mode='w', delete=False) as dzn_f:
+                dzn_f.write(dzn_data)
+                temp_dzn = dzn_f.name
+            cmd.append(temp_dzn)
+
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+        if result.returncode != 0:
+            return result.stderr
+        return None
+    except subprocess.TimeoutExpired:
+        return f"MiniZinc execution timed out after {timeout} seconds"
+    except Exception as e:
+        return f"Error checking syntax: {str(e)}"
+    finally:
+        if os.path.exists(temp_mzn):
+            os.remove(temp_mzn)
+        if temp_dzn and os.path.exists(temp_dzn):
+            os.remove(temp_dzn)
+
+
+def parse_dzn_string(dzn_str: str) -> List[Tuple[str, str]]:
+    """Parse dzn string into parameter-value pairs"""
+    parameters = re.findall(r'(\w+)\s*=\s*[^;]+;', dzn_str)
+    content_list = dzn_str.split("\n")
+    valid_lines = [line for line in content_list if '=' in line]
+    result = list(zip(parameters, valid_lines))
+    return result
+
+
+def create_data_nomenclature(input_data: Dict[str, Any], dzn_data: List[Tuple[str, str]]) -> str:
+    """Create data nomenclature section for prompts.
+
+    Returns empty string if no parameters or no dzn_data.
+    """
+    if not dzn_data:
+        return ""
+
+    parameters = input_data.get('parameters', [])
+
+    if not parameters:
+        return ""
+
+    data_nomenclature = []
+
+    for idx, param in enumerate(parameters):
+        symbol = param['symbol']
+        definition = param['definition']
+        shape = param['shape']
+
+        example_line = next(
+            (line for param_name, line in dzn_data if param_name == symbol),
+            f"{symbol} = N/A;"
+        )
+
+        shape_display = f"[{', '.join(map(str, shape))}]" if shape else "scalar"
+
+        data_nomenclature.append(
+            f"{idx + 1}. {symbol}: {definition}\n"
+            f"Example: {example_line}\n"
+            f"Shape: {shape_display}"
+        )
+
+    return '\n'.join(data_nomenclature)
+
+
+def prepare_problem_data(problem: Dict[str, Any]) -> Dict[str, Any]:
+    """Prepare problem data for use in prompts"""
+    input_data = ast.literal_eval(problem['input.json'])
+
+    if problem.get('data.dzn') and problem['data.dzn'].strip():
+        dzn_data = parse_dzn_string(problem['data.dzn'])
+    else:
+        dzn_data = []
+
+    data_nomenclature = create_data_nomenclature(input_data, dzn_data)
+
+    return {
+        'description': input_data['description'],
+        'data_nomenclature': data_nomenclature,
+        'objective_type': input_data.get('metadata', {}).get('objective', 'unknown'),
+        'identifier': input_data.get('metadata', {}).get('identifier', ''),
+        'input_data': input_data,
+        'dzn_data': dzn_data
+    }
+
+
+def get_effective_input_data(problem_data: Dict[str, Any]) -> str:
+    """Get the input data, with instructions if no dzn data exists."""
+    if not problem_data['data_nomenclature'].strip():
+        return """IMPORTANT: All data and parameters are already included in the problem description above.
+You must embed all data directly in the MiniZinc model - do not expect external .dzn files or assume data will be provided separately.
+Generate MiniZinc code ONLY. Do NOT generate CPOPT, COPT, or any other format even if the problem description mentions it."""
+
+    return problem_data['data_nomenclature']
+
+
+def create_baseline_prompt(problem: Dict[str, Any]) -> str:
+    """Create a baseline prompt for single-stage generation"""
+    problem_data = prepare_problem_data(problem)
+    effective_input_data = get_effective_input_data(problem_data)
+
+    if problem_data['data_nomenclature'].strip():
+        return f"""You are an expert MiniZinc developer.
+
+Generate Minizinc code from a given problem description with additional information about the parameters provided.
+
+The MiniZinc code should assume that the data needed, will be provided in a specific format through a .dzn file, so the generated code should assume the same names defined in the input data nomenclature.
+
+Please do not generate any other token, except the MiniZinc code.
+
+Problem Description:
+{problem_data['description']}
+
+Input Data Nomenclature:
+{effective_input_data}
+"""
+    else:
+        return f"""You are an expert MiniZinc developer.
+
+Generate MiniZinc code from the given problem description. All data and parameters are included in the problem description, so embed them directly in your MiniZinc model.
+
+IMPORTANT: Generate MiniZinc code ONLY. Do NOT generate CPOPT, COPT, or any other format even if the problem description asks for it.
+
+Please do not generate any other token, except the MiniZinc code.
+
+Problem Description:
+{problem_data['description']}
+"""
+
+
+def create_problem_from_text(text: str) -> Dict[str, Any]:
+    """Create a dataset-compatible problem dict from a plain text description."""
+    input_data = {
+        'description': text,
+        'parameters': [],
+        'metadata': {
+            'objective': 'unknown',
+            'identifier': 'user_problem',
+            'source': 'user',
+        }
+    }
+    return {
+        'input.json': repr(input_data),
+        'data.dzn': '',
+    }
+
+
+def save_solution(output_dir: str, problem_id: str, solution: str) -> None:
+    """Save the generated solution to a file"""
+    os.makedirs(output_dir, exist_ok=True)
+    output_path = os.path.join(output_dir, f"{problem_id}.mzn")
+    with open(output_path, 'w') as f:
+        f.write(solution)
+
+
+def load_file(file_path: str) -> str:
+    """Load a file, resolving the path relative to the package directory if not found locally."""
+    p = _resolve_path(file_path)
+    try:
+        return p.read_text()
+    except FileNotFoundError:
+        print(f"File not found: {file_path}")
+        return ""
+
+
+def get_problem_source(problem):
+    """Extract the source from problem's input.json metadata"""
+    try:
+        input_data = ast.literal_eval(problem['input.json'])
+        return input_data.get('metadata', {}).get('source', None)
+    except Exception:
+        return None
+
+
+def get_problem_identifier(problem, idx):
+    """Extract the identifier from problem's input.json metadata."""
+    try:
+        input_data = ast.literal_eval(problem['input.json'])
+        metadata = input_data.get('metadata', {})
+        identifier = metadata.get('identifier', '')
+
+        if not identifier or not identifier.strip():
+            source = metadata.get('source', 'unknown')
+            safe_source = re.sub(r'[^\w\-]', '_', source.lower())
+            identifier = f"{safe_source}_problem_{idx}"
+        elif identifier in ['easy_lp', 'complex_lp']:
+            identifier = f"{identifier}_{idx}"
+
+        return identifier
+    except Exception:
+        return f"unknown_problem_{idx}"
+
+
+def get_cardinal_ops_subfolder(problem):
+    """Determine the subfolder name for cardinal_operations datasets."""
+    try:
+        input_data = ast.literal_eval(problem['input.json'])
+        metadata = input_data.get('metadata', {})
+        source = metadata.get('source', '')
+        identifier = metadata.get('identifier', '')
+
+        if not source.startswith('cardinal_operations'):
+            return None
+
+        if source == 'cardinal_operations_mamo':
+            if identifier == 'easy_lp':
+                return 'easylp'
+            elif identifier == 'complex_lp':
+                return 'complexlp'
+            else:
+                return 'mamo'
+        elif source == 'cardinal_operations_nl4opt':
+            return 'nl4opt'
+        elif source == 'cardinal_operations_industryor':
+            return 'industryor'
+        else:
+            suffix = source.replace('cardinal_operations_', '')
+            return suffix if suffix else None
+
+    except Exception:
+        return None
+
+
+def filter_dataset_by_source(dataset, source_filter):
+    """Filter dataset by source field in metadata"""
+    def matches_source(problem):
+        source = get_problem_source(problem)
+        if source is None:
+            return False
+        return source_filter.lower() in source.lower()
+
+    return dataset.filter(matches_source)
+
+
+def get_available_sources(dataset):
+    """Get all unique sources in the dataset"""
+    sources = set()
+    for problem in dataset:
+        source = get_problem_source(problem)
+        if source:
+            sources.add(source)
+    return sorted(sources)