parse-lp 2.6.1__tar.gz → 2.6.2__tar.gz

{parse_lp-2.6.1 → parse_lp-2.6.2}/Cargo.lock

@@ -195,7 +195,7 @@ checksum = "9556bc800956545d6420a640173e5ba7dfa82f38d3ea5a167eb555bc69ac3323"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -259,9 +259,9 @@ dependencies = [
 
 [[package]]
 name = "insta"
-version = "1.44.1"
+version = "1.44.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8732d3774162a0851e3f2b150eb98f31a9885dd75985099421d393385a01dfd"
+checksum = "dfd3461e1f00283105bdf97c3a1aca2b3f8456eb809a96938d2b190cd4dbc6d2"
 dependencies = [
  "console",
  "once_cell",
@@ -307,7 +307,7 @@ checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "lp_parser_rs"
-version = "2.5.1"
+version = "2.5.2"
 dependencies = [
  "csv",
  "diff-struct",
@@ -429,7 +429,7 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "parse_lp"
-version = "2.6.1"
+version = "2.6.2"
 dependencies = [
  "lp_parser_rs",
  "pyo3",
@@ -465,7 +465,7 @@ dependencies = [
  "pest_meta",
  "proc-macro2",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -538,7 +538,7 @@ dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -551,7 +551,7 @@ dependencies = [
  "proc-macro2",
  "pyo3-build-config",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -627,7 +627,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -679,9 +679,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.110"
+version = "2.0.111"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a99801b5bd34ede4cf3fc688c5919368fea4e4814a4664359503e6015b280aea"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -721,7 +721,7 @@ checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
 ]
 
 [[package]]
@@ -816,7 +816,7 @@ dependencies = [
  "bumpalo",
  "proc-macro2",
  "quote",
- "syn 2.0.110",
+ "syn 2.0.111",
  "wasm-bindgen-shared",
 ]
 

parse_lp-2.6.2/PKG-INFO

@@ -0,0 +1,308 @@
+Metadata-Version: 2.4
+Name: parse_lp
+Version: 2.6.2
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+License-File: LICENSE-APACHE
+Summary: A LP file format parser for Python, powered by Rust
+Keywords: linear-programming,optimization,parser,integer-programming,math
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# parse_lp
+
+[![PyPI version](https://badge.fury.io/py/parse-lp.svg)](https://badge.fury.io/py/parse-lp)
+
+A LP file format parser, writer, and modifier for Python, powered by Rust.
+
+## Features
+
+- **Complete LP Support**: Handles all standard LP file format features
+- **Problem Modification**: Programmatically modify objectives, constraints, and variables
+- **LP File Writing**: Generate LP files from modified problems with round-trip compatibility
+- **Easy Data Access**: Direct access to problem components (variables, constraints, objectives)
+- **CSV Export**: Export parsed data to CSV files for further analysis
+- **Problem Comparison**: Compare two LP problems to identify differences
+- **Type Safety**: Full type hints for better IDE support and development experience
+
+## Installation
+
+```bash
+pip install parse_lp
+```
+
+## Quick Start
+
+```python
+from parse_lp import LpParser
+
+# Parse an LP file
+parser = LpParser("path/to/problem.lp")
+parser.parse()
+
+# Access problem information
+print(f"Problem: {parser.name}")
+print(f"Sense: {parser.sense}")
+print(f"Variables: {parser.variable_count()}")
+print(f"Constraints: {parser.constraint_count()}")
+
+# Modify the problem
+parser.update_objective_coefficient("OBJ", "x1", 5.0)
+parser.rename_variable("x2", "production")
+parser.update_constraint_rhs("C1", 100.0)
+
+# Write back to LP format
+modified_lp = parser.to_lp_string()
+parser.save_to_file("modified_problem.lp")
+
+# Export to CSV files
+parser.to_csv("output_directory/")
+```
+
+## Usage Examples
+
+### Basic Parsing and Information
+
+```python
+from parse_lp import LpParser
+
+parser = LpParser("optimization_problem.lp")
+parser.parse()
+
+# Get problem overview
+print(f"Problem Name: {parser.name}")
+print(f"Optimization Sense: {parser.sense}")
+print(f"Variables: {parser.variable_count()}")
+print(f"Constraints: {parser.constraint_count()}")
+print(f"Objectives: {parser.objective_count()}")
+```
+
+### Accessing Problem Data
+
+```python
+# Access objectives
+for i, objective in enumerate(parser.objectives):
+    print(f"Objective {i+1}: {objective['name']}")
+    for coef in objective['coefficients']:
+        print(f"  {coef['name']}: {coef['value']}")
+
+# Access variables
+for var_name, var_info in parser.variables.items():
+    print(f"Variable {var_name}:")
+    print(f"  Type: {var_info['var_type']}")
+    if 'bounds' in var_info:
+        bounds = var_info['bounds']
+        if 'lower' in bounds:
+            print(f"  Lower bound: {bounds['lower']}")
+        if 'upper' in bounds:
+            print(f"  Upper bound: {bounds['upper']}")
+
+# Access constraints
+for constraint in parser.constraints:
+    print(f"Constraint {constraint['name']}:")
+    print(f"  Type: {constraint['type']}")
+    if constraint['type'] == 'standard':
+        print(f"  Sense: {constraint['sense']}")
+        print(f"  RHS: {constraint['rhs']}")
+        print(f"  Coefficients: {len(constraint['coefficients'])}")
+```
+
+### CSV Export
+
+```python
+import os
+
+# Create output directory
+os.makedirs("output", exist_ok=True)
+
+# Export to CSV files
+parser.to_csv("output/")
+
+# Files created:
+# - output/variables.csv
+# - output/constraints.csv
+# - output/objectives.csv
+```
+
+### Problem Modification
+
+```python
+from parse_lp import LpParser
+
+# Parse an existing LP file
+parser = LpParser("optimization_problem.lp")
+parser.parse()
+
+# Modify objectives
+parser.update_objective_coefficient("profit", "x1", 5.0)
+parser.rename_objective("profit", "total_profit")
+
+# Modify constraints
+parser.update_constraint_coefficient("capacity", "x1", 2.0)
+parser.update_constraint_rhs("capacity", 200.0)
+parser.rename_constraint("capacity", "production_limit")
+
+# Modify variables
+parser.rename_variable("x1", "production_a")
+parser.update_variable_type("production_a", "integer")
+
+# Set problem properties
+parser.set_problem_name("Modified Optimization Problem")
+parser.set_sense("minimize")
+
+# Write back to LP format
+modified_lp_content = parser.to_lp_string()
+parser.save_to_file("modified_problem.lp")
+
+# Verify round-trip compatibility
+new_parser = LpParser("modified_problem.lp")
+new_parser.parse()
+print(f"Successfully modified and re-parsed: {new_parser.name}")
+```
+
+### Problem Comparison
+
+```python
+# Parse two different versions of a problem
+parser1 = LpParser("problem_v1.lp")
+parser1.parse()
+
+parser2 = LpParser("problem_v2.lp")
+parser2.parse()
+
+# Compare the problems
+diff = parser1.compare(parser2)
+
+print("Comparison Results:")
+print(f"Name changed: {diff['name_changed']}")
+print(f"Sense changed: {diff['sense_changed']}")
+print(f"Variable count difference: {diff['variable_count_diff']}")
+print(f"Added variables: {diff['added_variables']}")
+print(f"Removed variables: {diff['removed_variables']}")
+print(f"Modified variables: {diff['modified_variables']}")
+print(f"Added constraints: {diff['added_constraints']}")
+print(f"Removed constraints: {diff['removed_constraints']}")
+```
+
+### Objectives Structure
+
+```python
+[
+    {
+        "name": "objective_name",
+        "coefficients": [
+            {"name": "variable_name", "value": 1.5},
+            {"name": "another_var", "value": -2.0}
+        ]
+    }
+]
+```
+
+### Variables Structure
+
+```python
+{
+    "variable_name": {
+        "name": "variable_name",
+        "var_type": "Continuous",  # or "Binary", "Integer", etc.
+        "bounds": {  # Optional
+            "lower": 0.0,  # Optional
+            "upper": 100.0  # Optional
+        }
+    }
+}
+```
+
+### Constraints Structure
+
+```python
+[
+    {
+        "name": "constraint_name",
+        "type": "standard",  # or "sos"
+        "sense": "LessOrEqual",  # "Equal", "GreaterOrEqual"
+        "rhs": 10.0,
+        "coefficients": [
+            {"name": "variable_name", "value": 2.0}
+        ]
+    },
+    {
+        "name": "sos_constraint",
+        "type": "sos",
+        "sos_type": "SOS1",  # or "SOS2"
+        "variables": ["var1", "var2", "var3"]
+    }
+]
+```
+
+## Modification Methods
+
+### Objective Methods
+
+- `update_objective_coefficient(obj_name, var_name, coefficient)` - Update or add coefficient
+- `rename_objective(old_name, new_name)` - Rename an objective
+- `remove_objective(obj_name)` - Remove an objective
+
+### Constraint Methods
+
+- `update_constraint_coefficient(const_name, var_name, coefficient)` - Update or add coefficient
+- `update_constraint_rhs(const_name, new_rhs)` - Update right-hand side value
+- `rename_constraint(old_name, new_name)` - Rename a constraint
+- `remove_constraint(const_name)` - Remove a constraint
+
+### Variable Methods
+
+- `rename_variable(old_name, new_name)` - Rename variable across problem
+- `update_variable_type(var_name, var_type)` - Change variable type
+- `remove_variable(var_name)` - Remove variable from problem
+
+### Problem Methods
+
+- `set_problem_name(name)` - Set problem name
+- `set_sense(sense)` - Set optimization sense ("maximize" or "minimize")
+
+### Writing Methods
+
+- `to_lp_string()` - Generate LP format string
+- `to_lp_string_with_options(**options)` - Generate with custom formatting
+- `save_to_file(filepath)` - Save to LP file
+
+### Variable Types
+
+Supported variable types for `update_variable_type()`:
+
+- `"binary"` - Binary variables (0 or 1)
+- `"integer"` - General integer variables
+- `"general"` - Continuous variables (default)
+- `"free"` - Free variables (no bounds)
+- `"semicontinuous"` - Semi-continuous variables
+
+## Supported LP Format Features
+
+- Multiple objective functions
+- Standard constraints (≤, =, ≥)
+- Variable bounds
+- Variable types (continuous, binary, integer)
+- SOS (Special Ordered Sets) constraints
+- Problem names and comments
+- Scientific notation in coefficients
+
+## License
+
+Licensed under either of Apache License, Version 2.0 or MIT license at your option.
+
+## Contributing
+
+Issues and pull requests are welcome at: <https://github.com/dandxy89/lp_parser_rs>
+
+```bash
+make build
+make install
+make unit-test
+```
+

{parse_lp-2.6.1 → parse_lp-2.6.2}/parse_lp/parse_lp.pyi

@@ -177,3 +177,196 @@ class LpParser:
             RuntimeError: If either parser hasn't been parsed yet.
         """
         ...
+
+    def to_lp_string(self) -> str:
+        """Write the current problem to LP format string.
+
+        Returns:
+            The LP problem as a formatted string.
+
+        Raises:
+            RuntimeError: If the problem cannot be serialized.
+        """
+        ...
+
+    def to_lp_string_with_options(
+        self,
+        *,
+        include_problem_name: bool = True,
+        max_line_length: int = 80,
+        decimal_precision: int = 6,
+        include_section_spacing: bool = True,
+    ) -> str:
+        """Write the current problem to LP format string with custom options.
+
+        Args:
+            include_problem_name: Whether to include the problem name comment.
+            max_line_length: Maximum line length for output formatting.
+            decimal_precision: Number of decimal places for coefficients.
+            include_section_spacing: Whether to add blank lines between sections.
+
+        Returns:
+            The LP problem as a formatted string.
+
+        Raises:
+            RuntimeError: If the problem cannot be serialized.
+        """
+        ...
+
+    def save_to_file(self, filepath: str) -> None:
+        """Save the current problem to an LP file.
+
+        Args:
+            filepath: Path to the output file.
+
+        Raises:
+            RuntimeError: If the file cannot be written.
+        """
+        ...
+
+    def update_objective_coefficient(
+        self, objective_name: str, variable_name: str, coefficient: float
+    ) -> None:
+        """Update a coefficient in an objective function.
+
+        If the variable doesn't exist in the objective, it will be added.
+
+        Args:
+            objective_name: Name of the objective to modify.
+            variable_name: Name of the variable whose coefficient to update.
+            coefficient: New coefficient value.
+
+        Raises:
+            RuntimeError: If the objective is not found or update fails.
+        """
+        ...
+
+    def rename_objective(self, old_name: str, new_name: str) -> None:
+        """Rename an objective function.
+
+        Args:
+            old_name: Current name of the objective.
+            new_name: New name for the objective.
+
+        Raises:
+            RuntimeError: If the objective is not found.
+        """
+        ...
+
+    def remove_objective(self, objective_name: str) -> None:
+        """Remove an objective function from the problem.
+
+        Args:
+            objective_name: Name of the objective to remove.
+
+        Raises:
+            RuntimeError: If the objective is not found.
+        """
+        ...
+
+    def update_constraint_coefficient(
+        self, constraint_name: str, variable_name: str, coefficient: float
+    ) -> None:
+        """Update a coefficient in a constraint.
+
+        If the variable doesn't exist in the constraint, it will be added.
+
+        Args:
+            constraint_name: Name of the constraint to modify.
+            variable_name: Name of the variable whose coefficient to update.
+            coefficient: New coefficient value.
+
+        Raises:
+            RuntimeError: If the constraint is not found or update fails.
+        """
+        ...
+
+    def update_constraint_rhs(self, constraint_name: str, new_rhs: float) -> None:
+        """Update the right-hand side value of a constraint.
+
+        Args:
+            constraint_name: Name of the constraint to modify.
+            new_rhs: New right-hand side value.
+
+        Raises:
+            RuntimeError: If the constraint is not found.
+        """
+        ...
+
+    def rename_constraint(self, old_name: str, new_name: str) -> None:
+        """Rename a constraint.
+
+        Args:
+            old_name: Current name of the constraint.
+            new_name: New name for the constraint.
+
+        Raises:
+            RuntimeError: If the constraint is not found.
+        """
+        ...
+
+    def remove_constraint(self, constraint_name: str) -> None:
+        """Remove a constraint from the problem.
+
+        Args:
+            constraint_name: Name of the constraint to remove.
+
+        Raises:
+            RuntimeError: If the constraint is not found.
+        """
+        ...
+
+    def rename_variable(self, old_name: str, new_name: str) -> None:
+        """Rename a variable across all objectives and constraints.
+
+        Args:
+            old_name: Current name of the variable.
+            new_name: New name for the variable.
+
+        Raises:
+            RuntimeError: If the variable is not found.
+        """
+        ...
+
+    def update_variable_type(self, variable_name: str, var_type: str) -> None:
+        """Update the type of a variable.
+
+        Args:
+            variable_name: Name of the variable to modify.
+            var_type: New type for the variable. Supported types:
+                'binary', 'integer', 'general', 'free', 'semicontinuous'.
+
+        Raises:
+            RuntimeError: If the variable is not found or type is invalid.
+        """
+        ...
+
+    def remove_variable(self, variable_name: str) -> None:
+        """Remove a variable from all objectives and constraints.
+
+        Args:
+            variable_name: Name of the variable to remove.
+
+        Raises:
+            RuntimeError: If the variable is not found.
+        """
+        ...
+
+    def set_problem_name(self, name: str) -> None:
+        """Set the problem name.
+
+        Args:
+            name: New name for the problem.
+        """
+        ...
+
+    def set_sense(self, sense: str) -> None:
+        """Set the optimization sense.
+
+        Args:
+            sense: 'maximize', 'max', 'minimize', or 'min'.
+
+        Raises:
+            RuntimeError: If the sense value is invalid.
+        """
+        ...

{parse_lp-2.6.1 → parse_lp-2.6.2}/pyproject.toml

@@ -1,5 +1,6 @@
 [project]
 name = "parse_lp"
+readme = "README.md"
 description = "A LP file format parser for Python, powered by Rust"
 license = { file = "LICENSE-APACHE" }
 requires-python = ">=3.9"
@@ -16,6 +17,8 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 dynamic = ["version"]
 

{parse_lp-2.6.1 → parse_lp-2.6.2}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "parse_lp"
-version = "2.6.1"
+version = "2.6.2"
 edition = "2021"
 authors = ["Dan Dixey", "Dan Dixey <dan@functorml.co.uk>"]
 rust-version = "1.74.0"