Skip to content

Commit

Permalink
rename variables
Browse files Browse the repository at this point in the history
  • Loading branch information
@maximlt
maximlt committed Jun 20, 2023
1 parent e7adb2b commit 0a2a54d
Showing 1 changed file with 70 additions and 70 deletions.
140 changes: 70 additions & 70 deletions param/parameterized.py
View file
Original file line number Diff line number Diff line change
Expand Up @@ -369,7 +369,7 @@ def no_instance_params(cls):
"""
Disables instance parameters on the class
"""
cls._private._disable_instance__params = True
cls._private__param._disable_instance__params = True
return cls


Expand All @@ -392,9 +392,9 @@ def iscoroutinefunction(function):
def instance_descriptor(f):
# If parameter has an instance Parameter, delegate setting
def _f(self, obj, val):
_private = getattr(obj, '_private', None)
_instance__params = getattr(_private, '_instance__params', {})
instance_param = None if _instance__params is None else _instance__params.get(self.name)
_private__param = getattr(obj, '_private__param', None)
instance_params = getattr(_private__param, 'instance_params', {})
instance_param = None if instance_params is None else instance_params.get(self.name)
if instance_param is not None and self is not instance_param:
instance_param.__set__(obj, val)
return
Expand Down Expand Up @@ -1372,7 +1372,7 @@ def __set__(self, obj, val):
elif obj is None:
_old = self.default
self.default = val
elif not obj._private.initialized:
elif not obj._private__param.initialized:
_old = obj.__dict__.get(self._internal_name, self.default)
obj.__dict__[self._internal_name] = val
else:
Expand All @@ -1390,14 +1390,14 @@ def __set__(self, obj, val):
self._post_setter(obj, val)

if obj is not None:
if not hasattr(obj, '_private') or not getattr(obj._private, 'initialized', False):
if not hasattr(obj, '_private__param') or not getattr(obj._private__param, 'initialized', False):
return
obj.param._update_deps(self.name)

if obj is None:
watchers = self.watchers.get("value")
elif hasattr(obj, '_private') and hasattr(obj._private, '_param_watchers') and obj._private._param_watchers is not None and self.name in obj._private._param_watchers:
watchers = obj._private._param_watchers[self.name].get('value')
elif hasattr(obj, '_private__param') and hasattr(obj._private__param, 'param_watchers') and obj._private__param.param_watchers is not None and self.name in obj._private__param.param_watchers:
watchers = obj._private__param.param_watchers[self.name].get('value')
if watchers is None:
watchers = self.watchers.get("value")
else:
Expand Down Expand Up @@ -1555,10 +1555,10 @@ def as_uninitialized(fn):
@wraps(fn)
def override_initialization(self_,*args,**kw):
parameterized_instance = self_.self
original_initialized = parameterized_instance._private.initialized
parameterized_instance._private.initialized = False
original_initialized = parameterized_instance._private__param.initialized
parameterized_instance._private__param.initialized = False
fn(parameterized_instance, *args, **kw)
parameterized_instance._private.initialized = original_initialized
parameterized_instance._private__param.initialized = original_initialized
return override_initialization


Expand Down Expand Up @@ -1642,35 +1642,35 @@ def __init__(self_, cls, self=None):

@property
def _BATCH_WATCH(self_):
return self_.self_or_cls._private._parameters_state['BATCH_WATCH']
return self_.self_or_cls._private__param.parameters_state['BATCH_WATCH']

@_BATCH_WATCH.setter
def _BATCH_WATCH(self_, value):
self_.self_or_cls._private._parameters_state['BATCH_WATCH'] = value
self_.self_or_cls._private__param.parameters_state['BATCH_WATCH'] = value

@property
def _TRIGGER(self_):
return self_.self_or_cls._private._parameters_state['TRIGGER']
return self_.self_or_cls._private__param.parameters_state['TRIGGER']

@_TRIGGER.setter
def _TRIGGER(self_, value):
self_.self_or_cls._private._parameters_state['TRIGGER'] = value
self_.self_or_cls._private__param.parameters_state['TRIGGER'] = value

@property
def _events(self_):
return self_.self_or_cls._private._parameters_state['events']
return self_.self_or_cls._private__param.parameters_state['events']

@_events.setter
def _events(self_, value):
self_.self_or_cls._private._parameters_state['events'] = value
self_.self_or_cls._private__param.parameters_state['events'] = value

@property
def _watchers(self_):
return self_.self_or_cls._private._parameters_state['watchers']
return self_.self_or_cls._private__param.parameters_state['watchers']

@_watchers.setter
def _watchers(self_, value):
self_.self_or_cls._private._parameters_state['watchers'] = value
self_.self_or_cls._private__param.parameters_state['watchers'] = value

@property
def watchers(self):
Expand All @@ -1682,12 +1682,12 @@ def self_or_cls(self_):
return self_.cls if self_.self is None else self_.self

def __setstate__(self, state):
# Set old parameters state on Parameterized._parameters_state
# Set old parameters state on Parameterized.parameters_state
self_or_cls = state.get('self', state.get('cls'))
for k in self_or_cls._private._parameters_state:
for k in self_or_cls._private__param.parameters_state:
key = '_'+k
if key in state:
self_or_cls._private._parameters_state[k] = state.pop(key)
self_or_cls._private__param.parameters_state[k] = state.pop(key)
for k, v in state.items():
setattr(self, k, v)

Expand All @@ -1698,9 +1698,9 @@ def __getitem__(self_, key):
inst = self_.self
parameters = self_.objects(False) if inst is None else inst.param.objects(False)
p = parameters[key]
if (inst is not None and getattr(inst._private, 'initialized', False) and p.per_instance and
not getattr(self_.cls._private, '_disable_instance__params', False)):
if key not in inst._private._instance__params:
if (inst is not None and getattr(inst._private__param, 'initialized', False) and p.per_instance and
not getattr(self_.cls._private__param, '_disable_instance__params', False)):
if key not in inst._private__param.instance_params:
try:
# Do not copy watchers on class parameter
watchers = p.watchers
Expand All @@ -1711,9 +1711,9 @@ def __getitem__(self_, key):
finally:
p.watchers = {k: list(v) for k, v in watchers.items()}
p.owner = inst
inst._private._instance__params[key] = p
inst._private__param.instance_params[key] = p
else:
p = inst._private._instance__params[key]
p = inst._private__param.instance_params[key]
return p


Expand Down Expand Up @@ -1860,7 +1860,7 @@ def _update_deps(self_, attribute=None, init=False):
if on_init and m not in init_methods:
init_methods.append(m)
elif dynamic:
for w in obj._private._dynamic_watchers.pop(method, []):
for w in obj._private__param.dynamic_watchers.pop(method, []):
(w.inst or w.cls).param.unwatch(w)
else:
continue
Expand All @@ -1873,7 +1873,7 @@ def _update_deps(self_, attribute=None, init=False):

for group in grouped.values():
watcher = self_._watch_group(obj, method, queued, group, attribute)
obj._private._dynamic_watchers[method].append(watcher)
obj._private__param.dynamic_watchers[method].append(watcher)
for m in init_methods:
m()

Expand Down Expand Up @@ -2129,8 +2129,8 @@ def objects(self_, instance=True):

if instance and self_.self is not None:
if instance == 'existing':
if getattr(self_.self._private, 'initialized', False) and self_.self._private._instance__params:
return dict(pdict, **self_.self._private._instance__params)
if getattr(self_.self._private__param, 'initialized', False) and self_.self._private__param.instance_params:
return dict(pdict, **self_.self._private__param.instance_params)
return pdict
else:
return {k: self_.self.param[k] for k in pdict}
Expand Down Expand Up @@ -2583,7 +2583,7 @@ def _register_watcher(self_, action, watcher, what='value'):
"parameters of class {}".format(parameter_name, self_.cls.__name__))

if self_.self is not None and what == "value":
watchers = self_.self._private._param_watchers
watchers = self_.self._private__param.param_watchers
if parameter_name not in watchers:
watchers[parameter_name] = {}
if what not in watchers[parameter_name]:
Expand Down Expand Up @@ -2849,16 +2849,16 @@ def __init__(mcs, name, bases, dict_):
# Give Parameterized classes a useful 'name' attribute.
mcs.name = name

_parameters_state = {
parameters_state = {
"BATCH_WATCH": False, # If true, Event and watcher objects are queued.
"TRIGGER": False,
"events": [], # Queue of batched events
"watchers": [] # Queue of batched watchers
}
_private = _ClassPrivate(
_parameters_state=_parameters_state,
_private__param = _ClassPrivate(
parameters_state=parameters_state,
)
mcs._private = _private
mcs._private__param = _private__param
mcs._param = Parameters(mcs)

# All objects (with their names) of type Parameter that are
Expand Down Expand Up @@ -3310,42 +3310,42 @@ def wrapper(self, *args, **kwargs):
class _ClassPrivate:

__slots__ = [
'_parameters_state',
'parameters_state',
'_disable_instance__params',
]

def __init__(
self,
_parameters_state=None,
parameters_state=None,
_disable_instance__params=None,
):
self._parameters_state = _parameters_state
self.parameters_state = parameters_state
self._disable_instance__params = _disable_instance__params


class _InstancePrivate:

__slots__ = [
'initialized',
'_parameters_state',
'_dynamic_watchers',
'_instance__params',
'_param_watchers',
'parameters_state',
'dynamic_watchers',
'instance_params',
'param_watchers',
]

def __init__(
self,
initialized=None,
_parameters_state=None,
_dynamic_watchers=None,
_instance__params=None,
_param_watchers=None,
parameters_state=None,
dynamic_watchers=None,
instance_params=None,
param_watchers=None,
):
self.initialized = initialized
self._parameters_state = _parameters_state
self._dynamic_watchers = _dynamic_watchers
self._instance__params = _instance__params
self._param_watchers = _param_watchers
self.parameters_state = parameters_state
self.dynamic_watchers = dynamic_watchers
self.instance_params = instance_params
self.param_watchers = param_watchers


class Parameterized(metaclass=ParameterizedMetaclass):
Expand Down Expand Up @@ -3399,18 +3399,18 @@ def __init__(self, **params):

# Flag that can be tested to see if e.g. constant Parameters
# can still be set
_parameters_state = {
parameters_state = {
"BATCH_WATCH": False, # If true, Event and watcher objects are queued.
"TRIGGER": False,
"events": [], # Queue of batched events
"watchers": [] # Queue of batched watchers
}
self._private = _InstancePrivate(
self._private__param = _InstancePrivate(
initialized=False,
_parameters_state=_parameters_state,
_dynamic_watchers=defaultdict(list),
_instance__params={},
_param_watchers={},
parameters_state=parameters_state,
dynamic_watchers=defaultdict(list),
instance_params={},
param_watchers={},
)

self.param._generate_name()
Expand All @@ -3419,7 +3419,7 @@ def __init__(self, **params):

self.param._update_deps(init=True)

self._private.initialized = True
self._private__param.initialized = True

@property
def param(self):
Expand Down Expand Up @@ -3453,17 +3453,17 @@ def __setstate__(self, state):
During this process the object is considered uninitialized.
"""
self._private = _InstancePrivate()
self._private.initialized = False
self._private__param = _InstancePrivate()
self._private__param.initialized = False

_private = state.get('_private', None)
if _private is None:
_private = _InstancePrivate()
_private__param = state.get('_private__param', None)
if _private__param is None:
_private__param = _InstancePrivate()

# When making a copy the internal watchers have to be
# recreated and point to the new instance
if getattr(_private, '_param_watchers', None) is not None:
param_watchers = _private._param_watchers
if getattr(_private__param, 'param_watchers', None) is not None:
param_watchers = _private__param.param_watchers
for p, attrs in param_watchers.items():
for attr, watchers in attrs.items():
new_watchers = []
Expand All @@ -3479,15 +3479,15 @@ def __setstate__(self, state):
new_watchers.append(Watcher(*watcher_args))
param_watchers[p][attr] = new_watchers

if getattr(_private, '_instance__params', None) is None:
_private._instance__params = {}
if getattr(_private, '_param_watchers', None) is None:
_private._param_watchers = {}
if getattr(_private__param, 'instance_params', None) is None:
_private__param.instance_params = {}
if getattr(_private__param, 'param_watchers', None) is None:
_private__param.param_watchers = {}
state.pop('param', None)

for name,value in state.items():
setattr(self,name,value)
self._private.initialized = True
self._private__param.initialized = True

@recursive_repr()
def __repr__(self):
Expand Down

0 comments on commit 0a2a54d

Please sign in to comment.