AccessControl 7.6__cp315-cp315-win_amd64.whl

AccessControl/Implementation.py

@@ -0,0 +1,111 @@
+##############################################################################
+#
+# Copyright (c) 2003 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+
+"""Controller that can switch between security machinery implementations.
+
+This module allows configuration of the security implementation after
+the initial import of the modules.  It is intended to allow runtime
+selection of the machinery based on Zope's configuration file.
+
+The helper function defined here switches between the 'C' and 'PYTHON'
+security implementations by loading the appropriate implementation
+module and wiring the implementation into the other modules of the
+AccessControl package that defined the various components before this
+module was introduced.
+
+"""
+
+import os
+
+
+PURE_PYTHON = int(os.environ.get('PURE_PYTHON', '0'))
+CAPI = not PURE_PYTHON
+
+
+def getImplementationName():
+    """Return the name of the implementation currently being used."""
+    return _implementation_name
+
+
+def setImplementation(name):
+    """Select the policy implementation to use. The 'name' must be either
+       'PYTHON' or 'C'. NOTE: this function is intended to be called
+       exactly once, so that the Zope config file can dictate the policy
+       implementation to be used. Subsequent calls to this function will
+       have no effect!!
+    """
+    import sys
+    global _implementation_name
+    global _implementation_set
+
+    if _implementation_set:
+        return
+
+    name = name.upper()
+    if name == _implementation_name:
+        return
+    if name == "C":
+        from AccessControl import ImplC as impl
+    elif name == "PYTHON":
+        from AccessControl import ImplPython as impl
+    else:
+        raise ValueError("unknown policy implementation: %r" % name)
+
+    _implementation_name = name
+    for modname, names in _policy_names.items():
+        __import__(modname)
+        mod = sys.modules[modname]
+        for n in names:
+            setattr(mod, n, getattr(impl, n))
+        if hasattr(mod, "initialize"):
+            mod.initialize(impl)
+
+    from AccessControl.SecurityManager import setSecurityPolicy
+    policy = impl.ZopeSecurityPolicy(True, True)
+    setSecurityPolicy(policy)
+
+    _implementation_set = 1
+
+
+# start with the default, mostly because we need something for the tests
+_default_implementation = 'C'
+_implementation_name = None
+_implementation_set = 0
+
+_policy_names = {
+    "AccessControl": ("setDefaultBehaviors",
+                      ),
+    "AccessControl.PermissionRole": ("_what_not_even_god_should_do",
+                                     "rolesForPermissionOn",
+                                     "PermissionRole",
+                                     "imPermissionRole",
+                                     ),
+    "AccessControl.SecurityManagement": ("SecurityManager",
+                                         ),
+    "AccessControl.SecurityManager": ("SecurityManager",
+                                      ),
+    "AccessControl.ZopeGuards": ("aq_validate",
+                                 "guarded_getattr",
+                                 ),
+    "AccessControl.ZopeSecurityPolicy": ("ZopeSecurityPolicy",
+                                         ),
+}
+
+
+if CAPI:
+    setImplementation(_default_implementation)
+else:
+    setImplementation('PYTHON')
+
+# allow the implementation to change from the default
+_implementation_set = 0

AccessControl/Owned.py

@@ -0,0 +1,30 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Support for owned objects
+"""
+
+from zope.deferredimport import deprecated
+
+
+deprecated(
+    "The functionality of AccessControl.Owned has moved to"
+    " AccessControl.owner. Please import from there."
+    " This backward compatibility shim will be removed in AccessControl"
+    " version 6.",
+    EditUnowned='AccessControl.owner:EditUnowned',
+    EmergencyUserCannotOwn='AccessControl.owner:EmergencyUserCannotOwn',
+    UnownableOwner='AccessControl.owner:UnownableOwner',
+    absattr='AccessControl.owner:absattr',
+    ownableFilter='AccessControl.owner:ownableFilter',
+    ownerInfo='AccessControl.owner:ownerInfo',
+)

AccessControl/Permission.py

@@ -0,0 +1,179 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE.
+#
+##############################################################################
+"""Permissions
+"""
+
+import re
+
+from Acquisition import aq_base
+
+
+_NOT_ALLOWED_CHARS = re.compile(r'[^a-zA-Z0-9_]')
+
+
+def getPermissionIdentifier(name):
+    return '_' + re.sub(_NOT_ALLOWED_CHARS, '_', name) + "_Permission"
+
+
+# BBB
+pname = getPermissionIdentifier
+
+_marker = []
+
+
+class Permission:
+    # A Permission maps a named logical permission to a set
+    # of attribute names. Attribute names which appear in a
+    # permission may not appear in any other permission defined
+    # by the object.
+
+    def __init__(self, name, data, obj, default=None):
+        self.name = name
+        self._p = getPermissionIdentifier(name)
+        self.data = data
+        self.obj = aq_base(obj)
+        self.default = default
+
+    def getRoles(self, default=_marker):
+        # Return the list of role names which have been given
+        # this permission for the object in question. To do
+        # this, we try to get __roles__ from all of the object
+        # attributes that this permission represents.
+        obj = self.obj
+        name = self._p
+        if hasattr(obj, name):
+            return getattr(obj, name)
+        roles = default
+        for name in self.data:
+            if name:
+                if hasattr(obj, name):
+                    attr = getattr(obj, name)
+                    if getattr(attr, '__self__', None) is not None:
+                        attr = attr.__self__
+                        if hasattr(attr, '__dict__'):
+                            attr = attr.__dict__
+                            name = name + '__roles__'
+                            if name in attr:
+                                roles = attr[name]
+                                break
+            elif hasattr(obj, '__dict__'):
+                attr = obj.__dict__
+                if '__roles__' in attr:
+                    roles = attr['__roles__']
+                    break
+
+        if roles:
+            try:
+                if 'Shared' not in roles:
+                    return tuple(roles)
+                roles = list(roles)
+                roles.remove('Shared')
+                return roles
+            except BaseException:
+                return []
+
+        if roles is None:
+            return ['Manager', 'Anonymous']
+        if roles is _marker:
+            return ['Manager']
+
+        return roles
+
+    def setRoles(self, roles):
+        obj = self.obj
+
+        if isinstance(roles, list) and not roles:
+            if hasattr(obj, self._p):
+                delattr(obj, self._p)
+        else:
+            setattr(obj, self._p, roles)
+
+        for name in self.data:
+            if name == '':
+                attr = obj
+            else:
+                attr = getattr(obj, name)
+            try:
+                del attr.__roles__
+            except BaseException:
+                pass
+            try:
+                delattr(obj, name + '__roles__')
+            except BaseException:
+                pass
+
+    def setRole(self, role, present):
+        roles = self.getRoles()
+        if role in roles:
+            if present:
+                return
+            if isinstance(roles, list):
+                roles.remove(role)
+            else:
+                roles = list(roles)
+                roles.remove(role)
+                roles = tuple(roles)
+        elif not present:
+            return
+        else:
+            if isinstance(roles, list):
+                roles.append(role)
+            else:
+                roles = roles + (role, )
+        self.setRoles(roles)
+
+    def __len__(self):
+        return 1
+
+    def __str__(self):
+        return self.name
+
+
+_registeredPermissions = {}
+_ac_permissions = ()
+
+
+def getPermissions():
+    return _ac_permissions
+
+
+def addPermission(perm, default_roles=('Manager', )):
+    if perm in _registeredPermissions:
+        return
+
+    entry = ((perm, (), default_roles), )
+    global _ac_permissions
+    _ac_permissions = _ac_permissions + entry
+    _registeredPermissions[perm] = 1
+    mangled = getPermissionIdentifier(perm)
+    if not hasattr(ApplicationDefaultPermissions, mangled):
+        setattr(ApplicationDefaultPermissions, mangled, default_roles)
+
+
+def registerPermissions(permissions, defaultDefault=('Manager', )):
+    """Register an __ac_permissions__ sequence.
+    """
+    for setting in permissions:
+        if setting[0] in _registeredPermissions:
+            continue
+        if len(setting) == 2:
+            perm, methods = setting
+            default = defaultDefault
+        else:
+            perm, methods, default = setting
+        addPermission(perm, default)
+
+
+class ApplicationDefaultPermissions:
+    _View_Permission = ('Manager', 'Anonymous')
+    _Access_contents_information_Permission = ('Manager', 'Anonymous')

AccessControl/PermissionMapping.py

@@ -0,0 +1,165 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Permission Mapping
+
+Sometimes, we need an object's permissions to be remapped to other permissions
+when the object is used in special ways.  This is rather hard, since we
+need the object's ordinary permissions intact so we can manage it.
+"""
+
+from html import escape
+
+from Acquisition import ImplicitAcquisitionWrapper
+from ExtensionClass import Base
+from zope.interface import implementer
+
+from AccessControl.class_init import InitializeClass
+from AccessControl.interfaces import IPermissionMappingSupport
+from AccessControl.owner import UnownableOwner
+from AccessControl.Permission import getPermissionIdentifier
+from AccessControl.requestmethod import requestmethod
+
+
+@implementer(IPermissionMappingSupport)
+class RoleManager:
+
+    # XXX: No security declarations?
+
+    def manage_getPermissionMapping(self):
+        """Return the permission mapping for the object
+
+        This is a list of dictionaries with:
+
+          permission_name -- The name of the native object permission
+
+          class_permission -- The class permission the permission is
+             mapped to.
+        """
+        wrapper = getattr(self, '_permissionMapper', None)
+        if wrapper is None:
+            wrapper = PM()
+
+        perms = {}
+        for p in self.possible_permissions():
+            perms[getPermissionIdentifier(p)] = p
+
+        r = []
+        a = r.append
+        for ac_perms in self.ac_inherited_permissions(1):
+            p = perms.get(getPermissionMapping(ac_perms[0], wrapper), '')
+            a({'permission_name': ac_perms[0], 'class_permission': p})
+        return r
+
+    @requestmethod('POST')
+    def manage_setPermissionMapping(self,
+                                    permission_names=[],
+                                    class_permissions=[],
+                                    REQUEST=None):
+        """Change the permission mapping
+        """
+        wrapper = getattr(self, '_permissionMapper', None)
+        if wrapper is None:
+            wrapper = PM()
+
+        perms = self.possible_permissions()
+        for i in range(len(permission_names)):
+            name = permission_names[i]
+            p = class_permissions[i]
+            if p and (p not in perms):
+                __traceback_info__ = perms, p, i
+                raise ValueError(
+                    """Attempted to map a permission to a permission, %s,
+                    that is not valid. This should never happen. (Waaa).
+                    """ % escape(p))
+            setPermissionMapping(name, wrapper, p)
+
+        self._permissionMapper = wrapper
+
+        if REQUEST is not None:
+            return self.manage_access(
+                REQUEST,
+                manage_tabs_message='The permission mapping has been updated')
+
+    def _isBeingUsedAsAMethod(self, REQUEST=None, wannaBe=0):
+        try:
+            if hasattr(self, 'aq_self'):
+                r = self.aq_acquire('_isBeingUsedAsAMethod_')
+            else:
+                r = self._isBeingUsedAsAMethod_
+        except BaseException:
+            r = 0
+
+        if REQUEST is not None:
+            if not r != (not wannaBe):
+                REQUEST.response.notFoundError()
+
+        return r
+
+
+InitializeClass(RoleManager)
+
+
+def getPermissionMapping(name, obj, st=str):
+    obj = getattr(obj, 'aq_base', obj)
+    name = getPermissionIdentifier(name)
+    r = getattr(obj, name, '')
+    if not isinstance(r, st):
+        r = ''
+    return r
+
+
+def setPermissionMapping(name, obj, v):
+    name = getPermissionIdentifier(name)
+    if v:
+        setattr(obj, name, getPermissionIdentifier(v))
+    elif name in obj.__dict__:
+        delattr(obj, name)
+
+
+class PM(Base):
+    _owner = UnownableOwner
+
+    _View_Permission = '_View_Permission'
+    _is_wrapperish = 1
+
+    def __getattr__(self, name):
+        # We want to make sure that any non-explicitly set methods are
+        # private!
+        if name.startswith('_') and name.endswith("_Permission"):
+            return ''
+        raise AttributeError(escape(name))
+
+
+PermissionMapper = PM
+
+
+def aqwrap(object, wrapper, parent):
+    r = Rewrapper()
+    r._ugh = wrapper, object, parent
+    return r
+
+
+class Rewrapper(Base):
+    def __of__(self, parent):
+        w, m, p = self._ugh
+        return m.__of__(ImplicitAcquisitionWrapper(w, parent))
+
+    def __getattr__(self, name):
+        w, m, parent = self._ugh
+        self = m.__of__(ImplicitAcquisitionWrapper(w, parent))
+        return getattr(self, name)
+
+    def __call__(self, *args, **kw):
+        w, m, parent = self._ugh
+        self = m.__of__(ImplicitAcquisitionWrapper(w, parent))
+        return self(*args, **kw)

AccessControl/PermissionRole.py

@@ -0,0 +1,19 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+'''Objects that implement Permission-based roles.
+'''
+
+# The following names are inserted by AccessControl.Implementation:
+#
+# rolesForPermissionOn, PermissionRole, imPermissionRole,
+# _what_not_even_god_should_do

AccessControl/Permissions.py

@@ -0,0 +1,65 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Constant definitions for built-in Zope permissions
+"""
+
+access_contents_information = 'Access contents information'
+add_database_methods = 'Add Database Methods'
+add_documents_images_and_files = 'Add Documents, Images, and Files'
+add_external_methods = 'Add External Methods'
+add_folders = 'Add Folders'
+add_mailhost_objects = 'Add MailHost objects'
+add_page_templates = 'Add Page Templates'
+add_python_scripts = 'Add Python Scripts'
+add_user_folders = 'Add User Folders'
+add_vocabularies = 'Add Vocabularies'
+add_z_gadfly_database_connections = 'Add Z Gadfly Database Connections'
+add_zcatalogs = 'Add ZCatalogs'
+add_zope_tutorials = 'Add Zope Tutorials'
+change_database_connections = 'Change Database Connections'
+change_database_methods = 'Change Database Methods'
+change_external_methods = 'Change External Methods'
+change_images_and_files = 'Change Images and Files'
+change_python_scripts = 'Change Python Scripts'
+change_configuration = 'Change configuration'
+change_page_templates = 'Change Page Templates'
+change_permissions = 'Change permissions'
+change_proxy_roles = 'Change proxy roles'
+copy_or_move = 'Copy or Move'
+create_class_instances = 'Create class instances'
+define_permissions = 'Define permissions'
+delete_objects = 'Delete objects'
+edit_factories = 'Edit Factories'
+ftp_access = 'FTP access'
+import_export_objects = 'Import/Export objects'
+manage_vocabulary = 'Manage Vocabulary'
+manage_zcatalog_entries = 'Manage ZCatalog Entries'
+manage_zcatalog_indexes = 'Manage ZCatalogIndex Entries'
+manage_properties = 'Manage properties'
+manage_users = 'Manage users'
+open_close_database_connection = 'Open/Close Database Connection'
+open_close_database_connections = 'Open/Close Database Connections'
+query_vocabulary = 'Query Vocabulary'
+search_zcatalog = 'Search ZCatalog'
+take_ownership = 'Take ownership'
+test_database_connections = 'Test Database Connections'
+undo_changes = 'Undo changes'
+use_database_methods = 'Use Database Methods'
+use_factories = 'Use Factories'
+use_mailhost_services = 'Use mailhost services'
+view = 'View'
+view_management_screens = 'View management screens'
+webdav_access = 'WebDAV access'
+webdav_lock_items = 'WebDAV Lock items'
+webdav_manage_locks = 'Manage WebDAV Locks'
+webdav_unlock_items = 'WebDAV Unlock items'

AccessControl/Role.py

@@ -0,0 +1,34 @@
+##############################################################################
+#
+# Copyright (c) 2002 Zope Foundation and Contributors.
+#
+# This software is subject to the provisions of the Zope Public License,
+# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
+# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+# FOR A PARTICULAR PURPOSE
+#
+##############################################################################
+"""Access control support
+"""
+
+from zope.deferredimport import deprecated
+
+
+deprecated(
+    "The functionality of AccessControl.Role has moved to"
+    " AccessControl.rolemanager. Please import from there."
+    " This backward compatibility shim will be removed in AccessControl"
+    " version 6.",
+    DEFAULTMAXLISTUSERS='AccessControl.rolemanager:DEFAULTMAXLISTUSERS',
+    _isBeingUsedAsAMethod='AccessControl.rolemanager:_isBeingUsedAsAMethod',
+    _isNotBeingUsedAsAMethod='AccessControl.rolemanager:_isNotBeingUsedAsAMethod',  # noqa
+    class_attrs='AccessControl.rolemanager:class_attrs',
+    class_dict='AccessControl.rolemanager:class_dict',
+    classattr='AccessControl.rolemanager:classattr',
+    gather_permissions='AccessControl.rolemanager:gather_permissions',
+    instance_attrs='AccessControl.rolemanager:instance_attrs',
+    instance_dict='AccessControl.rolemanager:instance_dict',
+    reqattr='AccessControl.rolemanager:reqattr',
+)