1453576315

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/casbin/pycasbin/commit/<a class=hub.com/casbin/pycasbin/commit/b37f1b61eb4a60a3b4c08b5a0896c249fc2caa0f">b37f1b61e<a href="https://github.com/casbin/pycasbin/commit/b37f1b61eb4a60a3b4c08b5a0896c249fc2caa0f">">Merge </a><a class="double-link" href="https://github.com/casbin/pycasbin/commit/<a class="double-link" href="https://github.com/casbin/pycasbin/commit/1d60cd36887995b034dca7561179e13e9aae0c9f">1d60cd368</a>">1d60cd368</a><a href="https://github.com/casbin/pycasbin/commit/b37f1b61eb4a60a3b4c08b5a0896c249fc2caa0f"> into 786938821">786938821</a>

Pull Request Pull Request #210: fix: replace build_role_links with build_incremental_role_links

Run Details

16 of 23 new or added lines in 2 files covered. (69.57%)

1703 of 2025 relevant lines covered (84.1%)

10.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.09

/casbin/management_enforcer.py

from casbin.internal_enforcer import InternalEnforcer
from casbin.model.policy_op import PolicyOp


class ManagementEnforcer(InternalEnforcer):
    """
    ManagementEnforcer = InternalEnforcer + Management API.
    """

    def get_all_subjects(self):
        """gets the list of subjects that show up in the current policy."""
        return self.get_all_named_subjects("p")

    def get_all_named_subjects(self, ptype):
        """gets the list of subjects that show up in the current named policy."""
        return self.model.get_values_for_field_in_policy("p", ptype, 0)

    def get_all_objects(self):
        """gets the list of objects that show up in the current policy."""
        return self.get_all_named_objects("p")

    def get_all_named_objects(self, ptype):
        """gets the list of objects that show up in the current named policy."""
        return self.model.get_values_for_field_in_policy("p", ptype, 1)

    def get_all_actions(self):
        """gets the list of actions that show up in the current policy."""
        return self.get_all_named_actions("p")

    def get_all_named_actions(self, ptype):
        """gets the list of actions that show up in the current named policy."""
        return self.model.get_values_for_field_in_policy("p", ptype, 2)

    def get_all_roles(self):
        """gets the list of roles that show up in the current named policy."""
        return self.get_all_named_roles("g")

    def get_all_named_roles(self, ptype):
        """gets all the authorization rules in the policy."""
        return self.model.get_values_for_field_in_policy("g", ptype, 1)

    def get_policy(self):
        """gets all the authorization rules in the policy."""
        return self.get_named_policy("p")

    def get_filtered_policy(self, field_index, *field_values):
        """gets all the authorization rules in the policy, field filters can be specified."""
        return self.get_filtered_named_policy("p", field_index, *field_values)

    def get_named_policy(self, ptype):
        """gets all the authorization rules in the named policy."""
        return self.model.get_policy("p", ptype)

    def get_filtered_named_policy(self, ptype, field_index, *field_values):
        """gets all the authorization rules in the named policy, field filters can be specified."""
        return self.model.get_filtered_policy("p", ptype, field_index, *field_values)

    def get_grouping_policy(self):
        """gets all the role inheritance rules in the policy."""
        return self.get_named_grouping_policy("g")

    def get_filtered_grouping_policy(self, field_index, *field_values):
        """gets all the role inheritance rules in the policy, field filters can be specified."""
        return self.get_filtered_named_grouping_policy("g", field_index, *field_values)

    def get_named_grouping_policy(self, ptype):
        """gets all the role inheritance rules in the policy."""
        return self.model.get_policy("g", ptype)

    def get_filtered_named_grouping_policy(self, ptype, field_index, *field_values):
        """gets all the role inheritance rules in the policy, field filters can be specified."""
        return self.model.get_filtered_policy("g", ptype, field_index, *field_values)

    def has_policy(self, *params):
        """determines whether an authorization rule exists."""
        return self.has_named_policy("p", *params)

    def has_named_policy(self, ptype, *params):
        """determines whether a named authorization rule exists."""
        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            return self.model.has_policy("p", ptype, str_slice)

        return self.model.has_policy("p", ptype, list(params))

    def add_policy(self, *params):
        """adds an authorization rule to the current policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """
        return self.add_named_policy("p", *params)

    def add_policies(self, rules):
        """adds authorization rules to the current policy.

        If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
        Otherwise the function returns true for the corresponding rule by adding the new rule.
        """
        return self.add_named_policies("p", rules)

    def add_named_policy(self, ptype, *params):
        """adds an authorization rule to the current named policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """

        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_added = self._add_policy("p", ptype, str_slice)
        else:
            rule_added = self._add_policy("p", ptype, list(params))

        return rule_added

    def add_named_policies(self, ptype, rules):
        """adds authorization rules to the current named policy.

        If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
        Otherwise the function returns true for the corresponding by adding the new rule."""
        return self._add_policies("p", ptype, rules)

    def update_policy(self, old_rule, new_rule):
        """updates an authorization rule from the current policy."""
        return self.update_named_policy("p", old_rule, new_rule)

    def update_policies(self, old_rules, new_rules):
        """updates authorization rules from the current policy."""
        return self.update_named_policies("p", old_rules, new_rules)

    def update_named_policy(self, ptype, old_rule, new_rule):
        """updates an authorization rule from the current named policy."""
        return self._update_policy("p", ptype, old_rule, new_rule)

    def update_named_policies(self, ptype, old_rules, new_rules):
        """updates authorization rules from the current named policy."""
        return self._update_policies("p", ptype, old_rules, new_rules)

    def remove_policy(self, *params):
        """removes an authorization rule from the current policy."""
        return self.remove_named_policy("p", *params)

    def remove_policies(self, rules):
        """removes authorization rules from the current policy."""
        return self.remove_named_policies("p", rules)

    def remove_filtered_policy(self, field_index, *field_values):
        """removes an authorization rule from the current policy, field filters can be specified."""
        return self.remove_filtered_named_policy("p", field_index, *field_values)

    def remove_named_policy(self, ptype, *params):
        """removes an authorization rule from the current named policy."""

        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_removed = self._remove_policy("p", ptype, str_slice)
        else:
            rule_removed = self._remove_policy("p", ptype, list(params))

        return rule_removed

    def remove_named_policies(self, ptype, rules):
        """removes authorization rules from the current named policy."""
        return self._remove_policies("p", ptype, rules)

    def remove_filtered_named_policy(self, ptype, field_index, *field_values):
        """removes an authorization rule from the current named policy, field filters can be specified."""
        return self._remove_filtered_policy("p", ptype, field_index, *field_values)

    def has_grouping_policy(self, *params):
        """determines whether a role inheritance rule exists."""

        return self.has_named_grouping_policy("g", *params)

    def has_named_grouping_policy(self, ptype, *params):
        """determines whether a named role inheritance rule exists."""

        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            return self.model.has_policy("g", ptype, str_slice)

        return self.model.has_policy("g", ptype, list(params))

    def add_grouping_policy(self, *params):
        """adds a role inheritance rule to the current policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """
        return self.add_named_grouping_policy("g", *params)

    def add_grouping_policies(self, rules):
        """adds role inheritance rulea to the current policy.

        If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
        Otherwise the function returns true for the corresponding policy rule by adding the new rule.
        """
        return self.add_named_grouping_policies("g", rules)

    def add_named_grouping_policy(self, ptype, *params):
        """adds a named role inheritance rule to the current policy.

        If the rule already exists, the function returns false and the rule will not be added.
        Otherwise the function returns true by adding the new rule.
        """

        rules = []
        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_added = self._add_policy("g", ptype, str_slice)
            rules.append(str_slice)
        else:
            rule_added = self._add_policy("g", ptype, list(params))
            rules.append(list(params))

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
            )
        return rule_added

    def add_named_grouping_policies(self, ptype, rules):
        """ "adds named role inheritance rules to the current policy.

        If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
        Otherwise the function returns true for the corresponding policy rule by adding the new rule."""
        rules_added = self._add_policies("g", ptype, rules)
        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
            )

        return rules_added

    def remove_grouping_policy(self, *params):
        """removes a role inheritance rule from the current policy."""
        return self.remove_named_grouping_policy("g", *params)

    def remove_grouping_policies(self, rules):
        """removes role inheritance rulea from the current policy."""
        return self.remove_named_grouping_policies("g", rules)

    def remove_filtered_grouping_policy(self, field_index, *field_values):
        """removes a role inheritance rule from the current policy, field filters can be specified."""
        return self.remove_filtered_named_grouping_policy(
            "g", field_index, *field_values
        )

    def remove_named_grouping_policy(self, ptype, *params):
        """removes a role inheritance rule from the current named policy."""

        rules = []
        if len(params) == 1 and isinstance(params[0], list):
            str_slice = params[0]
            rule_removed = self._remove_policy("g", ptype, str_slice)
            rules.append(str_slice)
        else:
            rule_removed = self._remove_policy("g", ptype, list(params))
            rules.append(list(params))

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
            )
        return rule_removed

    def remove_named_grouping_policies(self, ptype, rules):
        """removes role inheritance rules from the current named policy."""
        rules_removed = self._remove_policies("g", ptype, rules)

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
            )

        return rules_removed

    def remove_filtered_named_grouping_policy(self, ptype, field_index, *field_values):
        """removes a role inheritance rule from the current named policy, field filters can be specified."""
        rule_removed = self._remove_filtered_policy_returns_effects(
            "g", ptype, field_index, *field_values
        )

        if self.auto_build_role_links:
            self.model.build_incremental_role_links(
                self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rule_removed
            )
        return rule_removed

    def add_function(self, name, func):
        """adds a customized function."""
        self.fm.add_function(name, func)

1	from casbin.internal_enforcer import InternalEnforcer	12✔
2	from casbin.model.policy_op import PolicyOp	12✔
3
4
5	class ManagementEnforcer(InternalEnforcer):	12✔
6	"""
7	ManagementEnforcer = InternalEnforcer + Management API.
8	"""
9
10	def get_all_subjects(self):	12✔
11	"""gets the list of subjects that show up in the current policy."""
12	return self.get_all_named_subjects("p")	12✔
13
14	def get_all_named_subjects(self, ptype):	12✔
15	"""gets the list of subjects that show up in the current named policy."""
16	return self.model.get_values_for_field_in_policy("p", ptype, 0)	12✔
17
18	def get_all_objects(self):	12✔
19	"""gets the list of objects that show up in the current policy."""
20	return self.get_all_named_objects("p")	12✔
21
22	def get_all_named_objects(self, ptype):	12✔
23	"""gets the list of objects that show up in the current named policy."""
24	return self.model.get_values_for_field_in_policy("p", ptype, 1)	12✔
25
26	def get_all_actions(self):	12✔
27	"""gets the list of actions that show up in the current policy."""
28	return self.get_all_named_actions("p")	12✔
29
30	def get_all_named_actions(self, ptype):	12✔
31	"""gets the list of actions that show up in the current named policy."""
32	return self.model.get_values_for_field_in_policy("p", ptype, 2)	12✔
33
34	def get_all_roles(self):	12✔
35	"""gets the list of roles that show up in the current named policy."""
36	return self.get_all_named_roles("g")	12✔
37
38	def get_all_named_roles(self, ptype):	12✔
39	"""gets all the authorization rules in the policy."""
40	return self.model.get_values_for_field_in_policy("g", ptype, 1)	12✔
41
42	def get_policy(self):	12✔
43	"""gets all the authorization rules in the policy."""
44	return self.get_named_policy("p")	12✔
45
46	def get_filtered_policy(self, field_index, *field_values):	12✔
47	"""gets all the authorization rules in the policy, field filters can be specified."""
48	return self.get_filtered_named_policy("p", field_index, *field_values)	12✔
49
50	def get_named_policy(self, ptype):	12✔
51	"""gets all the authorization rules in the named policy."""
52	return self.model.get_policy("p", ptype)	12✔
53
54	def get_filtered_named_policy(self, ptype, field_index, *field_values):	12✔
55	"""gets all the authorization rules in the named policy, field filters can be specified."""
56	return self.model.get_filtered_policy("p", ptype, field_index, *field_values)	12✔
57
58	def get_grouping_policy(self):	12✔
59	"""gets all the role inheritance rules in the policy."""
60	return self.get_named_grouping_policy("g")	12✔
61
62	def get_filtered_grouping_policy(self, field_index, *field_values):	12✔
63	"""gets all the role inheritance rules in the policy, field filters can be specified."""
64	return self.get_filtered_named_grouping_policy("g", field_index, *field_values)	12✔
65
66	def get_named_grouping_policy(self, ptype):	12✔
67	"""gets all the role inheritance rules in the policy."""
68	return self.model.get_policy("g", ptype)	12✔
69
70	def get_filtered_named_grouping_policy(self, ptype, field_index, *field_values):	12✔
71	"""gets all the role inheritance rules in the policy, field filters can be specified."""
72	return self.model.get_filtered_policy("g", ptype, field_index, *field_values)	12✔
73
74	def has_policy(self, *params):	12✔
75	"""determines whether an authorization rule exists."""
76	return self.has_named_policy("p", *params)	12✔
77
78	def has_named_policy(self, ptype, *params):	12✔
79	"""determines whether a named authorization rule exists."""
80	if len(params) == 1 and isinstance(params[0], list):	12✔
81	str_slice = params[0]	12✔
82	return self.model.has_policy("p", ptype, str_slice)	12✔
83
84	return self.model.has_policy("p", ptype, list(params))	×
85
86	def add_policy(self, *params):	12✔
87	"""adds an authorization rule to the current policy.
88
89	If the rule already exists, the function returns false and the rule will not be added.
90	Otherwise the function returns true by adding the new rule.
91	"""
92	return self.add_named_policy("p", *params)	12✔
93
94	def add_policies(self, rules):	12✔
95	"""adds authorization rules to the current policy.
96
97	If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
98	Otherwise the function returns true for the corresponding rule by adding the new rule.
99	"""
100	return self.add_named_policies("p", rules)	12✔
101
102	def add_named_policy(self, ptype, *params):	12✔
103	"""adds an authorization rule to the current named policy.
104
105	If the rule already exists, the function returns false and the rule will not be added.
106	Otherwise the function returns true by adding the new rule.
107	"""
108
109	if len(params) == 1 and isinstance(params[0], list):	12✔
110	str_slice = params[0]	12✔
111	rule_added = self._add_policy("p", ptype, str_slice)	12✔
112	else:
113	rule_added = self._add_policy("p", ptype, list(params))	12✔
114
115	return rule_added	12✔
116
117	def add_named_policies(self, ptype, rules):	12✔
118	"""adds authorization rules to the current named policy.
119
120	If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
121	Otherwise the function returns true for the corresponding by adding the new rule."""
122	return self._add_policies("p", ptype, rules)	12✔
123
124	def update_policy(self, old_rule, new_rule):	12✔
125	"""updates an authorization rule from the current policy."""
126	return self.update_named_policy("p", old_rule, new_rule)	×
127
128	def update_policies(self, old_rules, new_rules):	12✔
129	"""updates authorization rules from the current policy."""
130	return self.update_named_policies("p", old_rules, new_rules)	×
131
132	def update_named_policy(self, ptype, old_rule, new_rule):	12✔
133	"""updates an authorization rule from the current named policy."""
134	return self._update_policy("p", ptype, old_rule, new_rule)	×
135
136	def update_named_policies(self, ptype, old_rules, new_rules):	12✔
137	"""updates authorization rules from the current named policy."""
138	return self._update_policies("p", ptype, old_rules, new_rules)	×
139
140	def remove_policy(self, *params):	12✔
141	"""removes an authorization rule from the current policy."""
142	return self.remove_named_policy("p", *params)	12✔
143
144	def remove_policies(self, rules):	12✔
145	"""removes authorization rules from the current policy."""
146	return self.remove_named_policies("p", rules)	12✔
147
148	def remove_filtered_policy(self, field_index, *field_values):	12✔
149	"""removes an authorization rule from the current policy, field filters can be specified."""
150	return self.remove_filtered_named_policy("p", field_index, *field_values)	12✔
151
152	def remove_named_policy(self, ptype, *params):	12✔
153	"""removes an authorization rule from the current named policy."""
154
155	if len(params) == 1 and isinstance(params[0], list):	12✔
156	str_slice = params[0]	12✔
157	rule_removed = self._remove_policy("p", ptype, str_slice)	12✔
158	else:
159	rule_removed = self._remove_policy("p", ptype, list(params))	×
160
161	return rule_removed	12✔
162
163	def remove_named_policies(self, ptype, rules):	12✔
164	"""removes authorization rules from the current named policy."""
165	return self._remove_policies("p", ptype, rules)	12✔
166
167	def remove_filtered_named_policy(self, ptype, field_index, *field_values):	12✔
168	"""removes an authorization rule from the current named policy, field filters can be specified."""
169	return self._remove_filtered_policy("p", ptype, field_index, *field_values)	12✔
170
171	def has_grouping_policy(self, *params):	12✔
172	"""determines whether a role inheritance rule exists."""
173
174	return self.has_named_grouping_policy("g", *params)	12✔
175
176	def has_named_grouping_policy(self, ptype, *params):	12✔
177	"""determines whether a named role inheritance rule exists."""
178
179	if len(params) == 1 and isinstance(params[0], list):	12✔
180	str_slice = params[0]	12✔
181	return self.model.has_policy("g", ptype, str_slice)	12✔
182
183	return self.model.has_policy("g", ptype, list(params))	×
184
185	def add_grouping_policy(self, *params):	12✔
186	"""adds a role inheritance rule to the current policy.
187
188	If the rule already exists, the function returns false and the rule will not be added.
189	Otherwise the function returns true by adding the new rule.
190	"""
191	return self.add_named_grouping_policy("g", *params)	12✔
192
193	def add_grouping_policies(self, rules):	12✔
194	"""adds role inheritance rulea to the current policy.
195
196	If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
197	Otherwise the function returns true for the corresponding policy rule by adding the new rule.
198	"""
199	return self.add_named_grouping_policies("g", rules)	×
200
201	def add_named_grouping_policy(self, ptype, *params):	12✔
202	"""adds a named role inheritance rule to the current policy.
203
204	If the rule already exists, the function returns false and the rule will not be added.
205	Otherwise the function returns true by adding the new rule.
206	"""
207
208	rules = []	12✔
209	if len(params) == 1 and isinstance(params[0], list):	12✔
210	str_slice = params[0]	×
211	rule_added = self._add_policy("g", ptype, str_slice)	×
NEW 212	rules.append(str_slice)	×
213	else:
214	rule_added = self._add_policy("g", ptype, list(params))	12✔
215	rules.append(list(params))	12✔
216
217	if self.auto_build_role_links:	12✔
218	self.model.build_incremental_role_links(	12✔
219	self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
220	)
221	return rule_added	12✔
222
223	def add_named_grouping_policies(self, ptype, rules):	12✔
224	""" "adds named role inheritance rules to the current policy.
225
226	If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
227	Otherwise the function returns true for the corresponding policy rule by adding the new rule."""
228	rules_added = self._add_policies("g", ptype, rules)	×
229	if self.auto_build_role_links:	×
NEW 230	self.model.build_incremental_role_links(	×
231	self.rm_map[ptype], PolicyOp.Policy_add, "g", ptype, rules
232	)
233
234	return rules_added	×
235
236	def remove_grouping_policy(self, *params):	12✔
237	"""removes a role inheritance rule from the current policy."""
238	return self.remove_named_grouping_policy("g", *params)	12✔
239
240	def remove_grouping_policies(self, rules):	12✔
241	"""removes role inheritance rulea from the current policy."""
242	return self.remove_named_grouping_policies("g", rules)	×
243
244	def remove_filtered_grouping_policy(self, field_index, *field_values):	12✔
245	"""removes a role inheritance rule from the current policy, field filters can be specified."""
246	return self.remove_filtered_named_grouping_policy(	12✔
247	"g", field_index, *field_values
248	)
249
250	def remove_named_grouping_policy(self, ptype, *params):	12✔
251	"""removes a role inheritance rule from the current named policy."""
252
253	rules = []	12✔
254	if len(params) == 1 and isinstance(params[0], list):	12✔
255	str_slice = params[0]	×
256	rule_removed = self._remove_policy("g", ptype, str_slice)	×
NEW 257	rules.append(str_slice)	×
258	else:
259	rule_removed = self._remove_policy("g", ptype, list(params))	12✔
260	rules.append(list(params))	12✔
261
262	if self.auto_build_role_links:	12✔
263	self.model.build_incremental_role_links(	12✔
264	self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
265	)
266	return rule_removed	12✔
267
268	def remove_named_grouping_policies(self, ptype, rules):	12✔
269	"""removes role inheritance rules from the current named policy."""
270	rules_removed = self._remove_policies("g", ptype, rules)	×
271
272	if self.auto_build_role_links:	×
NEW 273	self.model.build_incremental_role_links(	×
274	self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rules
275	)
276
277	return rules_removed	×
278
279	def remove_filtered_named_grouping_policy(self, ptype, field_index, *field_values):	12✔
280	"""removes a role inheritance rule from the current named policy, field filters can be specified."""
281	rule_removed = self._remove_filtered_policy_returns_effects(	12✔
282	"g", ptype, field_index, *field_values
283	)
284
285	if self.auto_build_role_links:	12✔
286	self.model.build_incremental_role_links(	12✔
287	self.rm_map[ptype], PolicyOp.Policy_remove, "g", ptype, rule_removed
288	)
289	return rule_removed	12✔
290
291	def add_function(self, name, func):	12✔
292	"""adds a customized function."""
293	self.fm.add_function(name, func)	×

casbin / pycasbin / 1453576315

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous