fuzzy-dl-owl2 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

fuzzy_dl_owl2/fuzzydl/query/instance_query.py

@@ -10,7 +10,12 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class InstanceQuery(Query, ABC):
+    """
+    Instance checking query
+    """
+
     def __init__(self, concept: Concept, individual: Individual) -> None:
+        super().__init__()
         if concept.is_concrete():
             Util.error(f"Error: {concept} cannot be a concrete concept.")
 

fuzzy_dl_owl2/fuzzydl/query/kb_satisfiable_query.py

@@ -9,15 +9,25 @@ from fuzzy_dl_owl2.fuzzydl.query.query import Query
 
 
 class KbSatisfiableQuery(Query):
+    """
+    Knowledge base satisfiability degree
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
 
     def preprocess(self, kb: KnowledgeBase) -> None:
         pass
 
     def solve(self, kb: KnowledgeBase) -> Solution:
         try:
-            return Solution(1.0) if self.is_consistent_kb(kb) else Solution(False)
+            return (
+                Solution(1.0)
+                if self.is_consistent_kb(kb)
+                else Solution(Solution.INCONSISTENT_KB)
+            )
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def is_consistent_kb(self, kb: KnowledgeBase) -> bool:
         kb.solve_abox()

fuzzy_dl_owl2/fuzzydl/query/max/max_instance_query.py

@@ -15,6 +15,10 @@ from fuzzy_dl_owl2.fuzzydl.query.instance_query import InstanceQuery
 
 
 class MaxInstanceQuery(InstanceQuery):
+    """
+    Lowest upper bound of a concept assertion
+    """
+
     def __init__(self, concept: Concept, individual: Individual) -> None:
         super().__init__(concept, individual)
 
@@ -26,6 +30,7 @@ class MaxInstanceQuery(InstanceQuery):
         if "(all " in str(self.conc) or "(not (b-some " in str(self.conc):
             kb.set_dynamic_blocking()
 
+        # a: c >= q
         kb.add_assertion(self.ind, self.conc, DegreeVariable.get_degree(q))
         kb.solve_assertions()
 
@@ -39,7 +44,7 @@ class MaxInstanceQuery(InstanceQuery):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"Is {self.ind} instance of {self.conc} ? <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_query.py

@@ -10,7 +10,13 @@ from fuzzy_dl_owl2.fuzzydl.query.query import Query
 
 
 class MaxQuery(Query):
+    """
+    Maximize expression query
+    """
+
     def __init__(self, expr: Expression) -> None:
+        super().__init__()
+        # Expression to be maximized
         self.obj_expr: Expression = Expression.negate_expression(expr)
 
     def preprocess(self, kb: KnowledgeBase) -> None:
@@ -25,7 +31,7 @@ class MaxQuery(Query):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"{self.obj_expr} <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_related_query.py

@@ -16,12 +16,17 @@ from fuzzy_dl_owl2.fuzzydl.query.related_query import RelatedQuery
 
 
 class MaxRelatedQuery(RelatedQuery):
+    """
+    Lowest upper bound of a role assertion (ind1, ind2, role)
+    """
+
     def __init__(self, a: Individual, b: Individual, role_name: str) -> None:
         self.ind1: Individual = a
         self.ind2: Individual = b
         self.role: str = role_name
 
     def preprocess(self, kb: KnowledgeBase) -> None:
+        # glb(ind1 : b-some R ind2)
         conc: Concept = HasValueConcept(self.role, self.ind2)
         q: Variable = kb.milp.get_variable(self.ind1, conc)
         kb.add_assertion(self.ind1, conc, DegreeVariable.get_degree(q))
@@ -39,7 +44,7 @@ class MaxRelatedQuery(RelatedQuery):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"Is {self.ind1} related to {self.ind2} through {self.role} ? <= "

fuzzy_dl_owl2/fuzzydl/query/max/max_satisfiable_query.py

@@ -18,6 +18,9 @@ from fuzzy_dl_owl2.fuzzydl.util.config_reader import ConfigReader
 
 
 class MaxSatisfiableQuery(SatisfiableQuery):
+    """
+    Maximal satisfiability degree of a fuzzy concept.
+    """
 
     @typing.overload
     def __init__(self, c: Concept) -> None: ...
@@ -35,9 +38,20 @@ class MaxSatisfiableQuery(SatisfiableQuery):
             self.__max_sat_query_init_2(*args)
 
     def __max_sat_query_init_1(self, c: Concept) -> None:
+        """Constructor for a general satisfiability query
+
+        Args:
+            c (Concept): A fuzzy concept for which the satisfiability is to be tested.
+        """
         super().__init__(c)
 
     def __max_sat_query_init_2(self, c: Concept, a: Individual) -> None:
+        """Constructor for a satisfiability query involving a specific individual
+
+        Args:
+            c (Concept): A fuzzy concept for which the satisfiability is to be tested.
+            a (Individual): An individual used in the satisfiability test.
+        """
         super().__init__(c, a)
 
     def preprocess(self, kb: KnowledgeBase) -> None:
@@ -65,7 +79,7 @@ class MaxSatisfiableQuery(SatisfiableQuery):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         if self.ind is not None:

fuzzy_dl_owl2/fuzzydl/query/max/max_subsumes_query.py

@@ -22,6 +22,9 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType
 
 
 class MaxSubsumesQuery(SubsumptionQuery):
+    """
+    Maximize subsumption query.
+    """
 
     def __init__(self, c1: Concept, c2: Concept, type_: LogicOperatorType) -> None:
         super().__init__(c1, c2, type_)
@@ -58,7 +61,7 @@ class MaxSubsumesQuery(SubsumptionQuery):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"{self.c1} subsumes {self.c2} ? <= "

fuzzy_dl_owl2/fuzzydl/query/min/min_instance_query.py

@@ -16,6 +16,10 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
 
 
 class MinInstanceQuery(InstanceQuery):
+    """
+    Greatest lower bound of a concept assertion.
+    """
+
     def __init__(self, concept: Concept, individual: Individual) -> None:
         super().__init__(concept, individual)
 
@@ -27,6 +31,7 @@ class MinInstanceQuery(InstanceQuery):
         if "(some " in str(self.conc) or "(b-some " in str(self.conc):
             kb.set_dynamic_blocking()
 
+        # a: not c >= 1-q
         kb.add_assertion(
             self.ind,
             -self.conc,
@@ -44,7 +49,7 @@ class MinInstanceQuery(InstanceQuery):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"Is {self.ind} instance of {self.conc} ? >= "

fuzzy_dl_owl2/fuzzydl/query/min/min_query.py

@@ -10,7 +10,13 @@ from fuzzy_dl_owl2.fuzzydl.query.query import Query
 
 
 class MinQuery(Query):
+    """
+    Minimize expression query.
+    """
+
     def __init__(self, expr: Expression) -> None:
+        super().__init__()
+        # Expression to be minimized.
         self.obj_expr = expr
 
     def preprocess(self, kb: KnowledgeBase) -> None:
@@ -25,7 +31,7 @@ class MinQuery(Query):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"{self.obj_expr} ? >= "

fuzzy_dl_owl2/fuzzydl/query/min/min_related_query.py

@@ -17,6 +17,9 @@ from fuzzy_dl_owl2.fuzzydl.query.related_query import RelatedQuery
 
 
 class MinRelatedQuery(RelatedQuery):
+    """
+    Greatest lower bound of a role assertion (ind1, ind2, role).
+    """
 
     def __init__(self, a: Individual, b: Individual, role_name: str) -> None:
         self.ind1: Individual = a
@@ -33,6 +36,7 @@ class MinRelatedQuery(RelatedQuery):
         if "(some " in str(conc) or "(b-some " in str(conc):
             kb.set_dynamic_blocking()
 
+        # a: not c >= 1-q
         kb.add_assertion(
             self.ind1,
             -conc,
@@ -51,7 +55,7 @@ class MinRelatedQuery(RelatedQuery):
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"Is {self.ind1} related to {self.ind2} through {self.role} ? >= "

fuzzy_dl_owl2/fuzzydl/query/min/min_satisfiable_query.py

@@ -19,6 +19,9 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import VariableType
 
 
 class MinSatisfiableQuery(SatisfiableQuery):
+    """
+    Minimal satisfiability degree of a fuzzy concept.
+    """
 
     @typing.overload
     def __init__(self, c: Concept) -> None: ...
@@ -36,9 +39,22 @@ class MinSatisfiableQuery(SatisfiableQuery):
             self.__min_sat_query_init_2(*args)
 
     def __min_sat_query_init_1(self, c: Concept) -> None:
+        """
+        Constructor for a general satisfiability query.
+
+        Args:
+            c (Concept): A fuzzy concept for which the satisfiability is to be tested.
+        """
         super().__init__(c)
 
     def __min_sat_query_init_2(self, c: Concept, a: Individual) -> None:
+        """
+        Constructor for a satisfiability query involving a specific individual.
+
+        Args:
+            c (Concept): A fuzzy concept for which the satisfiability is to be tested.
+            a (Individual): An individual used in the satisfiability test.
+        """
         super().__init__(c, a)
 
     def preprocess(self, kb: KnowledgeBase) -> None:
@@ -72,7 +88,7 @@ class MinSatisfiableQuery(SatisfiableQuery):
             return sol
 
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         if self.ind is not None:

fuzzy_dl_owl2/fuzzydl/query/min/min_subsumes_query.py

@@ -1,5 +1,8 @@
 from __future__ import annotations
 
+import typing
+
+from fuzzy_dl_owl2.fuzzydl.classification_node import ClassificationNode
 from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 from fuzzy_dl_owl2.fuzzydl.concept.implies_concept import ImpliesConcept
 from fuzzy_dl_owl2.fuzzydl.concept.operator_concept import OperatorConcept
@@ -19,11 +22,17 @@ from fuzzy_dl_owl2.fuzzydl.util.constants import LogicOperatorType, VariableType
 
 
 class MinSubsumesQuery(SubsumptionQuery):
+    """
+    Minimize subsumption query.
+    """
 
     def __init__(self, c1: Concept, c2: Concept, type_: LogicOperatorType) -> None:
         super().__init__(c1, c2, type_)
 
     def preprocess(self, kb: KnowledgeBase) -> None:
+        if kb.is_classified():
+            return
+
         ind: Individual = kb.get_new_individual()
 
         if self.type == LogicOperatorType.LUKASIEWICZ:
@@ -39,6 +48,7 @@ class MinSubsumesQuery(SubsumptionQuery):
         kb.old_01_variables += 1
         self.obj_expr: Expression = Expression(Term(1.0, q))
 
+        # a: not c or d >= 1-q
         kb.add_assertion(
             ind,
             -conc,
@@ -46,20 +56,50 @@ class MinSubsumesQuery(SubsumptionQuery):
         )
         kb.solve_assertions()
 
+    # def solve(self, kb: KnowledgeBase) -> Solution:
+    #     try:
+    #         self.set_initial_time()
+    #         if ConfigReader.OPTIMIZATIONS == 0 or kb.has_nominals_in_tbox():
+    #             cloned: KnowledgeBase = kb.clone()
+    #             cloned.solve_abox()
+    #         else:
+    #             cloned: KnowledgeBase = kb.clone_without_abox()
+    #         self.preprocess(cloned)
+    #         sol: Solution = cloned.optimize(self.obj_expr)
+    #         self.set_total_time()
+    #         return sol
+    #     except InconsistentOntologyException:
+    #         return Solution(Solution.INCONSISTENT_KB)
+
     def solve(self, kb: KnowledgeBase) -> Solution:
         try:
             self.set_initial_time()
-            if ConfigReader.OPTIMIZATIONS == 0 or kb.has_nominals_in_tbox():
-                cloned: KnowledgeBase = kb.clone()
-                cloned.solve_abox()
+            if kb.is_classified() and self.c1.is_atomic() and self.c2.is_atomic():
+                n1: typing.Optional[ClassificationNode] = kb.get_classification_node(
+                    str(self.c1)
+                )
+                n2: typing.Optional[ClassificationNode] = kb.get_classification_node(
+                    str(self.c2)
+                )
+                if n1 is not None and n1.is_thing():
+                    sol: Solution = Solution(1.0)
+                elif n2 is not None and n1.is_thing():
+                    sol: Solution = Solution(1.0)
+                else:
+                    sol: Solution = Solution(kb.get_subsumption_flags(n1, n2))
             else:
-                cloned: KnowledgeBase = kb.clone_without_abox()
-            self.preprocess(cloned)
-            sol: Solution = cloned.optimize(self.obj_expr)
+                if ConfigReader.OPTIMIZATIONS == 0 or kb.has_nominals_in_tbox():
+                    cloned: KnowledgeBase = kb.clone()
+                    cloned.solve_abox()
+                else:
+                    cloned: KnowledgeBase = kb.clone_without_abox()
+                self.preprocess(cloned)
+                sol: Solution = cloned.optimize(self.obj_expr)
+
             self.set_total_time()
             return sol
         except InconsistentOntologyException:
-            return Solution(False)
+            return Solution(Solution.INCONSISTENT_KB)
 
     def __str__(self) -> str:
         return f"{self.c1} subsumes {self.c2} ? >= "

fuzzy_dl_owl2/fuzzydl/query/query.py

@@ -8,6 +8,7 @@ from fuzzy_dl_owl2.fuzzydl.milp.solution import Solution
 
 
 class Query(ABC):
+
     def __init__(self) -> None:
         self.initial_time: int = 0
         self.total_time: int = 0
@@ -24,7 +25,9 @@ class Query(ABC):
 
     @abstractmethod
     def preprocess(self, knowledge_base: KnowledgeBase) -> None:
-        """Preprocess the query with given knowledge base"""
+        """
+        Performs some preprocessing steps of the query over a fuzzy KB.
+        """
         pass
 
     @abstractmethod
@@ -34,5 +37,5 @@ class Query(ABC):
 
     @abstractmethod
     def __str__(self) -> str:
-        """String representation of the query"""
+        """Solves the query over a fuzzy KB"""
         pass

fuzzy_dl_owl2/fuzzydl/query/related_query.py

@@ -1,15 +1,22 @@
 from __future__ import annotations
 
+from abc import ABC
+
 from fuzzy_dl_owl2.fuzzydl.individual.individual import Individual
 from fuzzy_dl_owl2.fuzzydl.milp.expression import Expression
 from fuzzy_dl_owl2.fuzzydl.query.query import Query
 
 
-class RelatedQuery(Query):
+class RelatedQuery(Query, ABC):
+    """Entailment of a role assertion query"""
 
     def __init__(self) -> None:
         super().__init__()
+        # Abstract role
         self.role: str = None
+        # Subject of the relation.
         self.ind1: Individual = None
+        # Object of the relation.
         self.ind2: Individual = None
+        # Objective expression
         self.obj_expr: Expression = None

fuzzy_dl_owl2/fuzzydl/query/satisfiable_query.py

@@ -10,6 +10,7 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 
 
 class SatisfiableQuery(Query):
+    """Fuzzy concept satisfiability query."""
 
     @typing.overload
     def __init__(self, c: Concept, a: Individual) -> None: ...
@@ -18,6 +19,7 @@ class SatisfiableQuery(Query):
     def __init__(self, c: Concept) -> None: ...
 
     def __init__(self, *args) -> None:
+        super().__init__()
         assert len(args) in [1, 2]
         assert isinstance(args[0], Concept)
         if len(args) == 1:
@@ -27,11 +29,26 @@ class SatisfiableQuery(Query):
             self.__satisfiable_query_init_1(*args)
 
     def __satisfiable_query_init_1(self, c: Concept, a: Individual) -> None:
+        """Constructor for a satisfiability query involving a specific individual.
+
+        Args:
+            c (Concept): A fuzzy concept for which the satisfiability is to be tested.
+            a (Individual): An individual used in the satisfiability test.
+        """
         if c.is_concrete():
             Util.error(f"Error: {c} cannot be a concrete concept.")
+        # Fuzzy concept
         self.conc: Concept = c
+        # Optional individual used during the satisfiability test.
         self.ind: Individual = a
+        # Objective expression
         self.obj_expr: Expression = None
 
     def __satisfiable_query_init_2(self, c: Concept) -> None:
+        """
+        Constructor for a general satisfiability query.
+
+        Args:
+            c (Concept): A fuzzy concept for which the satisfiability is to be tested.
+        """
         self.__init__(c, None)

fuzzy_dl_owl2/fuzzydl/query/subsumption_query.py

@@ -10,11 +10,16 @@ from fuzzy_dl_owl2.fuzzydl.util.util import Util
 class SubsumptionQuery(Query):
 
     def __init__(self, c1: Concept, c2: Concept, s_type: LogicOperatorType) -> None:
+        super().__init__()
         if c1.is_concrete():
             Util.error(f"Error: {c1} cannot be a concrete concept.")
         if c2.is_concrete():
             Util.error(f"Error: {c1} cannot be a concrete concept.")
+        # Subsumed concept
         self.c1: Concept = c1
+        # Subsumer concept
         self.c2: Concept = c2
+        # Fuzzy implication used
         self.type: LogicOperatorType = s_type
+        # Objective epxression
         self.obj_expr: Expression = None

fuzzy_dl_owl2/fuzzydl/range_axiom.py

@@ -2,6 +2,10 @@ from fuzzy_dl_owl2.fuzzydl.concept.concept import Concept
 
 
 class RangeAxiom:
+    """
+    Role range axiom
+    """
+
     def __init__(self, role: str, concept: Concept) -> None:
         self.role: str = role
         self.concept: Concept = concept

fuzzy_dl_owl2/fuzzydl/relation.py

@@ -8,6 +8,10 @@ if typing.TYPE_CHECKING:
 
 
 class Relation:
+    """
+    Represents a role assertion of the form (object individual, role, lower bound for the degree) with respect to a subject individual.
+    """
+
     def __init__(
         self, role_name: str, ind1: Individual, ind2: Individual, degree: Degree
     ):
@@ -38,6 +42,7 @@ class Relation:
         return self.degree
 
     def get_name_without_degree(self) -> str:
+        """Gets a printable name of the role assertion without the lower bound"""
         return f"({self.ind_a}, {self.ind_b}): {self.role_name}"
 
     def __repr__(self) -> str:

fuzzy_dl_owl2/fuzzydl/restriction/has_value_restriction.py

@@ -5,6 +5,8 @@ from fuzzy_dl_owl2.fuzzydl.restriction.restriction import Restriction
 
 
 class HasValueRestriction(Restriction):
+    """Universal restriction formed by a role, a individual and a lower bound degree."""
+
     def __init__(self, role_name: str, individual: str, degree: Degree) -> None:
         super().__init__(role_name, None, degree)
         self.ind_name: str = individual

fuzzy_dl_owl2/fuzzydl/restriction/restriction.py

@@ -7,6 +7,8 @@ from fuzzy_dl_owl2.fuzzydl.degree.degree import Degree
 
 
 class Restriction:
+    """Universal restriction formed by a role, a concept and a lower bound degree."""
+
     def __init__(self, role_name: str, concept: Concept, degree: Degree) -> None:
         self.role_name: str = role_name
         self.concept: Concept = concept
@@ -25,6 +27,7 @@ class Restriction:
         return self.concept
 
     def get_name_without_degree(self) -> str:
+        """Gets the name of the restriction without the degree."""
         return f"(all {self.role_name} {self.concept})"
 
     def __repr__(self) -> str:

fuzzy_dl_owl2/fuzzydl/role_parent_with_degree.py

@@ -1,7 +1,12 @@
 class RoleParentWithDegree:
+    """
+    Pair of elements (role, degree in [0,1]).
+    Given a role, represents a role parent and the inclusion degree.
+    """
+
     def __init__(self, parent: str, degree: float) -> None:
-        self.degree: float = degree
         self.parent: str = parent
+        self.degree: float = degree
 
     def get_degree(self) -> float:
         return self.degree

fuzzy_dl_owl2/fuzzydl/util/config_reader.py

@@ -1,42 +1,32 @@
 from __future__ import annotations
 
 import configparser
-import enum
 import math
 
 from fuzzy_dl_owl2.fuzzydl.util import constants
 
 
-class MILPProvider(enum.StrEnum):
-    GUROBI = enum.auto()
-    MIP = enum.auto()
-    # SCIPY = enum.auto()
-    PULP = enum.auto()
-    PULP_GLPK = enum.auto()
-    PULP_HIGHS = enum.auto()
-    PULP_CPLEX = enum.auto()
-
-    @staticmethod
-    def from_str(value: str) -> MILPProvider:
-        try:
-            return MILPProvider(value.lower())
-        except ValueError:
-            raise ValueError(
-                f"Invalid MILP provider: {value}. Valid options are: {list(MILPProvider)}"
-            )
-
-
 class ConfigReader:
+    # Anywhere pairwise blocking applied. false disables anywhere double blocking; true enables anywher edouble blocking.
     ANYWHERE_DOUBLE_BLOCKING: bool = True
+    # Anywhere simple blocking applied. false disables anywhere simple blocking; true enables anywhere simple blocking.
     ANYWHERE_SIMPLE_BLOCKING: bool = True
+    # Debugging mode
     DEBUG_PRINT: bool = True
+    # Precision of the reasoner
     EPSILON: float = 0.001
+    # Maximum number of new individuals that will be created
     MAX_INDIVIDUALS: int = -1
+    # Number of digits of precision
     NUMBER_DIGITS: int = 2
+    # Level of the optimizations applied. 0 disables optimizations; a positive value enables optimizations.
     OPTIMIZATIONS: int = 1
+    # Rule acyclic TBox optimization applied
     RULE_ACYCLIC_TBOXES: bool = True
+    # XML OWL 2 annotation label used to create and parse Fuzzy OWL 2 ontologies
     OWL_ANNOTATION_LABEL: str = "fuzzyLabel"
-    MILP_PROVIDER: MILPProvider = MILPProvider.GUROBI
+    # MILP Solver provider used by the reasoner
+    MILP_PROVIDER: constants.MILPProvider = constants.MILPProvider.GUROBI
 
     @staticmethod
     def load_parameters(config_file: str, args: list[str]) -> None:
@@ -62,22 +52,22 @@ class ConfigReader:
             ConfigReader.OWL_ANNOTATION_LABEL = config.get(
                 "DEFAULT", "owlAnnotationLabel"
             )
-            ConfigReader.MILP_PROVIDER = MILPProvider(
+            ConfigReader.MILP_PROVIDER = constants.MILPProvider(
                 config.get("DEFAULT", "milpProvider").lower()
             )
             ConfigReader.NUMBER_DIGITS = int(
                 round(abs(math.log10(ConfigReader.EPSILON) - 1.0))
             )
             if ConfigReader.MILP_PROVIDER in [
-                MILPProvider.MIP,
-                MILPProvider.PULP,
+                constants.MILPProvider.MIP,
+                constants.MILPProvider.PULP,
             ]:
                 constants.MAXVAL = (1 << 31) - 1
                 constants.MAXVAL2 = constants.MAXVAL * 2
             elif ConfigReader.MILP_PROVIDER in [
-                MILPProvider.PULP_GLPK,
-                MILPProvider.PULP_HIGHS,
-                MILPProvider.PULP_CPLEX,
+                constants.MILPProvider.PULP_GLPK,
+                constants.MILPProvider.PULP_HIGHS,
+                constants.MILPProvider.PULP_CPLEX,
                 # MILPProvider.SCIPY,
             ]:
                 constants.MAXVAL = (1 << 28) - 1