def __add__(self, other): # => a+b
a = _copy(self.coefficients)
b = _copy(other.coefficients)
s = BinaryExtensionModuloConstructor(a ^ b)
self.xors = other.xors + self.modulodegree-1
s.xors = self.xors
return s
def _solve(solver, x0, disp=False, callback=None):
from copy import deepcopy as _copy
from mystic.tools import isNull
if x0 is not None:
solver.SetInitialPoints(x0)
if solver._useStrictRange: #XXX: always, settable, or sync'd ?
solver.SetStrictRanges(solver._strictMin,
solver._strictMax)
_term = (solver._live is False) and solver.Terminated()
if _term is True:
solver._live = True #XXX: HACK don't reset _fcalls
if solver._cost[1] is None: #XXX: HACK for configured NestedSolver
solver.SetObjective(cost, ExtraArgs=ExtraArgs)
solver.Solve(disp=disp, callback=callback)
if _term is True: solver._live = False
sm = solver._stepmon
em = solver._evalmon
if isNull(sm): sm = ([], [], [], [])
else:
sm = _copy(sm)
sm = (sm._x, sm._y, sm._id, sm._info)
if isNull(em): em = ([], [], [], [])
else:
em = _copy(em)
em = (em._x, em._y, em._id, em._info)
return solver, sm, em
def __init__(self, source, **traits):
HasTraits.__init__(self, **traits)
nTs = self.time.shape[0]
if isinstance(source, HasTraits):
self.traited = True
self.tracking = source.traits(track=True).keys()
for attr in self.tracking:
shape = (nTs,)
if type(getattr(source, attr)) is _numpy.ndarray:
shape += getattr(source, attr).shape
self.data[attr] = _numpy.zeros(shape, "d")
else:
if type(source) is type([]):
self.tracking = source
for var in source:
self.data[var] = _numpy.zeros((nTs,), "d")
self._update = _copy(source)
elif type(source) is type({}):
self.tracking = source.keys()
for var in self.tracking:
shape = (nTs,) + tuple(source[var])
self.data[var] = _numpy.zeros(shape, "d")
self._update = _copy(self.tracking)
else:
raise TypeError, self.__class__.__doc__
self.source = source
def copy(self):
temp = _copy(self)
temp.data = {}
temp.data.update(self.data)
temp.break1 = _copy(self.break1)
temp.break2 = _copy(self.break2)
return temp
def _step(solver, x0, disp=False, callback=None):
from copy import deepcopy as _copy
from mystic.tools import isNull
#ns = len(solver._stepmon)
#ne = len(solver._evalmon)
if x0 is not None:
solver.SetInitialPoints(x0)
if solver._useStrictRange: #XXX: always, settable, or sync'd ?
solver.SetStrictRanges(solver._strictMin,
solver._strictMax)
_term = (solver._live is False) and solver.Terminated()
if _term is True:
solver._live = True #XXX: HACK don't reset _fcalls
solver.Step(cost,
ExtraArgs=ExtraArgs,
disp=disp,
callback=callback)
if _term is True: solver._live = False
sm = solver._stepmon
em = solver._evalmon
if isNull(sm): sm = ([], [], [], [])
else:
sm = _copy(sm) #[ns:]
sm = (sm._x, sm._y, sm._id, sm._info)
if isNull(em): em = ([], [], [], [])
else:
em = _copy(em) #[ne:]
em = (em._x, em._y, em._id, em._info)
return solver, sm, em
def __sub__(self, other): # => a-b
# bar = -other it is itself
a = _copy(self.coefficients)
b = _copy(other.coefficients)
s = BinaryExtensionModuloConstructor(a ^ b)
self.xors = other.xors + self.modulodegree-1
s.xors = self.xors
return s
def render(model,
resolution,
cam,
steps,
center=(0, 0),
segmented=False,
use_light=False,
path_to_mesh=None): # pylint: disable=too-many-arguments
"""Render a sequence of views from a fitted body model."""
assert steps >= 1
if segmented:
texture = _os.path.join(_os.path.dirname(__file__), '..', 'models',
'3D', 'mask_filled.png')
else:
texture = _os.path.join(_os.path.dirname(__file__), '..', 'models',
'3D', 'mask_filled_uniform.png')
if path_to_mesh is None:
mesh = _copy(_TEMPLATE_MESH)
else:
mesh = _copy(_Mesh(path_to_mesh))
# render ply
model.betas[:len(cam['betas'])] = cam['betas']
model.pose[:] = cam['pose']
model.trans[:] = cam['trans']
mesh.v = model.r
w, h = resolution[0], resolution[1]
dist = _np.abs(cam['t'][2] - _np.mean(mesh.v, axis=0)[2])
rn = _create_renderer(
w=w,
h=h,
near=1.,
far=20. + dist,
rt=_np.array(cam['rt']),
t=_np.array(cam['t']),
f=_np.array([cam['f'], cam['f']]),
# c=_np.array(cam['cam_c']),
texture=texture)
light_yrot = _np.radians(120)
baked_mesh = bake_vertex_colors(mesh)
base_mesh = _copy(baked_mesh)
mesh.f = base_mesh.f
mesh.vc = base_mesh.vc
renderings = []
for angle in _np.linspace(0., 2. * (1. - 1. / steps) * _np.pi, steps):
mesh.v = _rotateY(base_mesh.v, angle)
imtmp = _simple_renderer(rn=rn,
meshes=[mesh],
yrot=light_yrot,
texture=texture,
use_light=use_light)
im = _np.zeros(h * w * 3).reshape(((h, w, 3)))
im[:h, :w, :] = imtmp * 255.
renderings.append(im)
return renderings
def _simple_renderer(rn, meshes, yrot=0, texture=None, use_light=False):
mesh = meshes[0]
if texture is not None:
if not hasattr(mesh, 'ft'):
mesh.ft = _copy(mesh.f)
vt = _copy(mesh.v[:, :2])
vt -= _np.min(vt, axis=0).reshape((1, -1))
vt /= _np.max(vt, axis=0).reshape((1, -1))
mesh.vt = vt
mesh.texture_filepath = rn.texture_image
# Set camera parameters
if texture is not None:
rn.set(v=mesh.v,
f=mesh.f,
vc=mesh.vc,
ft=mesh.ft,
vt=mesh.vt,
bgcolor=_np.ones(3))
else:
rn.set(v=mesh.v, f=mesh.f, vc=mesh.vc, bgcolor=_np.ones(3))
for next_mesh in meshes[1:]:
_stack_with(rn, next_mesh, texture)
# Construct light.
if use_light:
albedo = rn.vc
rn.vc = _odr_l.LambertianPointLight(f=rn.f,
v=rn.v,
num_verts=len(rn.v),
light_pos=_rotateY(
_np.array([-200, -100, -100]),
yrot),
vc=albedo,
light_color=_np.array([1, 1, 1]))
# Construct Left Light
rn.vc += _odr_l.LambertianPointLight(f=rn.f,
v=rn.v,
num_verts=len(rn.v),
light_pos=_rotateY(
_np.array([800, 10, 300]),
yrot),
vc=albedo,
light_color=_np.array([1, 1, 1]))
# Construct Right Light
rn.vc += _odr_l.LambertianPointLight(
f=rn.f,
v=rn.v,
num_verts=len(rn.v),
light_pos=_rotateY(_np.array([-500, 500, 1000]), yrot),
vc=albedo,
light_color=_np.array([.7, .7, .7]))
return rn.r
def simple_renderer(rn, meshes, yrot=0):
"""Create a renderer, optionally with texture."""
mesh = meshes[0]
if hasattr(rn, 'texture_image'):
if not hasattr(mesh, 'ft'):
mesh.ft = _copy(mesh.f)
vt = _copy(mesh.v[:, :2])
vt -= _np.min(vt, axis=0).reshape((1, -1))
vt /= _np.max(vt, axis=0).reshape((1, -1))
mesh.vt = vt
mesh.texture_filepath = rn.texture_image
rn.set(v=mesh.v,
f=mesh.f,
vc=mesh.vc,
ft=mesh.ft,
vt=mesh.vt,
bgcolor=_np.ones(3))
else:
rn.set(v=mesh.v, f=mesh.f, vc=mesh.vc, bgcolor=_np.ones(3))
for next_mesh in meshes[1:]:
_stack_with(rn, next_mesh) # pylint: disable=undefined-variable
albedo = rn.vc
# Construct Back Light (on back right corner)
rn.vc = _odr_l.LambertianPointLight(f=rn.f,
v=rn.v,
num_verts=len(rn.v),
light_pos=rotateY(
_np.array([-200, -100, -100]),
yrot),
vc=albedo,
light_color=_np.array([1, 1, 1]))
# Construct Left Light
rn.vc += _odr_l.LambertianPointLight(f=rn.f,
v=rn.v,
num_verts=len(rn.v),
light_pos=rotateY(
_np.array([800, 10, 300]), yrot),
vc=albedo,
light_color=_np.array([1, 1, 1]))
# Construct Right Light
rn.vc += _odr_l.LambertianPointLight(f=rn.f,
v=rn.v,
num_verts=len(rn.v),
light_pos=rotateY(
_np.array([-500, 500, 1000]),
yrot),
vc=albedo,
light_color=_np.array([.7, .7, .7]))
return rn.r
def _constructor(cls,
items=None,
copy_items=False,
deepcopy_items=False,
items_override=None,
instance_attr=None,
copy_instance_attr=False,
deepcopy_instance_attr=False,
instance_attr_override=None,
memo=None):
obj = cls.__new__(cls)
if instance_attr is not None:
if deepcopy_instance_attr:
instance_attr = _deepcopy(instance_attr, memo=memo)
elif copy_instance_attr:
instance_attr = {
name: _copy(item)
for name, item in instance_attr.items()
}
if instance_attr_override is not None:
instance_attr = instance_attr or {}
instance_attr.update(instance_attr_override)
if instance_attr:
sentinel = object()
for name in obj._all_slots:
item = instance_attr.pop(name, sentinel)
if item is not sentinel:
setattr(obj, name, item)
if hasattr(obj, '__dict__'):
obj.__dict__.update(instance_attr)
if items is not None:
if items.__class__ is not cls._base_dict:
items = cls._base_dict(items)
if deepcopy_items:
items = _deepcopy(items, memo=memo)
elif copy_items:
if cls._base_dict is dict:
items = {name: _copy(item) for name, item in items.items()}
else:
items = [(name, _copy(item))
for name, item in items.items()]
obj._base_dict_update(items)
if items_override is not None:
obj._base_dict_update(items_override)
return obj
def copy(self, recurse=False):
"""
Return a copy of the node, but not copies of children, parent,
or any attribute that is a Node.
If `recurse` is True, recursively copy child nodes.
Args:
recurse (bool): Whether or not to copy children as well as self.
Returns:
Node: A copy of self.
TODO: test this function.
RR: This function runs rather slowly -CZ
"""
newnode = Node()
for attr, value in self.__dict__.items():
if (attr not in ("children", "parent")
and not isinstance(value, Node)):
setattr(newnode, attr, _copy(value))
if recurse:
newnode.children = [
child.copy(True) for child in self.children
]
return newnode
def set(self, section, option, value=None):
"""
Sets the option value in the provided section
:param section: The section the config option is in, e.g. "main" or "s3"
:type section: str
:param option: The name of the option
:type option: str
:param value: The value to be set as the config option
:type value: Iterable (non-dict) or autoboxable to str
:raises MultipleInvalid: If the desited section and option are not valid in the cnofig Schema
"""
_ALLOWED_SCHEMA_OPTIONS = {section.schema: [option.schema for option in self._CONFIG_SCHEMA.schema[section]]
for section in self._CONFIG_SCHEMA.schema}
# If in bootstrap mode, create the options in advance of the check to see if they're in the schema. This will
# allow us to set invalid options, but they won't validate on write.
if self._bootstrap and section not in self._configuration:
self._configuration[section] = dict()
if self._bootstrap and option not in self._configuration[section]:
self._configuration[section][option] = None
allowed_option = section in _ALLOWED_SCHEMA_OPTIONS and option in _ALLOWED_SCHEMA_OPTIONS[section]
if allowed_option:
if isinstance(value, dict):
raise TypeError("Option values cannot be dictionaries")
elif isinstance(value, (list, tuple, set)):
value = ','.join(value)
self._configuration[section][option] = _copy(value)
else:
raise MultipleInvalid("Section:{} and Option:{} not valid on Config Schema".format(section, option))
def __init__(self,
name=None,
drive_uid=None,
creds=None,
aclrules=None,
cheque=None,
max_size=None,
autocreate=True):
"""Construct a handle to the drive that the passed user
calls 'name' on the passed storage service. If
'autocreate' is True and the user is logged in then
this will automatically create the drive if
it doesn't exist already
"""
self._metadata = None
self._creds = None
if creds is not None:
from Acquire.Client import StorageCreds as _StorageCreds
if not isinstance(creds, _StorageCreds):
raise TypeError("creds must be type StorageCreds")
drive = _get_drive(creds=creds,
name=name,
drive_uid=drive_uid,
aclrules=aclrules,
autocreate=autocreate)
from copy import copy as _copy
self.__dict__ = _copy(drive.__dict__)
def metadata(self):
"""Return the metadata about this drive"""
if self.is_null():
return None
else:
from copy import copy as _copy
return _copy(self._metadata)
def _clear_dirty(self):
'''
Clear the dirty flag after the value has been persisted
'''
# Make a new copy of the persisted value
self._original_value = _copy(self._variables)
self._dirty = False
def _generate_mapjob_tasks(task_prototype, param_set):
"""
Creates len(param_set) number of tasks. Each of which is a clone of
task_prototype with a different element of param_set set as its parameters.
The output of each task will be set to a temporary locations.
Returns a list of tasks. Also returns
the mapping of param values to output location.
"""
param_set = _copy(param_set)
param_set.reverse() # Preserve order; we'll be 'popping' in reverse order.
tasks = []
num_in_cur_step = 0
tasks.append([])
while param_set:
cur_params = param_set.pop()
cur_name = "-".join([task_prototype.name, str(0), str(num_in_cur_step)])
cur_task = task_prototype.clone(cur_name)
cur_task.set_inputs(cur_params)
tasks[-1].append(cur_task)
num_in_cur_step += 1
return tasks
def insert(self, first_arg, second_arg=None):
if second_arg is None:
if isinstance(first_arg, abc.Iterable):
values = list(first_arg)
if values:
self._tokenizer.reset()
for value in values:
self._tree.insert(value, None)
else:
node, inserted = self._tree.insert(first_arg, None)
if inserted:
self._tokenizer.reset()
return (set.iterator(node, self._tree,
self._tokenizer.create_weak()),
inserted)
elif isinstance(second_arg, LegacyInputIterator):
if not isinstance(first_arg, type(second_arg)):
raise TypeError('Both ends of the insertion range '
'should have same type, but found: '
'{first_type}, {last_type}.'
.format(first_type=type(first_arg),
last_type=type(second_arg)))
first = _copy(first_arg)
values = []
while first != second_arg:
values.append(first.inc().value)
if values:
self._tokenizer.reset()
for value in values:
self._tree.insert(value, None)
else:
self._tokenizer.reset()
self._tree.insert(second_arg, None)
return None
def _shallowcopy_attributes(self, dst: "BaseModel") -> None:
for attr in ["_gene", "_lineage", "_is_bulk"]:
setattr(dst, attr, _copy(getattr(self, attr)))
# user is not exposed to this
dst._obs_names = self._obs_names
# always deepcopy the model (we're manipulating it in multiple threads/processed)
dst._model = deepcopy(self.model)
def _printLen(x):
if isinstance(x, _list_iter_type):
x = list(_copy(x))
if _isNdArray(x):
print(x.shape)
else:
print(len(x))
def add_tracker(self, name):
if i != 0:
return
if name not in self.data:
self.data[name] = _numpy.empty((self.time.shape[0],), "d")
self.tracking += [name]
self._update = _copy(self.tracking)
def copy(self, recurse=True, _par=None):
"""
Return a shallow copy of self. If recurse = False, do not copy children,
parents, or any attribute that is Node.
Args:
recurse (bool): Whether or not to copy children as well as self.
Returns:
Node: A copy of self.
"""
for n in self.iternodes():
self.cached = False
newnode = Node()
for attr, value in list(self.__dict__.items()):
if (attr not in ("children", "parent")
and not isinstance(value, Node)):
setattr(newnode, attr, _copy(value))
if recurse:
newnode.children = [
child.copy(True, _par=newnode) for child in self.children
]
if _par:
newnode.parent = _par
for n in self.iternodes():
self.cached = True
newnode.set_iternode_cache()
return newnode
def copy(self, **kwargs) -> IoTyping:
x = _copy(self)
for k, v in kwargs.items():
if not hasattr(x, k):
raise AttributeError(f"No attribute {k}")
setattr(x, k, v)
return x
def _find_path(maps, path, current_state, start_state):
paths = []
# current_state could not be on maps if it only has outgoing
# transitions. i.e an initial state you are not able to return to.
if current_state not in maps:
return
for new_transition, from_states in maps[current_state]:
next_path = _copy(path)
if new_transition in path:
# Don't go in a circle
continue
next_path.insert(0, new_transition)
if start_state in from_states:
paths.append(next_path)
continue
for state in from_states:
recursive_paths = _find_path(
maps,
next_path,
state,
start_state,
)
if recursive_paths:
paths.append(recursive_paths)
return len(paths) and min(paths, key=len) or None
def find_path(maps, path, current_state, start_state):
paths = []
# current_state could not be on maps if it only has outgoing
# transitions. i.e an initial state you are not able to return to.
if current_state not in maps:
return
for new_transition, from_states in maps[current_state]:
next_path = _copy(path)
if new_transition in path:
# Don't go in a circle
continue
next_path.insert(0, new_transition)
if start_state in from_states:
paths.append(next_path)
continue
for state in from_states:
recursive_paths = find_path(
maps,
next_path,
state,
start_state,
)
if recursive_paths:
paths.append(recursive_paths)
return len(paths) and min(paths, key=len) or None
def copy(self, recurse=False):
"""
Return a copy of the node, but not copies of children, parent,
or any attribute that is a Node.
If `recurse` is True, recursively copy child nodes.
Args:
recurse (bool): Whether or not to copy children as well as self.
Returns:
Node: A copy of self.
TODO: test this function.
RR: This function runs rather slowly -CZ
"""
newnode = Node()
for attr, value in self.__dict__.items():
if (attr not in ("children", "parent") and
not isinstance(value, Node)):
setattr(newnode, attr, _copy(value))
if recurse:
newnode.children = [
child.copy(True) for child in self.children
]
return newnode
def __init__(self,
service=None,
service_url=None,
service_uid=None,
service_type=None):
"""Construct the service that is accessed at the remote
URL 'service_url'. This will fetch and return the
details of the remote service. This wrapper is a
chameleon class, and will transform into the
class type of the fetched service, e.g.
service = Acquire.Client.Service("https://identity_service_url")
service.__class__ == Acquire.Identity.IdentityService
"""
if service is not None:
from Acquire.Service import Service as _Service
service = _Service.resolve(service, fetch=True)["service"]
else:
try:
from Acquire.Client import Wallet as _Wallet
service = _Wallet().get_service(service_url=service_url,
service_uid=service_uid,
service_type=service_type)
except Exception as e:
self._failed = True
raise e
from copy import copy as _copy
self.__dict__ = _copy(service.__dict__)
self.__class__ = service.__class__
def addWatchPoint(cls, f, arg):
""" watch the name of point in nearest namespace,
for example: if namespace A, B both have var a, the watch pointer may attach to A.a or B.a"""
try:
_value = eval(arg, f.f_locals, f.f_globals)
astT = _ast.parse(arg)
_id = cls._getId(astT)
sys.stdout.write("%s %s" % (repr(_value), repr(_id)))
if _id == 'error':
raise NoThisVarError
while f:
if f.f_locals.has_key(_id) or f.f_globals.has_key(_id):
wd = f.f_locals if f.f_locals.has_key(_id) else f.f_globals
cls._watchPList.append(
[_copy(wd), _id, _value, arg,
id(f)])
sys.stdout.write("Succ to Add Watch Point")
sys.stdout.write('\n')
wd = None
return
f = f.f_back
raise NotFoundError
except Exception as e:
sys.stdout.write("Failed to Add Watch Point for %s" % repr(e))
sys.stdout.write('\n')
def insert(self,
position: const_iterator,
second_arg,
third_arg=None) -> None:
index = position._index
if third_arg is None:
if isinstance(second_arg, abc.Iterable):
values = list(second_arg)
if values:
self._tokenizer.reset()
self._values[index:index] = second_arg
else:
self._tokenizer.reset()
self._values.insert(index, second_arg)
elif isinstance(second_arg, int):
if second_arg < 0:
raise ValueError(
'`count` should be positive, but found {}.'.format(
second_arg))
if second_arg:
self._tokenizer.reset()
self._values[index:index] = repeat(third_arg, second_arg)
else:
first = _copy(second_arg)
values = []
while first != third_arg:
values.append(first.inc().value)
if values:
self._tokenizer.reset()
self._values[index:index] = values
def TEflagedges(data,altpaths,edges_orig,sgncmb_enum,**kwargs):
data=_copy(data)
N=size(altpaths,1)
flag_list=m_array([cell2mat(altpaths[:,1-1:3+1-1]),2*ones(N,1)]).reshape(1,-1)
for i in arange(1,N+1).reshape(1,-1).flat:
new_edge_ind=edges_orig[altpaths[i-1,1-1]-1,:]
flag_list[i-1,1-1]=find(sgncmb_enum[:,1-1]==new_edge_ind[int(1-1)]&sgncmb_enum[:,2-1]==new_edge_ind[int(2-1)])
no_triangles=0
for j in arange(1,length(altpaths[i-1,5-1][1-1])+1).reshape(1,-1).flat:
if (length(altpaths[i-1,5-1][1-1][j-1])==3):
no_triangles=no_triangles+1
new_edge=m_array([altpaths[i-1,5-1][1-1][j-1][int(altpaths[i-1,5-1][1-1][j-1].shape[0]-1-1)],altpaths[i-1,5-1][1-1][j-1][int(altpaths[i-1,5-1][1-1][j-1].shape[0]-1)]]).reshape(1,-1)
new_edge_ind=edges_orig[edges_orig[:,1-1]==new_edge[int(1-1)]&edges_orig[:,2-1]==new_edge[int(2-1)],:]
new_edge_ind=find(sgncmb_enum[:,1-1]==new_edge_ind[int(1-1)]&sgncmb_enum[:,2-1]==new_edge_ind[int(2-1)])
flag_list=cat(1,flag_list,m_array([new_edge_ind,new_edge,4]).reshape(1,-1))
flag_list[i-1,4-1]=3
disp(m_array([num2str(no_triangles),' triangle(s) were found by TEflagedges.']).reshape(1,-1))
duplicates=m_array()
for i in arange(1,size(flag_list,1)+1).reshape(1,-1).flat:
ind=flag_list[i-1,1-1]==flag_list[i+1-1:flag_list.shape[0]+1-1,1-1]
if (sum(ind)>0):
ind=find(ind)+i
duplicates=m_array([[duplicates],[ind]]).reshape(1,-1)
flag_list[duplicates-1,:]=m_array()
data.n_spuriousedges=size(flag_list,1)
for i in arange(1,size(flag_list,1)+1).reshape(1,-1).flat:
if isnan(data.TEpermvalues[flag_list[i-1,1-1]-1,4-1]):
warning('This edge has already been flagged!')
ind=flag_list[i-1,1-1]
data.TEpermvalues[ind-1,:]=m_array([1,0,0,NaN(),flag_list[i-1,4-1],0]).reshape(1,-1)
return data
def addWatchPoint(cls, f, arg):
""" watch the name of point in nearest namespace,
for example: if namespace A, B both have var a, the watch pointer may attach to A.a or B.a"""
try:
_value = eval(arg, f.f_locals, f.f_globals)
astT = _ast.parse(arg)
_id = cls._getId(astT)
sys.stdout.write("%s %s" % (repr(_value), repr(_id)))
if _id == 'error':
raise NoThisVarError
while f:
if f.f_locals.has_key(_id) or f.f_globals.has_key(_id):
wd = f.f_locals if f.f_locals.has_key(_id) else f.f_globals
cls._watchPList.append([_copy(wd) , _id, _value, arg, id(f)])
sys.stdout.write("Succ to Add Watch Point")
sys.stdout.write('\n')
wd = None
return
f = f.f_back
raise NotFoundError
except Exception as e:
sys.stdout.write("Failed to Add Watch Point for %s"
% repr(e))
sys.stdout.write('\n')
def __setup(self):
"""Construct the series of shell commands, i.e., fill in
self.__commands"""
# Create a copy of the toolchain so that it can be modified
# without impacting the original.
toolchain = _copy(self.__toolchain)
# Need to tell it where to find HDF5
if not toolchain.CPPFLAGS:
toolchain.CPPFLAGS = '-I{}/include'.format(self.__hdf5_dir)
if not toolchain.LDFLAGS:
toolchain.LDFLAGS = '-L{}/lib'.format(self.__hdf5_dir)
# Version 4.7.0 changed the package name
if LooseVersion(self.__version) >= LooseVersion('4.7.0'):
pkgname = 'netcdf-c'
else:
pkgname = 'netcdf'
tarball = '{0}-{1}.tar.gz'.format(pkgname, self.__version)
url = '{0}/{1}'.format(self.__baseurl, tarball)
# Download source from web
self.__commands.append(self.download_step(url=url,
directory=self.__wd))
self.__commands.append(
self.untar_step(tarball=posixpath.join(self.__wd, tarball),
directory=self.__wd))
self.__commands.append(
self.configure_step(directory=posixpath.join(
self.__wd, '{0}-{1}'.format(pkgname, self.__version)),
toolchain=toolchain))
self.__commands.append(self.build_step())
# Check the build
if self.__check:
self.__commands.append(self.check_step())
self.__commands.append(self.install_step())
# Set library path
libpath = posixpath.join(self.prefix, 'lib')
if self.ldconfig:
self.__commands.append(self.ldcache_step(directory=libpath))
else:
self.environment_variables[
'LD_LIBRARY_PATH'] = '{}:$LD_LIBRARY_PATH'.format(libpath)
self.__commands.append(
self.cleanup_step(items=[
posixpath.join(self.__wd, tarball),
posixpath.join(self.__wd, '{0}-{1}'.format(
pkgname, self.__version))
]))
# Set the environment
self.environment_variables['PATH'] = '{}:$PATH'.format(
posixpath.join(self.prefix, 'bin'))
def _xkwds(kwds, **dflts): # PYCHOK expected
'''(INTERNAL) Override C{dflts} with specified C{kwds}.
'''
d = dflts
if kwds:
d = _copy(d)
d.update(kwds)
return d
def row2feature(row, id_field, geometry_field):
feature = {'type': 'Feature', 'properties': _copy(row)}
geometry = feature['properties'].pop(geometry_field)
feature['geometry'] = _loadshape(_unhexlify(geometry))
feature['id'] = feature['properties'].pop(id_field)
return feature
def _xkwds(kwds, **dflts):
'''(INTERNAL) Override C{dflts} with C{kwds}.
'''
d = dflts
if kwds:
d = _copy(d)
d.update(kwds)
return d
def row2feature(row, id_field, geometry_field):
feature = {'type': 'Feature', 'properties': _copy(row)}
geometry = feature['properties'].pop(geometry_field)
feature['geometry'] = _loadshape(_unhexlify(geometry))
feature['id'] = feature['properties'].pop(id_field)
return feature
def _save_state_to_s3(self):
# Dump immutable state data to a config
state = _ConfigParser(allow_no_value=True)
state.optionxform = str
state.add_section(PredictiveService._SERVICE_INFO_SECTION_NAME)
state.set(PredictiveService._SERVICE_INFO_SECTION_NAME, 'Name', self.name)
state.set(PredictiveService._SERVICE_INFO_SECTION_NAME, 'Description', self._description)
state.set(PredictiveService._SERVICE_INFO_SECTION_NAME, 'API Key', self._api_key)
# Save environment, if we have one
if self._environment:
state.add_section(PredictiveService._ENVIRONMENT_SECTION_NAME)
for (key, value) in self._environment._get_state().iteritems():
state.set(PredictiveService._ENVIRONMENT_SECTION_NAME, key, value)
# Save deployment version data to config
state.add_section(PredictiveService._DEPLOYMENT_SECTION_NAME)
current_predictive_objects = _copy(self._all_predictive_objects)
for (model_name, info) in current_predictive_objects.iteritems():
state.set(PredictiveService._DEPLOYMENT_SECTION_NAME, model_name, info['version'])
state.add_section(PredictiveService._PREDICTIVE_OBJECT_DOCSTRING)
for (model_name, info) in current_predictive_objects.iteritems():
state.set(PredictiveService._PREDICTIVE_OBJECT_DOCSTRING, model_name, info['docstring'].encode('string_escape'))
if self._has_state_changed_on_s3():
raise IOError("Can not save changes. The Predictive Service has changed on S3. Please "
"reload from S3.")
# Save any new predictive objects to S3.
for predictive_object_name in self._local_changes:
(predictive_object, po_info) = self._local_changes[predictive_object_name]
if predictive_object: # if this is not a model deletion:
save_path = self._get_predictive_object_save_path(predictive_object_name, po_info['version'])
dependency_path = self._get_dependency_save_path(predictive_object_name, po_info['version'])
predictive_object.save(save_path, dependency_path, self.aws_credentials)
# Update the revision number after we have successfully written all predictive objects
self._revision_number += 1
state.add_section(self._META_SECTION_NAME)
state.set(self._META_SECTION_NAME, 'Revision Number', self._revision_number)
state.set(self._META_SECTION_NAME, 'Schema Version', self._schema_version)
# Write state file to S3
with _NamedTemporaryFile() as temp_file:
state.write(temp_file)
temp_file.flush()
conn = _connect_s3(**self.aws_credentials)
bucket = conn.get_bucket(self._s3_bucket_name, validate=False)
key = _s3_key(bucket)
key.key = self._s3_state_key
key.set_contents_from_filename(temp_file.name)
temp_file.close() # deletes temp file
# Update our state
self._local_changes = {}
self._predictive_objects = dict(zip(current_predictive_objects.keys(),
[{'version':info['version'], 'docstring': info['docstring']} for info in current_predictive_objects.values()]))
def copy(self):
'''
make a copy of this image
'''
from copy import copy as _copy
data = self.data.copy()
copied = EMImage(data, mmap=self._mmap, mode=self._mmap_mode)
copied.headers = _copy(self.headers)
return copied
def copy(self, deep=True): # pylint:disable=overridden-final-method
"""Perform a pandas deep copy of the ELPDData plus a copy of the stored data."""
copied_obj = pd.Series.copy(self)
for key in copied_obj.keys():
if deep:
copied_obj[key] = _deepcopy(copied_obj[key])
else:
copied_obj[key] = _copy(copied_obj[key])
return ELPDData(copied_obj)
def __mul__(self, other): # => a*b
'''
'''
if type(other) == int: # a * n = [a, a,..., a]
res = []
for i in range(other):
res.append(_deepcopy(self))
return res
a = _copy(self._coefficients)
b = _copy(other._coefficients)
res = self.__multiply__(a, b)
self._debug_stream("c = a * b = %s * %s = %s"
% (self.__interpretToStr__(a),
self.__interpretToStr__(b),
self.__interpretToStr__(res)))
p = BinaryExtensionModuloConstructor(res)
p.xors = self.xors
return p
def column(self, idx):
"""
range with given col of current range
:param idx: indexing is 1-based, negative indices start from last col
:return: new range object
"""
coords = _a2cr(self.address)
if len(coords) == 2:
return _copy(self)
else:
newcoords = _copy(coords)
if idx < 0:
newcoords[0] = newcoords[2] + idx + 1
else:
newcoords[0] += idx - 1
newcoords[2] = newcoords[0]
newaddr = _cr2a(*newcoords)
return Rng(address=newaddr, sheet=self.sheet)
def __pow__(self, degree):
new_unit = _copy(self)
new_unit.value **= degree
new_unit.units = dict([(k, v * degree)
for k, v in new_unit.units.items()])
return new_unit
def copy(self, deep=True):
"""Perform a pandas deep copy of the ELPDData plus a copy of the stored data."""
copied_obj = pd.Series.copy(self)
for key in copied_obj.keys():
if deep:
copied_obj[key] = _deepcopy(copied_obj[key])
else:
copied_obj[key] = _copy(copied_obj[key])
return ELPDData(copied_obj)
def _start_commander_host(env_name, config, s3_folder_path, num_hosts, additional_packages,
idle_shutdown_timeout):
@_file_util.retry(tries=240, delay=2, retry_exception=_requests.exceptions.ConnectionError)
def _wait_for_host_to_start_up():
response = _requests.get("http://%s:9004/ping" % commander.public_dns_name)
if not response:
raise RuntimeError()
credentials = config.get_credentials()
# Set user data for cluster controller
num_children = num_hosts - 1
user_data = {
'auth_token': '', 'AWS_ACCESS_KEY_ID': credentials['aws_access_key_id'],
'AWS_SECRET_ACCESS_KEY': credentials['aws_secret_access_key'], 'daemon': True,
'is_cluster_controller': True, 'num_children_host': num_children,
's3_folder_path': s3_folder_path, 'additional_packages': additional_packages,
'idle_shutdown_timeout': idle_shutdown_timeout
}
# Propagating debug environment variables to user data
if('GRAPHLAB_TEST_AMI_ID' in _os.environ and 'GRAPHLAB_TEST_ENGINE_URL' in _os.environ
and 'GRAPHLAB_TEST_OS_URL' in _os.environ and 'GRAPHLAB_TEST_HASH_KEY' in _os.environ):
user_data['GRAPHLAB_TEST_AMI_ID'] = _os.environ['GRAPHLAB_TEST_AMI_ID']
user_data['GRAPHLAB_TEST_ENGINE_URL'] = _os.environ['GRAPHLAB_TEST_ENGINE_URL']
user_data['GRAPHLAB_TEST_OS_URL'] = _os.environ['GRAPHLAB_TEST_OS_URL']
user_data['GRAPHLAB_TEST_HASH_KEY'] = _os.environ['GRAPHLAB_TEST_HASH_KEY']
if('GRAPHLAB_TEST_EC2_KEYPAIR' in _os.environ):
user_data['GRAPHLAB_TEST_EC2_KEYPAIR'] = _os.environ['GRAPHLAB_TEST_EC2_KEYPAIR']
# Launch the cluster controller
tags = _copy(config.tags)
tags['Name'] = env_name
commander, security_group, subnet_id = _ec2_factory(config.instance_type, region = config.region,
CIDR_rule = config.cidr_ip,
security_group_name = config.security_group,
tags = tags, user_data = user_data,
credentials = credentials,
product_type = _ProductType.DatoDistributed)
# Log message explaining the additional hosts will not be launched by us.
if num_children == 1:
__LOGGER__.info("One additional host will be launched by %s" % commander.instance_id)
elif num_children > 1:
__LOGGER__.info("%d additional hosts will be launched by %s"
% (num_children, commander.instance_id))
# Wait for cluster_controller_daemon
__LOGGER__.info("Waiting for %s to start up." % commander.instance_id)
try:
_wait_for_host_to_start_up()
except:
raise RuntimeError('Unable to start host(s). Please terminate '
'manually from the AWS console.')
return commander.public_dns_name
def _xcopy(inst, deep=False):
'''(INTERNAL) Copy an object, shallow or deep.
@arg inst: The object to copy (any C{type}).
@kwarg deep: If C{True} make a deep, otherwise
a shallow copy (C{bool}).
@return: The copy of B{C{inst}}.
'''
return _deepcopy(inst) if deep else _copy(inst)
def row2feature(row, id_field, geometry_field):
""" Convert a database row dict to a feature dict.
"""
feature = {'type': 'Feature', 'properties': _copy(row)}
geometry = feature['properties'].pop(geometry_field)
feature['geometry'] = _loadshape(_unhexlify(geometry))
feature['id'] = feature['properties'].pop(id_field)
return feature
def get_models(self):
'''
Return a list of models that are served by this policy
Returns
--------
models : list[str]
A list of models that are served by this policy
'''
return _copy(self._models)
def __init__(self, other=None):
if isinstance(other, _Service):
self.__dict__ = _copy(other.__dict__)
if not self.is_accounting_service():
raise AccountingServiceError(
"Cannot construct an AccountingService from "
"a service which is not an accounting service!")
else:
_Service.__init__(self)
def _solve(solver, x0, disp=False, callback=None):
from copy import deepcopy as _copy
from mystic.tools import isNull
if x0 is not None:
solver.SetInitialPoints(x0)
if solver._useStrictRange: #XXX: always, settable, or sync'd ?
solver.SetStrictRanges(solver._strictMin,solver._strictMax)
solver.Solve(cost,ExtraArgs=ExtraArgs,disp=disp,callback=callback)
sm = solver._stepmon
em = solver._evalmon
if isNull(sm): sm = ([],[],[],[])
else:
sm = _copy(sm)
sm = (sm._x,sm._y,sm._id,sm._info)
if isNull(em): em = ([],[],[],[])
else:
em = _copy(em)
em = (em._x,em._y,em._id,em._info)
return solver, sm, em
def semilogypn(x,y,specpos,specneg,varargin,**kwargs):
error(nargchk(1,inf(),nargin()))
if nargin()<2:
y=x
x=arange(1,length(y)+1).reshape(1,-1)
if nargin()<3:
specpos='b-'
specneg='b--'
else:
if nargin()<4:
if findstr(specpos,'--'):
specneg=strrep(specpos,'--','-')
else:
specneg=specpos
specneg=strrep(specneg,'-.','')
specneg=strrep(specneg,':','')
specneg=strrep(specneg,'-','')
specneg=m_array([specneg,'--']).reshape(1,-1)
indpos=find(y>0)
indneg=find(y<0)
ypos=_copy(y)
ypos[int(indneg-1)]=0
yneg=_copy(y)
yneg[int(indpos-1)]=0
if isempty(indneg) and not isempty(indpos):
hp=semilogy(x,ypos,specpos,varargin[:])
hn=m_array()
else:
if not isempty(indneg) and isempty(indpos):
hp=m_array()
hn=semilogy(x,-yneg,specneg,varargin[:])
else:
statehold=ishold()
hp=semilogy(x,ypos,specpos,varargin[:])
hold('on')
hn=semilogy(x,-yneg,specneg,varargin[:])
if statehold==false():
hold('off')
if not nargout():
clear('hp','hn')
return hp,hn
def _preprocess(self, data):
"""
Internal function to perform fit_transform() on all but last step.
"""
transformed_data = _copy(data)
for name, step in self._transformers[:-1]:
transformed_data = step.fit_transform(transformed_data)
if type(transformed_data) != _gl.SFrame:
raise RuntimeError("The transform function in step '%s' did not"
" return an SFrame (got %s instead)." % (name,
type(transformed_data).__name__))
return transformed_data
def variables(self):
"""Getter for variables.
The specified variables including the new computer variables and
between subject variables and added variables.
"""
variables = _copy(self._variables)
variables.extend(self._subject_variables)
variables.extend(self._added_variables)
return variables
def array(element, count):
"""Creates an array.
The array is initialized with the value of ``element`` repeated ``count``
times. Elements can be read and written using the regular Python index
syntax.
For static compilation, ``count`` must be a fixed integer.
Arrays of arrays are supported.
"""
return [_copy(element) for i in range(count)]
def _solve(self, id=None, disp=None):
from copy import deepcopy as _copy
solver = _copy(self.solver) #FIXME: python2.6
# configure solver
solver.id = id
model = solver._cost[1] #FIXME: HACK b/c Solve(model) is required
# solve
disp = self.disp if disp is None else disp
# import time
# start = time.time()
solver.Solve(model, disp=disp)
# print "TOOK: %s" % (time.time() - start)
return solver
def _advance(self):
if self.traited:
for key in self.tracking:
self.data[key][self.i] = getattr(self.source, key)
else:
if self.i:
for key in self._update:
self.data[key][self.i] = self.data[key][self.i - 1]
self._update = _copy(self.tracking)
if self.i + 1 == self.time.shape[0]:
self.finish()
else:
self.i += 1
self.t = self.time[self.i]
def TEdfs_rec(source,target,adjacency_list,visited,bool,**kwargs):
visited=_copy(visited)
if source==target:
bool=1
return bool
else:
for i in arange(1,size(adjacency_list[source-1],2)+1).reshape(1,-1).flat:
if visited[int(adjacency_list[source-1][1-1,i-1]-1)]==0:
new_source=adjacency_list[source-1][1-1,i-1]
visited[int(new_source-1)]=1
bool=TEdfs_rec(new_source,target,adjacency_list,visited,bool)
if logical(bool):
return bool
return bool
def local_optimize(solver, x0, rank=None, disp=False, callback=None):
from copy import deepcopy as _copy
from mystic.tools import isNull
solver.id = rank
solver.SetInitialPoints(x0)
if solver._useStrictRange: #XXX: always, settable, or sync'd ?
solver.SetStrictRanges(min=solver._strictMin, \
max=solver._strictMax) # or lower,upper ?
solver.Solve(cost, disp=disp, callback=callback)
sm = solver._stepmon
em = solver._evalmon
if isNull(sm): sm = ([],[],[],[])
else: sm = (_copy(sm._x),_copy(sm._y),_copy(sm._id),_copy(sm._info))
if isNull(em): em = ([],[],[],[])
else: em = (_copy(em._x),_copy(em._y),_copy(em._id),_copy(em._info))
return solver, sm, em
def from_parameterset(cls, params, copy=False):
"""
Instantiates a CharmmParameterSet from another ParameterSet (or
subclass). The main thing this feature is responsible for is converting
lower-case atom type names into all upper-case and decorating the name
to ensure each atom type name is unique.
Parameters
----------
params : :class:`parmed.parameters.ParameterSet`
ParameterSet containing the list of parameters to be converted to a
CHARMM-compatible set
copy : bool, optional
If True, the returned parameter set is a deep copy of ``params``. If
False, the returned parameter set is a shallow copy. Default False.
Returns
-------
new_params : OpenMMParameterSet
OpenMMParameterSet with the same parameters as that defined in the
input parameter set
"""
new_params = cls()
if copy:
# Make a copy so we don't modify the original
params = _copy(params)
new_params.atom_types = new_params.atom_types_str = params.atom_types
new_params.atom_types_int = params.atom_types_int
new_params.atom_types_tuple = params.atom_types_tuple
new_params.bond_types = params.bond_types
new_params.angle_types = params.angle_types
new_params.urey_bradley_types = params.urey_bradley_types
new_params.dihedral_types = params.dihedral_types
new_params.improper_types = params.improper_types
new_params.improper_periodic_types = params.improper_periodic_types
new_params.rb_torsion_types = params.rb_torsion_types
new_params.cmap_types = params.cmap_types
new_params.nbfix_types = params.nbfix_types
new_params.pair_types = params.pair_types
new_params.parametersets = params.parametersets
new_params._combining_rule = params.combining_rule
new_params.default_scee = params.default_scee
new_params.default_scnb = params.default_scnb
# add only ResidueTemplate instances (no ResidueTemplateContainers)
for name, residue in iteritems(params.residues):
if isinstance(residue, ResidueTemplate):
new_params.residues[name] = residue
return new_params
def __init_allSolvers(self):
'populate NestedSolver state to allSolvers'
# get the nested solver instance
solver = self._AbstractEnsembleSolver__get_solver_instance()
# configure inputs for each solver
from copy import deepcopy as _copy
at = self.id if self.id else 0 #XXX start at self.id?
#at = max((getattr(i, 'id', self.id) or 0) for i in self._allSolvers)
for i,op in enumerate(self._allSolvers):
if op is None: #XXX: don't reset existing solvers?
op = _copy(solver)
op.id = i
self._allSolvers[i] = op
return self._allSolvers
def __call__(self, device): assert not hasattr(self, '_value') assert self.device_kind is None or device.kind in self.device_kind p = device.protocol if p == 1.0: # HID++ 1.0 devices do not support features assert self._rw.kind == RegisterRW.kind elif p >= 2.0: # HID++ 2.0 devices do not support registers assert self._rw.kind == FeatureRW.kind o = _copy(self) o._value = None o._device = device return o
def setOpts(defaults,options,**kwargs):
if nargin()==1 or isempty(options):
user_fields=m_array()
else:
if isstruct(options):
user_fields=fieldnames(options)
else:
user_fields=options[1-1:2:options.shape[0]+1-1]
options=struct(options[:])
if isstruct(defaults):
params=_copy(defaults)
else:
params=struct(defaults[:])
for k in arange(1,length(user_fields)+1).reshape(1,-1).flat:
setfield(params,user_fields[k-1],getfield(options,user_fields[k-1]))
return params
