From b39de24bd64201ddfa02cbf86634679535a42808 Mon Sep 17 00:00:00 2001 From: Kevin Phoenix Date: Thu, 20 Jun 2024 00:22:23 -0700 Subject: [PATCH] Revert "Add E lints" This reverts commit 68903335a889ce3087b0a49cb4d72bc47a38c8af. --- claripy/ast/base.py | 18 +++++++++--------- claripy/ast/bool.py | 9 +++++++-- claripy/ast/bv.py | 14 +++++++++----- claripy/ast/fp.py | 13 ++++++++++--- claripy/backends/backend_vsa.py | 14 ++++++++++++++ claripy/backends/backend_z3.py | 11 +++++++++++ claripy/backends/backend_z3_parallel.py | 5 ++++- claripy/frontend.py | 4 ++-- .../constraint_expansion_mixin.py | 2 ++ .../smtlib_script_dumper_mixin.py | 10 ++++++++++ claripy/frontends/composite_frontend.py | 3 +++ claripy/frontends/constrained_frontend.py | 1 + claripy/frontends/hybrid_frontend.py | 3 ++- claripy/frontends/light_frontend.py | 1 + claripy/frontends/replacement_frontend.py | 1 + claripy/operations.py | 5 +++++ claripy/simplifications.py | 6 +++++- claripy/vsa/strided_interval.py | 12 ++++++++++-- claripy/vsa/valueset.py | 6 +++++- tests/test_concrete.py | 5 +++-- tests/test_vsa.py | 12 ++++++------ 21 files changed, 120 insertions(+), 35 deletions(-) diff --git a/claripy/ast/base.py b/claripy/ast/base.py index a6536013b..b99e20a22 100644 --- a/claripy/ast/base.py +++ b/claripy/ast/base.py @@ -16,7 +16,7 @@ from claripy.annotation import Annotation try: - import _pickle as pickle + import cPickle as pickle except ImportError: import pickle @@ -383,7 +383,7 @@ def _arg_serialize(arg) -> Optional[bytes]: return b"\x1f" elif arg is False: return b"\x2e" - elif isinstance(arg, int): + elif type(arg) is int: if arg < 0: if arg >= -0x7FFF: return b"-" + struct.pack(" Optional[bytes]: elif arg <= 0xFFFF_FFFF_FFFF_FFFF: return struct.pack(" Bool: # Bound operations # +from .. import operations Bool.__eq__ = operations.op("__eq__", (Bool, Bool), Bool) Bool.__ne__ = operations.op("__ne__", (Bool, Bool), Bool) @@ -271,4 +273,7 @@ def constraint_to_si(expr): return satisfiable, replace_list -from .bv import BVS # noqa: E402 +from ..backend_manager import backends +from ..errors import ClaripyOperationError, ClaripyTypeError, BackendError +from .bits import Bits +from .bv import BVS diff --git a/claripy/ast/bv.py b/claripy/ast/bv.py index 6e1acbca6..cd53d5e12 100644 --- a/claripy/ast/bv.py +++ b/claripy/ast/bv.py @@ -240,7 +240,7 @@ def BVS( if stride == 0 and max != min: raise ClaripyValueError("BVSes of stride 0 should have max == min") - if isinstance(name, bytes): + if type(name) is bytes: name = name.decode() if not isinstance(name, str): raise TypeError(f"Name value for BVS must be a str, got {type(name)!r}") @@ -276,20 +276,20 @@ def BVV(value, size=None, **kwargs) -> BV: """ if type(value) in (bytes, bytearray, memoryview, str): - if isinstance(value, str): + if type(value) is str: l.warning("BVV value is a unicode string, encoding as utf-8") value = value.encode("utf-8") if size is None: size = len(value) * 8 - elif not isinstance(size, int): + elif type(size) is not int: raise TypeError("Bitvector size must be either absent (implicit) or an integer") elif size != len(value) * 8: raise ClaripyValueError("string/size mismatch for BVV creation") value = int.from_bytes(value, "big") - elif size is None or (not isinstance(value, int) and value is not None): + elif size is None or (type(value) is not int and value is not None): raise TypeError("BVV() takes either an integer value and a size or a string of bytes") # ensure the 0 <= value < (1 << size) @@ -411,6 +411,8 @@ def DSIS( # Unbound operations # +from .bool import Bool +from .. import operations # comparisons ULT = operations.op("__lt__", (BV, BV), Bool, extra_check=operations.length_same_check, bound=False) @@ -623,4 +625,6 @@ def DSIS( "intersection", (BV, BV), BV, extra_check=operations.length_same_check, calc_length=operations.basic_length_calc ) -from . import fp # noqa: E402 +from . import fp +from .. import vsa +from ..errors import ClaripyValueError diff --git a/claripy/ast/fp.py b/claripy/ast/fp.py index a38519f70..7e4fd51c9 100644 --- a/claripy/ast/fp.py +++ b/claripy/ast/fp.py @@ -102,12 +102,14 @@ def FPV(value, sort): :param sort: The sort of the floating point. :return: An FP AST. """ - if isinstance(value, int): + if type(value) is int: value = float(value) - elif not isinstance(value, float): + elif type(value) is float: + pass + else: raise TypeError("Must instanciate FPV with a numerical value") - if not isinstance(sort, fp.FSort): + if type(sort) is not fp.FSort: raise TypeError("Must instanciate FPV with a FSort") if sort == FSORT_FLOAT: @@ -122,6 +124,11 @@ def FPV(value, sort): # unbound floating point conversions # +from .. import operations +from .. import fp +from .bv import BV +from .bool import Bool + def _fp_length_calc(a1, a2, a3=None): if isinstance(a1, fp.RM) and a3 is None: diff --git a/claripy/backends/backend_vsa.py b/claripy/backends/backend_vsa.py index 00ec3a3a1..283ae36a3 100644 --- a/claripy/backends/backend_vsa.py +++ b/claripy/backends/backend_vsa.py @@ -462,4 +462,18 @@ def constraint_to_si(self, expr): return Balancer(self, expr).compat_ret +from ..ast.base import Base +from ..operations import backend_operations_vsa_compliant, expression_set_operations +from ..vsa import ( + StridedInterval, + CreateStridedInterval, + DiscreteStridedIntervalSet, + ValueSet, + AbstractLocation, + BoolResult, + TrueResult, + FalseResult, +) +from ..balancer import Balancer + BackendVSA.CreateStridedInterval = staticmethod(CreateStridedInterval) diff --git a/claripy/backends/backend_z3.py b/claripy/backends/backend_z3.py index 5b61d638f..85c720017 100644 --- a/claripy/backends/backend_z3.py +++ b/claripy/backends/backend_z3.py @@ -160,6 +160,7 @@ def popitem(self): # And the (ugh) magic # +from . import Backend class BackendZ3(Backend): _split_on = ("And", "Or") @@ -1424,6 +1425,16 @@ def _op_raw_IntToStr(input_bv): "Z3_OP_UNINTERPRETED": "UNINTERPRETED", } +from ..ast.base import Base +from ..ast.bv import BV, BVV +from ..ast.bool import BoolV, Bool +from ..ast.strings import StringV +from ..ast.fp import FP, FPV +from ..operations import backend_operations, backend_fp_operations, backend_strings_operations +from ..fp import FSort, RM +from ..errors import ClaripyError, BackendError, ClaripyOperationError +from .. import _all_operations + op_type_map = { # Boolean "Z3_OP_TRUE": Bool, diff --git a/claripy/backends/backend_z3_parallel.py b/claripy/backends/backend_z3_parallel.py index 69b4af1e4..be1184e6d 100644 --- a/claripy/backends/backend_z3_parallel.py +++ b/claripy/backends/backend_z3_parallel.py @@ -1,4 +1,3 @@ -import logging import os import pickle import threading @@ -9,8 +8,12 @@ num_children = 0 +import logging + l = logging.getLogger("claripy.backends.backend_z3_parallel") +from .backend_z3 import BackendZ3 + class BackendZ3Parallel(BackendZ3): def __init__(self): diff --git a/claripy/frontend.py b/claripy/frontend.py index 1cde721ac..3fce06069 100644 --- a/claripy/frontend.py +++ b/claripy/frontend.py @@ -1,8 +1,8 @@ +#!/usr/bin/env python + import logging import numbers -from . import ast - l = logging.getLogger("claripy.frontends.frontend") diff --git a/claripy/frontend_mixins/constraint_expansion_mixin.py b/claripy/frontend_mixins/constraint_expansion_mixin.py index fb0a40334..af29b1cf7 100644 --- a/claripy/frontend_mixins/constraint_expansion_mixin.py +++ b/claripy/frontend_mixins/constraint_expansion_mixin.py @@ -1,3 +1,5 @@ +#!/usr/bin/env python + import logging from claripy.ast.bool import Or diff --git a/claripy/frontend_mixins/smtlib_script_dumper_mixin.py b/claripy/frontend_mixins/smtlib_script_dumper_mixin.py index 310e94e86..bd86f21ef 100644 --- a/claripy/frontend_mixins/smtlib_script_dumper_mixin.py +++ b/claripy/frontend_mixins/smtlib_script_dumper_mixin.py @@ -1,4 +1,6 @@ import logging +import sys +import threading from claripy.errors import BackendError, ClaripyFrontendError @@ -20,3 +22,11 @@ def get_smtlib_script_satisfiability(self, extra_constraints=(), extra_variables return self._solver_backend._get_satisfiability_smt_script(csts, variables) except BackendError as e: raise ClaripyFrontendError("Backend error during smtlib script generation") from e + + # def merge(self, others, merge_conditions, common_ancestor=None): + # return self._solver_backend.__class__.__name__ == 'BackendZ3', ConstrainedFrontend.merge( + # self, others, merge_conditions, common_ancestor=common_ancestor + # )[1] + + +from ..errors import BackendError, ClaripyFrontendError diff --git a/claripy/frontends/composite_frontend.py b/claripy/frontends/composite_frontend.py index 78fe9d2e6..77c5b731a 100644 --- a/claripy/frontends/composite_frontend.py +++ b/claripy/frontends/composite_frontend.py @@ -1,5 +1,8 @@ import itertools import logging + +l = logging.getLogger("claripy.frontends.composite_frontend") + import weakref from typing import TYPE_CHECKING, Set diff --git a/claripy/frontends/constrained_frontend.py b/claripy/frontends/constrained_frontend.py index d45a25187..576cedbb0 100644 --- a/claripy/frontends/constrained_frontend.py +++ b/claripy/frontends/constrained_frontend.py @@ -7,6 +7,7 @@ l = logging.getLogger("claripy.frontends.constrained_frontend") +from ..frontend import Frontend class ConstrainedFrontend(Frontend): # pylint:disable=abstract-method def __init__(self): diff --git a/claripy/frontends/hybrid_frontend.py b/claripy/frontends/hybrid_frontend.py index 4323dd6cf..de4233920 100644 --- a/claripy/frontends/hybrid_frontend.py +++ b/claripy/frontends/hybrid_frontend.py @@ -1,9 +1,10 @@ +#!/usr/bin/env python + import logging from claripy.errors import ClaripyFrontendError from claripy.frontend import Frontend -l = logging.getLogger("claripy.frontends.full_frontend") _VALIDATE_BALANCER = False diff --git a/claripy/frontends/light_frontend.py b/claripy/frontends/light_frontend.py index d132f37bd..8f4c5faa8 100644 --- a/claripy/frontends/light_frontend.py +++ b/claripy/frontends/light_frontend.py @@ -7,6 +7,7 @@ l = logging.getLogger("claripy.frontends.light_frontend") +from .constrained_frontend import ConstrainedFrontend class LightFrontend(ConstrainedFrontend): def __init__(self, solver_backend, **kwargs): diff --git a/claripy/frontends/replacement_frontend.py b/claripy/frontends/replacement_frontend.py index b56c3963d..ab06f7f6f 100644 --- a/claripy/frontends/replacement_frontend.py +++ b/claripy/frontends/replacement_frontend.py @@ -13,6 +13,7 @@ l = logging.getLogger("claripy.frontends.replacement_frontend") +from .constrained_frontend import ConstrainedFrontend class ReplacementFrontend(ConstrainedFrontend): def __init__( diff --git a/claripy/operations.py b/claripy/operations.py index 058ead290..4ff29c102 100644 --- a/claripy/operations.py +++ b/claripy/operations.py @@ -589,3 +589,8 @@ def strtoint_bv_size_calc(s, bitlength): # pylint: disable=unused-argument "Or", "Xor", } + +from .errors import ClaripyOperationError, ClaripyTypeError +from . import simplifications +from . import ast +from . import fp diff --git a/claripy/simplifications.py b/claripy/simplifications.py index 2e7f6cdb6..18be5b2d8 100644 --- a/claripy/simplifications.py +++ b/claripy/simplifications.py @@ -961,7 +961,7 @@ def rotate_shift_mask_simplifier(a, b): return None a_00, a_01 = a_0.args a_10, a_11 = a_1.args - if a_00 is not a_10: + if not a_00 is a_10: return None if a_01.op != "BVV" or a_11.op != "BVV": return None @@ -1162,6 +1162,10 @@ def zeroext_comparing_against_simplifier(op, a, b): "Or", } +from .backend_manager import backends +from . import ast +from . import fp + # the actual instance simpleton = SimplificationManager() diff --git a/claripy/vsa/strided_interval.py b/claripy/vsa/strided_interval.py index 1253ee21e..998a2be08 100644 --- a/claripy/vsa/strided_interval.py +++ b/claripy/vsa/strided_interval.py @@ -16,6 +16,8 @@ logger = logging.getLogger("claripy.vsa.strided_interval") +from ..backend_object import BackendObject + def reversed_processor(f): def processor(self, *args, **kwargs): @@ -3608,5 +3610,11 @@ def CreateStridedInterval( return dsis -from . import discrete_strided_interval_set # noqa: E402 -from .discrete_strided_interval_set import DiscreteStridedIntervalSet # noqa: E402 +from .errors import ClaripyVSAError +from ..errors import ClaripyOperationError +from .bool_result import TrueResult, FalseResult, MaybeResult +from . import discrete_strided_interval_set +from .discrete_strided_interval_set import DiscreteStridedIntervalSet +from .valueset import ValueSet +from ..ast.base import Base +from ..bv import BVV diff --git a/claripy/vsa/valueset.py b/claripy/vsa/valueset.py index 467ec45e9..f9b605545 100644 --- a/claripy/vsa/valueset.py +++ b/claripy/vsa/valueset.py @@ -700,4 +700,8 @@ def identical(self, o): return True -from .strided_interval import StridedInterval # noqa: E402 +from ..ast.base import Base +from .strided_interval import StridedInterval +from .bool_result import BoolResult, TrueResult, FalseResult, MaybeResult +from .errors import ClaripyVSAOperationError, ClaripyVSAError +from ..errors import ClaripyValueError diff --git a/tests/test_concrete.py b/tests/test_concrete.py index cca4f1b6f..3966ead87 100644 --- a/tests/test_concrete.py +++ b/tests/test_concrete.py @@ -4,9 +4,10 @@ def test_concrete(): a = claripy.BVV(10, 32) b = claripy.BoolV(True) + # c = claripy.BVS('x', 32) - assert isinstance(claripy.backends.concrete.convert(a), claripy.bv.BVV) - assert isinstance(claripy.backends.concrete.convert(b), bool) + assert type(claripy.backends.concrete.convert(a)) is claripy.bv.BVV + assert type(claripy.backends.concrete.convert(b)) is bool a = claripy.BVV(1337, 32) b = a[31:16] diff --git a/tests/test_vsa.py b/tests/test_vsa.py index 4d1f2bca0..e0eb0dc37 100644 --- a/tests/test_vsa.py +++ b/tests/test_vsa.py @@ -66,16 +66,16 @@ def test_reversed_concat(): assert claripy.backends.vsa.max(reversed_b) == 0xFF000000 a_concat_b = claripy.Concat(a, b) - assert a_concat_b._model_vsa._reversed is False + assert a_concat_b._model_vsa._reversed == False ra_concat_b = claripy.Concat(reversed_a, b) - assert ra_concat_b._model_vsa._reversed is False + assert ra_concat_b._model_vsa._reversed == False a_concat_rb = claripy.Concat(a, reversed_b) - assert a_concat_rb._model_vsa._reversed is False + assert a_concat_rb._model_vsa._reversed == False ra_concat_rb = claripy.Concat(reversed_a, reversed_b) - assert ra_concat_rb._model_vsa._reversed is False + assert ra_concat_rb._model_vsa._reversed == False def test_simple_cardinality(): @@ -285,7 +285,7 @@ def test_join(): assert 225 in vsa_model(tmp).eval(255) assert 0 in vsa_model(tmp).eval(255) assert 135 in vsa_model(tmp).eval(255) - assert 138 not in vsa_model(tmp).eval(255) + assert not 138 in vsa_model(tmp).eval(255) def test_vsa(): @@ -701,7 +701,7 @@ def test_vsa_constraint_to_si(): ) falseside_sat, falseside_replacement = b.constraint_to_si(ast_false) - assert falseside_sat is True + assert falseside_sat == True assert len(falseside_replacement) == 1 assert falseside_replacement[0][0] is s1 # False side; claripy.SI<32>1[1, 2]