extra normalizer method "normal" and consistent eq/hash semantics for use as dict keys and/or set members.

Author: d-w-moore

README.md

@@ -2149,15 +2149,19 @@ The following code sorts the objects based on their lexical order starting with
 normalized `access_name`, which serves to group identical permissions together:
 ```py
 from irods.access import *
-normalize = lambda acl: acl.copy(decanonicalize=-1, implied_zone='tempZone')
+import irods.helpers
 acls = [
     iRODSAccess('read_object', '/tempZone/home/alice', 'bob', 'tempZone'),
     ACLOperation('write', 'rods'),
     ACLOperation('read', 'bob'),
 ]
+
+session = irods.helpers.make_session()
+normalize = lambda acl: acl.normal(session)
+
 print(normalize(acls[0]) == normalize(acls[2]))
 acls.sort(key=normalize)
-print(normalize(iRODSAccess('read', '/tempZone/home/alice', 'bob')) in map(normalize, acls))
+print(normalize(iRODSAccess('read', '', 'bob')) in map(normalize,acls))
 ```
 
 If strict order of permissions is desired, we can use code such as the following:
@@ -2166,11 +2170,11 @@ from irods.access import *
 from pprint import pp
 pp(sorted(
     [
-        ACLOperation('read', 'bob'),
+        ACLOperation('read', 'bob' ),
         ACLOperation('own', 'rods'),
         ACLOperation('read_object', 'alice')
     ],
-    key=lambda acl: (all_permissions[acl.access_name], normalize(acl))
+    key=lambda acl: (all_permissions[acl.access_name], acl.normal())
 ))
 ```
 

irods/access.py

@@ -4,7 +4,6 @@
 
 from irods.collection import iRODSCollection
 from irods.data_object import iRODSDataObject
-from irods.path import iRODSPath
 
 _permissions = (
     "own",
@@ -102,23 +101,28 @@ def __init__(self, access_name, path, user_name, user_zone, user_type):
         self.user_type = user_type
 
     def __lt__(self, other):
-        return (self.access_name, self.user_name, self.user_zone, iRODSPath(self.path)) < (
+        return (self.access_name, self.user_name, self.user_zone, str(self.path)) < (
             other.access_name,
             other.user_name,
             other.user_zone,
-            iRODSPath(other.path),
+            str(other.path),
         )
 
     def __eq__(self, other):
         return (
             self.access_name == other.access_name
-            and iRODSPath(self.path) == iRODSPath(other.path)
+            and str(self.path) == str(other.path)
             and self.user_name == other.user_name
             and self.user_zone == other.user_zone
         )
 
     def __hash__(self):
-        return hash((self.access_name, iRODSPath(self.path), self.user_name, self.user_zone))
+        return hash((self.access_name, str(self.path), self.user_name, self.user_zone))
+
+    def normal(self, session = None):
+        normal_form = self.copy(decanonicalize=-1, implied_zone = (session.zone if session else ''))
+        normal_form.path = ""
+        return normal_form
 
     def copy(self, decanonicalize=False, implied_zone=''):
         """

irods/test/access_test.py

@@ -514,16 +514,13 @@ def test_atomic_acls__issue_505(self):
                 a4 := ACLOperation("read", group.name),
             )
 
-            def normalize(access):
-                return access.copy(decanonicalize=-1, implied_zone=ses.zone)
-
-            accesses = [normalize(acl) for acl in ses.acls.get(self.coll)]
+            accesses = {acl.normal(ses) for acl in ses.acls.get(self.coll)}
 
             # Assert that the ACLs we added are among those listed for the object in the catalog.
-            self.assertIn(normalize(a1), accesses)
-            self.assertIn(normalize(a2), accesses)
-            self.assertIn(normalize(a3), accesses)
-            self.assertIn(normalize(a4), accesses)
+            self.assertIn(a1.normal(ses), accesses)
+            self.assertIn(a2.normal(ses), accesses)
+            self.assertIn(a3.normal(ses), accesses)
+            self.assertIn(a4.normal(ses), accesses)
 
         finally:
             if user1: