parse-lp 2.4.3__tar.gz → 2.5.0__tar.gz

{parse_lp-2.4.3 → parse_lp-2.5.0}/Cargo.lock

@@ -432,7 +432,7 @@ checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
 
 [[package]]
 name = "parse_lp"
-version = "2.4.3"
+version = "2.5.0"
 dependencies = [
  "lp_parser_rs",
  "pyo3",

parse_lp-2.5.0/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: parse_lp
+Version: 2.5.0
+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
+License-File: LICENSE-APACHE
+Summary: A LP file format parser for Python, powered by Rust
+Keywords: linear-programming,optimization,parser,integer-programming,math
+Author: Dan Dixey, Dan Dixey <dan@functorml.co.uk>
+Author-email: Dan Dixey, Dan Dixey <dan@functorml.co.uk>
+License: MIT OR Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Source Code, https://github.com/dandxy89/lp_parser_rs
+
+# parse_lp
+
+A LP file format parser for Python, powered by Rust.
+
+## Features
+
+- **Complete LP Support**: Handles all standard LP file format features
+- **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()}")
+
+# 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 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"]
+    }
+]
+```
+
+## 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>
+

parse_lp-2.5.0/README.md

@@ -0,0 +1,194 @@
+# parse_lp
+
+A LP file format parser for Python, powered by Rust.
+
+## Features
+
+- **Complete LP Support**: Handles all standard LP file format features
+- **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()}")
+
+# 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 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"]
+    }
+]
+```
+
+## 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>

parse_lp-2.5.0/parse_lp/__init__.py

@@ -0,0 +1,39 @@
+"""parse_lp - A fast LP file format parser for Python, powered by Rust.
+
+This package provides a high-performance parser for Linear Programming (LP) files,
+leveraging Rust for speed and Python for ease of use.
+
+Key Features:
+- Fast parsing of LP files of various formats
+- Export parsed data to CSV files
+- Access to problem components (variables, constraints, objectives)
+- Compare two LP problems to find differences
+- Type hints for better IDE support
+
+Example Usage:
+    >>> from parse_lp import LpParser
+    >>>
+    >>> # Parse an LP file
+    >>> parser = LpParser("optimization_problem.lp")
+    >>> parser.parse()
+    >>>
+    >>> # Access problem information
+    >>> print(f"Problem name: {parser.name}")
+    >>> print(f"Variables: {parser.variable_count()}")
+    >>> print(f"Constraints: {parser.constraint_count()}")
+    >>>
+    >>> # Export to CSV files
+    >>> parser.to_csv("output/")
+    >>>
+    >>> # Compare two problems
+    >>> parser2 = LpParser("modified_problem.lp")
+    >>> parser2.parse()
+    >>> diff = parser.compare(parser2)
+    >>> print(f"Added variables: {diff['added_variables']}")
+
+"""
+
+from .parse_lp import LpParser
+
+__version__ = "2.4.2"
+__all__ = ["LpParser"]

parse_lp-2.5.0/parse_lp/parse_lp.pyi

@@ -0,0 +1,179 @@
+"""Type stubs for parse_lp module."""
+
+from typing import Any, Dict, List, Optional
+
+class LpParser:
+    """A fast LP file format parser.
+
+    This class provides functionality to parse Linear Programming (LP) files
+    and access the parsed data or export it to CSV format.
+
+    Attributes:
+        lp_file: Path to the LP file being parsed.
+        name: Name of the LP problem (after parsing).
+        sense: Optimization sense ('maximize' or 'minimize').
+        objectives: List of objective functions with coefficients.
+        constraints: List of constraints with their properties.
+        variables: Dictionary of variables with their properties.
+
+    Example:
+        >>> from parse_lp import LpParser
+        >>> parser = LpParser("path/to/problem.lp")
+        >>> parser.parse()  # Parse the file
+        >>> print(f"Problem: {parser.name}")
+        >>> print(f"Variables: {parser.variable_count()}")
+        >>> parser.to_csv("output/directory/")
+    """
+
+    def __init__(self, lp_file: str) -> None:
+        """Initialize the LP parser with a file path.
+
+        Args:
+            lp_file: Path to the LP file to parse.
+
+        Raises:
+            FileExistsError: If the specified file does not exist.
+        """
+        ...
+
+    @property
+    def lp_file(self) -> str:
+        """Get the path to the LP file.
+
+        Returns:
+            The path to the LP file being parsed.
+        """
+        ...
+
+    @property
+    def name(self) -> Optional[str]:
+        """Get the name of the LP problem.
+
+        Returns:
+            The problem name if available and parsed, None otherwise.
+        """
+        ...
+
+    @property
+    def sense(self) -> Optional[str]:
+        """Get the optimization sense of the problem.
+
+        Returns:
+            'maximize' or 'minimize' if parsed, None otherwise.
+        """
+        ...
+
+    @property
+    def objectives(self) -> List[Dict[str, Any]]:
+        """Get the list of objective functions.
+
+        Returns:
+            List of dictionaries containing objective information:
+            - name: Name of the objective
+            - coefficients: List of coefficient dictionaries with 'name' and 'value'
+        """
+        ...
+
+    @property
+    def constraints(self) -> List[Dict[str, Any]]:
+        """Get the list of constraints.
+
+        Returns:
+            List of dictionaries containing constraint information:
+            - name: Name of the constraint
+            - type: 'standard' or 'sos'
+            - For standard constraints: coefficients, sense, rhs
+            - For SOS constraints: sos_type, variables
+        """
+        ...
+
+    @property
+    def variables(self) -> Dict[str, Dict[str, Any]]:
+        """Get the dictionary of variables.
+
+        Returns:
+            Dictionary mapping variable names to their properties:
+            - name: Variable name
+            - var_type: Type of variable (e.g., 'Continuous', 'Binary', 'Integer')
+            - bounds: Optional dictionary with 'lower' and/or 'upper' bounds
+        """
+        ...
+
+    def parse(self) -> None:
+        """Parse the LP file.
+
+        This method reads and parses the LP file, storing the problem
+        data internally for later access.
+
+        Raises:
+            RuntimeError: If the LP file cannot be read or parsed.
+        """
+        ...
+
+    def to_csv(self, base_directory: str) -> None:
+        """Export the parsed LP problem to CSV files.
+
+        This method parses the LP file (if not already parsed) and exports
+        the problem data (variables, constraints, and objectives) to separate
+        CSV files in the specified directory.
+
+        Args:
+            base_directory: Path to the directory where CSV files will be saved.
+                           The directory must exist.
+
+        Raises:
+            NotADirectoryError: If base_directory is not a valid directory.
+            RuntimeError: If the LP file cannot be read or parsed, or if
+                         CSV files cannot be written.
+        """
+        ...
+
+    def variable_count(self) -> int:
+        """Get the number of variables in the problem.
+
+        Returns:
+            Number of variables, or 0 if not parsed.
+        """
+        ...
+
+    def constraint_count(self) -> int:
+        """Get the number of constraints in the problem.
+
+        Returns:
+            Number of constraints, or 0 if not parsed.
+        """
+        ...
+
+    def objective_count(self) -> int:
+        """Get the number of objective functions in the problem.
+
+        Returns:
+            Number of objectives, or 0 if not parsed.
+        """
+        ...
+
+    def compare(self, other: "LpParser") -> Dict[str, Any]:
+        """Compare this LP problem with another.
+
+        Both parsers must be parsed before comparison.
+
+        Args:
+            other: Another LpParser instance to compare with.
+
+        Returns:
+            Dictionary containing comparison results:
+            - name_changed: Whether problem names differ
+            - sense_changed: Whether optimization senses differ
+            - variable_count_diff: Difference in variable counts
+            - constraint_count_diff: Difference in constraint counts
+            - objective_count_diff: Difference in objective counts
+            - added_variables: Variables in 'other' but not in 'self'
+            - removed_variables: Variables in 'self' but not in 'other'
+            - modified_variables: Variables that exist in both but differ
+            - added_constraints: Constraints in 'other' but not in 'self'
+            - removed_constraints: Constraints in 'self' but not in 'other'
+
+        Raises:
+            RuntimeError: If either parser hasn't been parsed yet.
+        """
+        ...

{parse_lp-2.4.3 → parse_lp-2.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "parse_lp"
-description = "A fast LP file format parser for Python, powered by Rust"
+description = "A LP file format parser for Python, powered by Rust"
 license = { file = "LICENSE-APACHE" }
 requires-python = ">=3.9"
 keywords = [
@@ -29,10 +29,10 @@ manifest-path = "python/Cargo.toml"
 
 [dependency-groups]
 dev = [
-    "mypy>=1.14.1",
-    "pip>=25.0",
-    "pytest>=8.3.4",
-    "ruff>=0.9.3",
+    "mypy>=1.17.0",
+    "pip>=25.1.1",
+    "pytest>=8.4.1",
+    "ruff>=0.12.5",
     "wheel>=0.45.1",
 ]
 
@@ -43,6 +43,13 @@ ignore = ["E501"]
 [tool.ruff.lint.isort]
 known-first-party = ["parse_lp"]
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"
+python_classes = "Test*"
+python_functions = "test_*"
+addopts = "-v --color=yes"
+
 [tool.coverage.run]
 branch = true
 source = ["parse_lp"]

{parse_lp-2.4.3 → parse_lp-2.5.0}/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "parse_lp"
-version = "2.4.3"
+version = "2.5.0"
 edition = "2021"
 authors = ["Dan Dixey", "Dan Dixey <dan@functorml.co.uk>"]
 rust-version = "1.70.0"
@@ -21,7 +21,7 @@ name = "parse_lp"
 crate-type = ["cdylib"]
 
 [dependencies]
-lp_parser_rs = { path = "../rust", features = ["csv"] }
+lp_parser_rs = { path = "../rust", features = ["csv", "diff", "serde"] }
 pyo3 = { version = "0.25.1", features = [
     "extension-module",
     "abi3",

{parse_lp-2.4.3 → parse_lp-2.5.0}/python/MANIFEST.in

@@ -2,5 +2,6 @@ include LICENSE-APACHE
 include Cargo.toml
 include pyproject.toml
 recursive-include src *
-recursive-include parse_lp *.py
-exclude ../README.md
+recursive-include parse_lp *.py *.pyi
+include parse_lp/py.typed
+exclude ../README.md