chore: convert restrictions to meta.Immutable

Signed-off-by: Brian Harring <[email protected]>

Author: ferringb

src/pkgcore/ebuild/atom.py

@@ -16,9 +16,8 @@
 from ..restrictions.packages import AndRestriction as PkgAndRestriction
 from ..restrictions.packages import Conditional
 from ..restrictions.values import ContainmentMatch
-from . import cpv
+from . import cpv, errors, restricts
 from . import eapi as eapi_mod
-from . import errors, restricts
 
 # namespace compatibility...
 MalformedAtom = errors.MalformedAtom
@@ -95,7 +94,6 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
         if not atom:
             raise errors.MalformedAtom(atom)
 
-        sf = object.__setattr__
         orig_atom = atom
         override_kls = False
         use_start = atom.find("[")
@@ -116,7 +114,7 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                 raise errors.MalformedAtom(orig_atom, "use restriction isn't completed")
             elif use_end != len(atom) - 1:
                 raise errors.MalformedAtom(orig_atom, "trailing garbage after use dep")
-            sf(self, "use", tuple(sorted(atom[use_start + 1 : use_end].split(","))))
+            self.use = tuple(sorted(atom[use_start + 1 : use_end].split(",")))
             for x in self.use:
                 # stripped purely for validation reasons
                 try:
@@ -152,10 +150,10 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                 except IndexError:
                     raise errors.MalformedAtom(orig_atom, "empty use dep detected")
             if override_kls:
-                sf(self, "__class__", transitive_use_atom)
+                self.__class__ = transitive_use_atom
             atom = atom[0:use_start] + atom[use_end + 1 :]
         else:
-            sf(self, "use", None)
+            self.use = None
         if slot_start != -1:
             i2 = atom.find("::", slot_start)
             if i2 != -1:
@@ -173,9 +171,9 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                         f"repo_id may contain only [a-Z0-9_-/], found {repo_id!r}",
                     )
                 atom = atom[:i2]
-                sf(self, "repo_id", repo_id)
+                self.repo_id = repo_id
             else:
-                sf(self, "repo_id", None)
+                self.repo_id = None
             # slot dep.
             slot = atom[slot_start + 1 :]
             slot_operator = subslot = None
@@ -230,17 +228,12 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                 if len(slots) == 2:
                     slot, subslot = slots
 
-            sf(self, "slot_operator", slot_operator)
-            sf(self, "slot", slot)
-            sf(self, "subslot", subslot)
+            self.slot_operator, self.slot, self.subslot = slot_operator, slot, subslot
             atom = atom[:slot_start]
         else:
-            sf(self, "slot_operator", None)
-            sf(self, "slot", None)
-            sf(self, "subslot", None)
-            sf(self, "repo_id", None)
+            self.slot_operator = self.slot = self.subslot = self.repo_id = None
 
-        sf(self, "blocks", atom[0] == "!")
+        self.blocks = atom[0] == "!"
         if self.blocks:
             atom = atom[1:]
             # hackish/slow, but lstrip doesn't take a 'prune this many' arg
@@ -251,32 +244,32 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                         f"strong blockers are not supported in EAPI {eapi}"
                     )
                 atom = atom[1:]
-                sf(self, "blocks_strongly", True)
+                self.blocks_strongly = True
             else:
-                sf(self, "blocks_strongly", False)
+                self.blocks_strongly = False
         else:
-            sf(self, "blocks_strongly", False)
+            self.blocks_strongly = False
 
         if atom[0] in ("<", ">"):
             if atom[1] == "=":
-                sf(self, "op", atom[:2])
+                self.op = atom[:2]
                 atom = atom[2:]
             else:
-                sf(self, "op", atom[0])
+                self.op = atom[0]
                 atom = atom[1:]
         elif atom[0] == "=":
             if atom[-1] == "*":
-                sf(self, "op", "=*")
+                self.op = "=*"
                 atom = atom[1:-1]
             else:
                 atom = atom[1:]
-                sf(self, "op", "=")
+                self.op = "="
         elif atom[0] == "~":
-            sf(self, "op", "~")
+            self.op = "~"
             atom = atom[1:]
         else:
-            sf(self, "op", "")
-        sf(self, "cpvstr", atom)
+            self.op = ""
+        self.cpvstr = atom
 
         if self.slot is not None and not eapi_obj.options.has_slot_deps:
             raise errors.MalformedAtom(
@@ -295,7 +288,7 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                     orig_atom, f"repo_id atoms aren't supported for EAPI {eapi}"
                 )
         try:
-            sf(self, "_cpv", cpv.CPV(self.cpvstr, versioned=bool(self.op)))
+            self._cpv = cpv.CPV(self.cpvstr, versioned=bool(self.op))
         except errors.InvalidCPV as e:
             raise errors.MalformedAtom(orig_atom) from e
 
@@ -308,8 +301,9 @@ def __init__(self, atom: str, negate_vers: bool = False, eapi: str = "-1"):
                 )
         elif self.version is not None:
             raise errors.MalformedAtom(orig_atom, "versioned atom requires an operator")
-        sf(self, "_hash", hash(orig_atom))
-        sf(self, "negate_vers", negate_vers)
+
+        self._hash = hash(orig_atom)
+        self.negate_vers = negate_vers
 
     __getattr__ = klass.GetAttrProxy("_cpv")
     __dir__ = klass.DirProxy("_cpv")
@@ -362,7 +356,7 @@ def cnf_solutions(self, full_solution_expansion=False):
         return [[self]]
 
     @property
-    def is_simple(self):
+    def is_simple(self) -> bool:
         return len(self.restrictions) == 2
 
     @klass.jit_attr
@@ -694,7 +688,7 @@ class transitive_use_atom(atom):
     __inst_caching__ = True
     _nontransitive_use_atom = atom
 
-    is_simple = False
+    is_simple = False  # type: ignore
 
     def _stripped_use(self):
         return str(self).split("[", 1)[0]

src/pkgcore/ebuild/conditionals.py

@@ -34,13 +34,11 @@ def __init__(
         node_conds=True,
         known_conditionals=None,
     ):
-        sf = object.__setattr__
-        sf(self, "_known_conditionals", known_conditionals)
-        sf(self, "element_class", element_class)
-        sf(self, "restrictions", restrictions)
-        sf(self, "_node_conds", node_conds)
-        sf(self, "type", restriction.package_type)
-        sf(self, "negate", False)
+        self._known_conditionals = known_conditionals
+        self.element_class = element_class
+        self.restrictions = restrictions
+        self._node_conds = node_conds
+        self.type, self.negate = restriction.package_type, False
 
     @classmethod
     def parse(

src/pkgcore/restrictions/boolean.py

@@ -9,7 +9,7 @@
 
 from itertools import islice
 
-from snakeoil.klass import cached_hash, generic_equality
+from snakeoil.klass import cached_hash, generic_equality, immutable
 
 from . import restriction
 
@@ -42,12 +42,10 @@ def __init__(self, *restrictions, **kwds):
         :keyword negate: should the logic be negated?
         """
 
-        sf = object.__setattr__
-
         node_type = kwds.pop("node_type", None)
 
-        sf(self, "type", node_type)
-        sf(self, "negate", kwds.pop("negate", False))
+        self.type = node_type
+        self.negate = kwds.pop("negate", False)
 
         if node_type is not None:
             try:
@@ -62,12 +60,9 @@ def __init__(self, *restrictions, **kwds):
                 )
 
         if kwds.pop("finalize", True):
-            if not isinstance(restrictions, tuple):
-                sf(self, "restrictions", tuple(restrictions))
-            else:
-                sf(self, "restrictions", restrictions)
+            self.restrictions = tuple(restrictions)
         else:
-            sf(self, "restrictions", list(restrictions))
+            self.restrictions = list(restrictions)
 
         if kwds:
             kwds.pop("disable_inst_caching", None)
@@ -123,9 +118,10 @@ def add_restriction(self, *new_restrictions):
         except AttributeError:
             raise TypeError("%r is finalized" % self)
 
+    @immutable.Simple.__allow_mutation_wrapper__
     def finalize(self):
         """finalize the restriction instance, disallowing adding restrictions."""
-        object.__setattr__(self, "restrictions", tuple(self.restrictions))
+        self.restrictions = tuple(self.restrictions)
 
     def __repr__(self):
         return "<%s negate=%r type=%r finalized=%r restrictions=%r @%#8x>" % (

src/pkgcore/restrictions/delegated.py

@@ -30,8 +30,7 @@ def __init__(self, transform_func, negate=False):
         if not callable(transform_func):
             raise TypeError(transform_func)
 
-        object.__setattr__(self, "negate", negate)
-        object.__setattr__(self, "_transform", transform_func)
+        self.negate, self._transform = negate, transform_func
 
     def match(self, pkginst):
         return self._transform(pkginst, "match") != self.negate

src/pkgcore/restrictions/packages.py

@@ -45,15 +45,14 @@ def __init__(self, attr, childrestriction, negate=False, ignore_missing=True):
         """
         if not childrestriction.type == self.subtype:
             raise TypeError("restriction must be of type %r" % (self.subtype,))
-        sf = object.__setattr__
-        sf(self, "negate", negate)
+        self.negate = negate
         self._parse_attr(attr)
-        sf(self, "restriction", childrestriction)
-        sf(self, "ignore_missing", ignore_missing)
+        self.restriction = childrestriction
+        self.ignore_missing = ignore_missing
 
     def _parse_attr(self, attr):
-        object.__setattr__(self, "_pull_attr_func", static_attrgetter(attr))
-        object.__setattr__(self, "_attr_split", attr.split("."))
+        self._pull_attr_func = static_attrgetter(attr)
+        self._attr_split = attr.split(".")
 
     def _pull_attr(self, pkg):
         try:
@@ -171,10 +170,8 @@ def attrs(self):
         return tuple(".".join(x) for x in self._attr_split)
 
     def _parse_attr(self, attrs):
-        object.__setattr__(
-            self, "_pull_attr_func", tuple(map(static_attrgetter, attrs))
-        )
-        object.__setattr__(self, "_attr_split", tuple(x.split(".") for x in attrs))
+        self._pull_attr_func = tuple(map(static_attrgetter, attrs))
+        self._attr_split = tuple(x.split(".") for x in attrs)
 
     def _pull_attr(self, pkg):
         val = []
@@ -216,7 +213,7 @@ def __init__(self, attr, childrestriction, payload, **kwds):
         :param kwds: additional args to pass to :obj:`PackageRestriction`
         """
         PackageRestriction.__init__(self, attr, childrestriction, **kwds)
-        object.__setattr__(self, "payload", tuple(payload))
+        self.payload = tuple(payload)
 
     def __str__(self):
         s = PackageRestriction.__str__(self)
@@ -287,8 +284,8 @@ def __init__(self, *a, **kwds):
         key = kwds.pop("key", None)
         tag = kwds.pop("tag", None)
         boolean.AndRestriction.__init__(self, *a, **kwds)
-        object.__setattr__(self, "key", key)
-        object.__setattr__(self, "tag", tag)
+        self.key = key
+        self.tag = tag
 
     def __str__(self):
         boolean_str = boolean.AndRestriction.__str__(self)

src/pkgcore/restrictions/restriction.py

@@ -6,9 +6,14 @@
 
 from snakeoil import caching, klass
 from snakeoil.currying import pretty_docs
+from snakeoil.klass import immutable
 
 
-class base(klass.SlotsPicklingMixin, metaclass=caching.WeakInstMeta):
+class base(
+    klass.SlotsPicklingMixin,
+    immutable.Simple,
+    metaclass=caching.WeakInstMeta,
+):
     """base restriction matching object.
 
     all derivatives *should* be __slots__ based (lot of instances may
@@ -21,8 +26,6 @@ class base(klass.SlotsPicklingMixin, metaclass=caching.WeakInstMeta):
     __slots__ = ()
     package_matching = False
 
-    klass.inject_immutable_instance(locals())
-
     def match(self, *arg, **kwargs):
         raise NotImplementedError
 
@@ -75,9 +78,7 @@ def __getstate__(self):
         return self.negate, self.type
 
     def __setstate__(self, state):
-        negate, node_type = state
-        object.__setattr__(self, "negate", negate)
-        object.__setattr__(self, "type", node_type)
+        self.negate, self.type = state
 
 
 class Negate(base):