text_prompt
stringlengths 157
13.1k
| code_prompt
stringlengths 7
19.8k
⌀ |
|---|---|
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def flatten(nested):
""" Return a flatten version of the nested argument """ |
flat_return = list()
def __inner_flat(nested,flat):
for i in nested:
__inner_flat(i, flat) if isinstance(i, list) else flat.append(i)
return flat
__inner_flat(nested,flat_return)
return flat_return |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def dict_array_bytes(ary, template):
""" Return the number of bytes required by an array Arguments ary : dict Dictionary representation of an array template : dict A dictionary of key-values, used to replace any string values in the array with concrete integral values Returns The number of bytes required to represent the array. """ |
shape = shape_from_str_tuple(ary['shape'], template)
dtype = dtype_from_str(ary['dtype'], template)
return array_bytes(shape, dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def dict_array_bytes_required(arrays, template):
""" Return the number of bytes required by a dictionary of arrays. Arguments arrays : list A list of dictionaries defining the arrays template : dict A dictionary of key-values, used to replace any string values in the arrays with concrete integral values Returns The number of bytes required to represent all the arrays. """ |
return np.sum([dict_array_bytes(ary, template)
for ary in arrays]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def viable_dim_config(bytes_available, arrays, template, dim_ord, nsolvers=1):
""" Returns the number of timesteps possible, given the registered arrays and a memory budget defined by bytes_available Arguments bytes_available : int The memory budget, or available number of bytes for solving the problem. arrays : list List of dictionaries describing the arrays template : dict Dictionary containing key-values that will be used to replace any string representations of dimensions and types. slvr.template_dict() will return something suitable. dim_ord : list list of dimension string names that the problem should be subdivided by. e.g. ['ntime', 'nbl', 'nchan']. Multple dimensions can be reduced simultaneously using the following syntax 'nbl&na'. This is mostly useful for the baseline-antenna equivalence. nsolvers : int Number of solvers to budget for. Defaults to one. Returns A tuple (boolean, dict). The boolean is True if the problem can fit within the supplied budget, False otherwise. THe dictionary contains the reduced dimensions as key and the reduced size as value. e.g. (True, { 'time' : 1, 'nbl' : 1 }) For a dim_ord = ['ntime', 'nbl', 'nchan'], this method will try and fit a ntime x nbl x nchan problem into the available number of bytes. If this is not possible, it will first set ntime=1, and then try fit an 1 x nbl x nchan problem into the budget, then a 1 x 1 x nchan problem. One can specify reductions for specific dimensions. For e.g. ['ntime=20', 'nbl=1&na=2', 'nchan=50%'] will reduce ntime to 20, but no lower. nbl=1&na=2 sets both nbl and na to 1 and 2 in the same operation respectively. nchan=50\% will continuously halve the nchan dimension until it reaches a value of 1. """ |
if not isinstance(dim_ord, list):
raise TypeError('dim_ord should be a list')
# Don't accept non-negative memory budgets
if bytes_available < 0:
bytes_available = 0
modified_dims = {}
T = template.copy()
bytes_used = dict_array_bytes_required(arrays, T)*nsolvers
# While more bytes are used than are available, set
# dimensions to one in the order specified by the
# dim_ord argument.
while bytes_used > bytes_available:
try:
dims = dim_ord.pop(0)
montblanc.log.debug('Applying reduction {s}. '
'Bytes available: {a} used: {u}'.format(
s=dims,
a=fmt_bytes(bytes_available),
u=fmt_bytes(bytes_used)))
dims = dims.strip().split('&')
except IndexError:
# No more dimensions available for reducing
# the problem size. Unable to fit the problem
# within the specified memory budget
return False, modified_dims
# Can't fit everything into memory,
# Lower dimensions and re-evaluate
for dim in dims:
match = re.match(__DIM_REDUCTION_RE, dim)
if not match:
raise ValueError(
"{d} is an invalid dimension reduction string "
"Valid strings are for e.g. "
"'ntime', 'ntime=20' or 'ntime=20%'"
.format(d=dim))
dim_name = match.group('name')
dim_value = match.group('value')
dim_percent = match.group('percent')
dim_value = 1 if dim_value is None else int(dim_value)
# Attempt reduction by a percentage
if dim_percent == '%':
dim_value = int(T[dim_name] * int(dim_value) / 100.0)
if dim_value < 1:
# This can't be reduced any further
dim_value = 1
else:
# Allows another attempt at reduction
# by percentage on this dimension
dim_ord.insert(0, dim)
# Apply the dimension reduction
if T[dim_name] > dim_value:
modified_dims[dim_name] = dim_value
T[dim_name] = dim_value
else:
montblanc.log.info(('Ignored reduction of {d} '
'of size {s} to {v}. ').format(
d=dim_name, s=T[dim_name], v=dim_value))
bytes_used = dict_array_bytes_required(arrays, T)*nsolvers
return True, modified_dims |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def shape_from_str_tuple(sshape, variables, ignore=None):
""" Substitutes string values in the supplied shape parameter with integer variables stored in a dictionary Parameters sshape : tuple/string composed of integers and strings. The strings should related to integral properties registered with this Solver object variables : dictionary Keys with associated integer values. Used to replace string values within the tuple ignore : list A list of tuple strings to ignore (4, 3) """ |
if ignore is None: ignore = []
if not isinstance(sshape, tuple) and not isinstance(sshape, list):
raise TypeError, 'sshape argument must be a tuple or list'
if not isinstance(ignore, list):
raise TypeError, 'ignore argument must be a list'
return tuple([int(eval_expr(v,variables)) if isinstance(v,str) else int(v)
for v in sshape if v not in ignore]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def shape_list(l,shape,dtype):
""" Shape a list of lists into the appropriate shape and data type """ |
return np.array(l, dtype=dtype).reshape(shape) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def array_convert_function(sshape_one, sshape_two, variables):
""" Return a function defining the conversion process between two NumPy arrays of different shapes """ |
if not isinstance(sshape_one, tuple): sshape_one = (sshape_one,)
if not isinstance(sshape_two, tuple): sshape_two = (sshape_two,)
s_one = flatten([eval_expr_names_and_nrs(d) if isinstance(d,str) else d
for d in sshape_one])
s_two = flatten([eval_expr_names_and_nrs(d) if isinstance(d,str) else d
for d in sshape_two])
if len(s_one) != len(s_two):
raise ValueError, ('Flattened shapes %s and %s '\
'do not have the same length. '
'Original shapes were %s and %s') % \
(s_one, s_two, sshape_one, sshape_two)
# Reason about the transpose
t_idx = tuple([s_one.index(v) for v in s_two])
# Figure out the actual numeric shape values to use
n_one = shape_from_str_tuple(s_one, variables)
n_two = [eval_expr(d,variables)
if isinstance(d,str) else d for d in sshape_two]
def f(ary): return np.reshape(ary, n_one).transpose(t_idx).reshape(n_two)
return f |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def redistribute_threads(blockdimx, blockdimy, blockdimz, dimx, dimy, dimz):
""" Redistribute threads from the Z dimension towards the X dimension. Also clamp number of threads to the problem dimension size, if necessary """ |
# Shift threads from the z dimension
# into the y dimension
while blockdimz > dimz:
tmp = blockdimz // 2
if tmp < dimz:
break
blockdimy *= 2
blockdimz = tmp
# Shift threads from the y dimension
# into the x dimension
while blockdimy > dimy:
tmp = blockdimy // 2
if tmp < dimy:
break
blockdimx *= 2
blockdimy = tmp
# Clamp the block dimensions
# if necessary
if dimx < blockdimx:
blockdimx = dimx
if dimy < blockdimy:
blockdimy = dimy
if dimz < blockdimz:
blockdimz = dimz
return blockdimx, blockdimy, blockdimz |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def register_default_dimensions(cube, slvr_cfg):
""" Register the default dimensions for a RIME solver """ |
import montblanc.src_types as mbs
# Pull out the configuration options for the basics
autocor = slvr_cfg['auto_correlations']
ntime = 10
na = 7
nbands = 1
nchan = 16
npol = 4
# Infer number of baselines from number of antenna,
nbl = nr_of_baselines(na, autocor)
if not npol == 4:
raise ValueError("npol set to {}, but only 4 polarisations "
"are currently supported.")
# Register these dimensions on this solver.
cube.register_dimension('ntime', ntime,
description="Timesteps")
cube.register_dimension('na', na,
description="Antenna")
cube.register_dimension('nbands', nbands,
description="Bands")
cube.register_dimension('nchan', nchan,
description="Channels")
cube.register_dimension('npol', npol,
description="Polarisations")
cube.register_dimension('nbl', nbl,
description="Baselines")
# Register dependent dimensions
cube.register_dimension('npolchan', nchan*npol,
description='Polarised channels')
cube.register_dimension('nvis', ntime*nbl*nchan,
description='Visibilities')
# Convert the source types, and their numbers
# to their number variables and numbers
# { 'point':10 } => { 'npsrc':10 }
src_cfg = default_sources()
src_nr_vars = sources_to_nr_vars(src_cfg)
# Sum to get the total number of sources
cube.register_dimension('nsrc', sum(src_nr_vars.itervalues()),
description="Sources (Total)")
# Register the individual source types
for nr_var, nr_of_src in src_nr_vars.iteritems():
cube.register_dimension(nr_var, nr_of_src,
description='{} sources'.format(mbs.SOURCE_DIM_TYPES[nr_var])) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def get_ip_address(ifname):
""" Hack to get IP address from the interface """ |
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(fcntl.ioctl(
s.fileno(),
0x8915, # SIOCGIFADDR
struct.pack('256s', ifname[:15])
)[20:24]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def nvcc_compiler_settings():
""" Find nvcc and the CUDA installation """ |
search_paths = os.environ.get('PATH', '').split(os.pathsep)
nvcc_path = find_in_path('nvcc', search_paths)
default_cuda_path = os.path.join('usr', 'local', 'cuda')
cuda_path = os.environ.get('CUDA_PATH', default_cuda_path)
nvcc_found = os.path.exists(nvcc_path)
cuda_path_found = os.path.exists(cuda_path)
# Can't find either NVCC or some CUDA_PATH
if not nvcc_found and not cuda_path_found:
raise InspectCudaException("Neither nvcc '{}' "
"or the CUDA_PATH '{}' were found!".format(
nvcc_path, cuda_path))
# No NVCC, try find it in the CUDA_PATH
if not nvcc_found:
log.warn("nvcc compiler not found at '{}'. "
"Searching within the CUDA_PATH '{}'"
.format(nvcc_path, cuda_path))
bin_dir = os.path.join(cuda_path, 'bin')
nvcc_path = find_in_path('nvcc', bin_dir)
nvcc_found = os.path.exists(nvcc_path)
if not nvcc_found:
raise InspectCudaException("nvcc not found in '{}' "
"or under the CUDA_PATH at '{}' "
.format(search_paths, cuda_path))
# No CUDA_PATH found, infer it from NVCC
if not cuda_path_found:
cuda_path = os.path.normpath(
os.path.join(os.path.dirname(nvcc_path), ".."))
log.warn("CUDA_PATH not found, inferring it as '{}' "
"from the nvcc location '{}'".format(
cuda_path, nvcc_path))
cuda_path_found = True
# Set up the compiler settings
include_dirs = []
library_dirs = []
define_macros = []
if cuda_path_found:
include_dirs.append(os.path.join(cuda_path, 'include'))
if sys.platform == 'win32':
library_dirs.append(os.path.join(cuda_path, 'bin'))
library_dirs.append(os.path.join(cuda_path, 'lib', 'x64'))
else:
library_dirs.append(os.path.join(cuda_path, 'lib64'))
library_dirs.append(os.path.join(cuda_path, 'lib'))
if sys.platform == 'darwin':
library_dirs.append(os.path.join(default_cuda_path, 'lib'))
return {
'cuda_available' : True,
'nvcc_path' : nvcc_path,
'include_dirs': include_dirs,
'library_dirs': library_dirs,
'define_macros': define_macros,
'libraries' : ['cudart', 'cuda'],
'language': 'c++',
} |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def template_dict(self):
""" Returns a dictionary suitable for templating strings with properties and dimensions related to this Solver object. Used in templated GPU kernels. """ |
slvr = self
D = {
# Constants
'LIGHTSPEED': montblanc.constants.C,
}
# Map any types
D.update(self.type_dict())
# Update with dimensions
D.update(self.dim_local_size_dict())
# Add any registered properties to the dictionary
for p in self._properties.itervalues():
D[p.name] = getattr(self, p.name)
return D |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rime_solver(slvr_cfg):
""" Factory function that produces a RIME solver """ |
from montblanc.impl.rime.tensorflow.RimeSolver import RimeSolver
return RimeSolver(slvr_cfg) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parallactic_angles(times, antenna_positions, field_centre):
""" Computes parallactic angles per timestep for the given reference antenna position and field centre. Arguments: times: ndarray Array of unique times with shape (ntime,), obtained from TIME column of MS table antenna_positions: ndarray of shape (na, 3) Antenna positions, obtained from POSITION column of MS ANTENNA sub-table field_centre : ndarray of shape (2,) Field centre, should be obtained from MS PHASE_DIR Returns: An array of parallactic angles per time-step """ |
import pyrap.quanta as pq
try:
# Create direction measure for the zenith
zenith = pm.direction('AZEL','0deg','90deg')
except AttributeError as e:
if pm is None:
raise ImportError("python-casacore import failed")
raise
# Create position measures for each antenna
reference_positions = [pm.position('itrf',
*(pq.quantity(x,'m') for x in pos))
for pos in antenna_positions]
# Compute field centre in radians
fc_rad = pm.direction('J2000',
*(pq.quantity(f,'rad') for f in field_centre))
return np.asarray([
# Set current time as the reference frame
pm.do_frame(pm.epoch("UTC", pq.quantity(t, "s")))
and
[ # Set antenna position as the reference frame
pm.do_frame(rp)
and
pm.posangle(fc_rad, zenith).get_value("rad")
for rp in reference_positions
]
for t in times]) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def constant_cache(method):
""" Caches constant arrays associated with an array name. The intent of this decorator is to avoid the cost of recreating and storing many arrays of constant data, especially data created by np.zeros or np.ones. Instead, a single array of the first given shape is created and any further requests for constant data of the same (or smaller) shape are served from the cache. Requests for larger shapes or different types are regarded as a cache miss and will result in replacement of the existing cache value. """ |
@functools.wraps(method)
def wrapper(self, context):
# Defer to method if no caching is enabled
if not self._is_cached:
return method(self, context)
name = context.name
cached = self._constant_cache.get(name, None)
# No cached value, call method and return
if cached is None:
data = self._constant_cache[name] = method(self, context)
return data
# Can we just slice the existing cache entry?
# 1. Are all context.shape's entries less than or equal
# to the shape of the cached data?
# 2. Do they have the same dtype?
cached_ok = (cached.dtype == context.dtype and
all(l <= r for l,r in zip(context.shape, cached.shape)))
# Need to return something bigger or a different type
if not cached_ok:
data = self._constant_cache[name] = method(self, context)
return data
# Otherwise slice the cached data
return cached[tuple(slice(0, s) for s in context.shape)]
f = wrapper
f.__decorator__ = constant_cache.__name__
return f |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def chunk_cache(method):
""" Caches chunks of default data. This decorator caches generated default data so as to avoid recomputing it on a subsequent queries to the provider. """ |
@functools.wraps(method)
def wrapper(self, context):
# Defer to the method if no caching is enabled
if not self._is_cached:
return method(self, context)
# Construct the key for the given index
name = context.name
idx = context.array_extents(name)
key = tuple(i for t in idx for i in t)
# Access the sub-cache for this array
array_cache = self._chunk_cache[name]
# Cache miss, call the function
if key not in array_cache:
array_cache[key] = method(self, context)
return array_cache[key]
f = wrapper
f.__decorator__ = chunk_cache.__name__
return f |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _create_defaults_source_provider(cube, data_source):
""" Create a DefaultsSourceProvider object. This provides default data sources for each array defined on the hypercube. The data sources may either by obtained from the arrays 'default' data source or the 'test' data source. """ |
from montblanc.impl.rime.tensorflow.sources import (
find_sources, DEFAULT_ARGSPEC)
from montblanc.impl.rime.tensorflow.sources import constant_cache
# Obtain default data sources for each array,
# Just take from defaults if test data isn't specified
staging_area_data_source = ('default' if not data_source == 'test'
else data_source)
cache = True
default_prov = DefaultsSourceProvider(cache=cache)
# Create data sources on the source provider from
# the cube array data sources
for n, a in cube.arrays().iteritems():
# Unnecessary for temporary arrays
if 'temporary' in a.tags:
continue
# Obtain the data source
data_source = a.get(staging_area_data_source)
# Array marked as constant, decorate the data source
# with a constant caching decorator
if cache is True and 'constant' in a.tags:
data_source = constant_cache(data_source)
method = types.MethodType(data_source, default_prov)
setattr(default_prov, n, method)
def _sources(self):
"""
Override the sources method to also handle lambdas that look like
lambda s, c: ..., as defined in the config module
"""
try:
return self._sources
except AttributeError:
self._sources = find_sources(self, [DEFAULT_ARGSPEC] + [['s', 'c']])
return self._sources
# Monkey patch the sources method
default_prov.sources = types.MethodType(_sources, default_prov)
return default_prov |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_data(data_source, context):
""" Get data from the data source, checking the return values """ |
try:
# Get data from the data source
data = data_source.source(context)
# Complain about None values
if data is None:
raise ValueError("'None' returned from "
"data source '{n}'".format(n=context.name))
# We want numpy arrays
elif not isinstance(data, np.ndarray):
raise TypeError("Data source '{n}' did not "
"return a numpy array, returned a '{t}'".format(
t=type(data)))
# And they should be the right shape and type
elif data.shape != context.shape or data.dtype != context.dtype:
raise ValueError("Expected data of shape '{esh}' and "
"dtype '{edt}' for data source '{n}', but "
"shape '{rsh}' and '{rdt}' was found instead".format(
n=context.name, esh=context.shape, edt=context.dtype,
rsh=data.shape, rdt=data.dtype))
return data
except Exception as e:
ex = ValueError("An exception occurred while "
"obtaining data from data source '{ds}'\n\n"
"{e}\n\n"
"{help}".format(ds=context.name,
e=str(e), help=context.help()))
raise ex, None, sys.exc_info()[2] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _supply_data(data_sink, context):
""" Supply data to the data sink """ |
try:
data_sink.sink(context)
except Exception as e:
ex = ValueError("An exception occurred while "
"supplying data to data sink '{ds}'\n\n"
"{e}\n\n"
"{help}".format(ds=context.name,
e=str(e), help=context.help()))
raise ex, None, sys.exc_info()[2] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _setup_hypercube(cube, slvr_cfg):
""" Sets up the hypercube given a solver configuration """ |
mbu.register_default_dimensions(cube, slvr_cfg)
# Configure the dimensions of the beam cube
cube.register_dimension('beam_lw', 2,
description='E Beam cube l width')
cube.register_dimension('beam_mh', 2,
description='E Beam cube m height')
cube.register_dimension('beam_nud', 2,
description='E Beam cube nu depth')
# =========================================
# Register hypercube Arrays and Properties
# =========================================
from montblanc.impl.rime.tensorflow.config import (A, P)
def _massage_dtypes(A, T):
def _massage_dtype_in_dict(D):
new_dict = D.copy()
new_dict['dtype'] = mbu.dtype_from_str(D['dtype'], T)
return new_dict
return [_massage_dtype_in_dict(D) for D in A]
dtype = slvr_cfg['dtype']
is_f32 = dtype == 'float'
T = {
'ft' : np.float32 if is_f32 else np.float64,
'ct' : np.complex64 if is_f32 else np.complex128,
'int' : int,
}
cube.register_properties(_massage_dtypes(P, T))
cube.register_arrays(_massage_dtypes(A, T)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _partition(iter_dims, data_sources):
""" Partition data sources into 1. Dictionary of data sources associated with radio sources. 2. List of data sources to feed multiple times. 3. List of data sources to feed once. """ |
src_nr_vars = set(source_var_types().values())
iter_dims = set(iter_dims)
src_data_sources = collections.defaultdict(list)
feed_many = []
feed_once = []
for ds in data_sources:
# Is this data source associated with
# a radio source (point, gaussian, etc.?)
src_int = src_nr_vars.intersection(ds.shape)
if len(src_int) > 1:
raise ValueError("Data source '{}' contains multiple "
"source types '{}'".format(ds.name, src_int))
elif len(src_int) == 1:
# Yep, record appropriately and iterate
src_data_sources[src_int.pop()].append(ds)
continue
# Are we feeding this data source multiple times
# (Does it possess dimensions on which we iterate?)
if len(iter_dims.intersection(ds.shape)) > 0:
feed_many.append(ds)
continue
# Assume this is a data source that we only feed once
feed_once.append(ds)
return src_data_sources, feed_many, feed_once |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _feed_impl(self, cube, data_sources, data_sinks, global_iter_args):
""" Implementation of staging_area feeding """ |
session = self._tf_session
FD = self._tf_feed_data
LSA = FD.local
# Get source strides out before the local sizes are modified during
# the source loops below
src_types = LSA.sources.keys()
src_strides = [int(i) for i in cube.dim_extent_size(*src_types)]
src_staging_areas = [[LSA.sources[t][s] for t in src_types]
for s in range(self._nr_of_shards)]
compute_feed_dict = { ph: cube.dim_global_size(n) for
n, ph in FD.src_ph_vars.iteritems() }
compute_feed_dict.update({ ph: getattr(cube, n) for
n, ph in FD.property_ph_vars.iteritems() })
chunks_fed = 0
which_shard = itertools.cycle([self._shard(d,s)
for s in range(self._shards_per_device)
for d, dev in enumerate(self._devices)])
while True:
try:
# Get the descriptor describing a portion of the RIME
result = session.run(LSA.descriptor.get_op)
descriptor = result['descriptor']
except tf.errors.OutOfRangeError as e:
montblanc.log.exception("Descriptor reading exception")
# Quit if EOF
if descriptor[0] == -1:
break
# Make it read-only so we can hash the contents
descriptor.flags.writeable = False
# Find indices of the emptiest staging_areas and, by implication
# the shard with the least work assigned to it
emptiest_staging_areas = np.argsort(self._inputs_waiting.get())
shard = emptiest_staging_areas[0]
shard = which_shard.next()
feed_f = self._feed_executors[shard].submit(self._feed_actual,
data_sources.copy(), cube.copy(),
descriptor, shard,
src_types, src_strides, src_staging_areas[shard],
global_iter_args)
compute_f = self._compute_executors[shard].submit(self._compute,
compute_feed_dict, shard)
consume_f = self._consumer_executor.submit(self._consume,
data_sinks.copy(), cube.copy(), global_iter_args)
self._inputs_waiting.increment(shard)
yield (feed_f, compute_f, consume_f)
chunks_fed += 1
montblanc.log.info("Done feeding {n} chunks.".format(n=chunks_fed)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _compute(self, feed_dict, shard):
""" Call the tensorflow compute """ |
try:
descriptor, enq = self._tfrun(self._tf_expr[shard], feed_dict=feed_dict)
self._inputs_waiting.decrement(shard)
except Exception as e:
montblanc.log.exception("Compute Exception")
raise |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rime_solver_cfg(**kwargs):
""" Produces a SolverConfiguration object, inherited from a simple python dict, and containing the options required to configure the RIME Solver. Keyword arguments Any keyword arguments are inserted into the returned dict. Returns ------- A SolverConfiguration object. """ |
from configuration import (load_config, config_validator,
raise_validator_errors)
def _merge_copy(d1, d2):
return { k: _merge_copy(d1[k], d2[k]) if k in d1
and isinstance(d1[k], dict)
and isinstance(d2[k], dict)
else d2[k] for k in d2 }
try:
cfg_file = kwargs.pop('cfg_file')
except KeyError as e:
slvr_cfg = kwargs
else:
cfg = load_config(cfg_file)
slvr_cfg = _merge_copy(cfg, kwargs)
# Validate the configuration, raising any errors
validator = config_validator()
validator.validate(slvr_cfg)
raise_validator_errors(validator)
return validator.document |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _create_filenames(filename_schema, feed_type):
""" Returns a dictionary of beam filename pairs, keyed on correlation,from the cartesian product of correlations and real, imaginary pairs Given 'beam_$(corr)_$(reim).fits' returns: { 'xx' : ('beam_xx_re.fits', 'beam_xx_im.fits'), 'xy' : ('beam_xy_re.fits', 'beam_xy_im.fits'), 'yy' : ('beam_yy_re.fits', 'beam_yy_im.fits'), } Given 'beam_$(CORR)_$(REIM).fits' returns: { 'xx' : ('beam_XX_RE.fits', 'beam_XX_IM.fits'), 'xy' : ('beam_XY_RE.fits', 'beam_XY_IM.fits'), 'yy' : ('beam_YY_RE.fits', 'beam_YY_IM.fits'), } """ |
template = FitsFilenameTemplate(filename_schema)
def _re_im_filenames(corr, template):
try:
return tuple(template.substitute(
corr=corr.lower(), CORR=corr.upper(),
reim=ri.lower(), REIM=ri.upper())
for ri in REIM)
except KeyError:
raise ValueError("Invalid filename schema '%s'. "
"FITS Beam filename schemas "
"must follow forms such as "
"'beam_$(corr)_$(reim).fits' or "
"'beam_$(CORR)_$(REIM).fits." % filename_schema)
if feed_type == 'linear':
CORRELATIONS = LINEAR_CORRELATIONS
elif feed_type == 'circular':
CORRELATIONS = CIRCULAR_CORRELATIONS
else:
raise ValueError("Invalid feed_type '{}'. "
"Should be 'linear' or 'circular'")
return collections.OrderedDict(
(c, _re_im_filenames(c, template))
for c in CORRELATIONS) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _create_axes(filenames, file_dict):
""" Create a FitsAxes object """ |
try:
# Loop through the file_dictionary, finding the
# first open FITS file.
f = iter(f for tup in file_dict.itervalues()
for f in tup if f is not None).next()
except StopIteration as e:
raise (ValueError("No FITS files were found. "
"Searched filenames: '{f}'." .format(
f=filenames.values())),
None, sys.exc_info()[2])
# Create a FitsAxes object
axes = FitsAxes(f[0].header)
# Scale any axes in degrees to radians
for i, u in enumerate(axes.cunit):
if u == 'DEG':
axes.cunit[i] = 'RAD'
axes.set_axis_scale(i, np.pi/180.0)
return axes |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _initialise(self, feed_type="linear"):
""" Initialise the object by generating appropriate filenames, opening associated file handles and inspecting the FITS axes of these files. """ |
self._filenames = filenames = _create_filenames(self._filename_schema,
feed_type)
self._files = files = _open_fits_files(filenames)
self._axes = axes = _create_axes(filenames, files)
self._dim_indices = dim_indices = l_ax, m_ax, f_ax = tuple(
axes.iaxis(d) for d in self._fits_dims)
# Complain if we can't find required axes
for i, ax in zip(dim_indices, self._fits_dims):
if i == -1:
raise ValueError("'%s' axis not found!" % ax)
self._cube_extents = _cube_extents(axes, l_ax, m_ax, f_ax,
self._l_sign, self._m_sign)
self._shape = tuple(axes.naxis[d] for d in dim_indices) + (4,)
self._beam_freq_map = axes.grid[f_ax]
# Now describe our dimension sizes
self._dim_updates = [(n, axes.naxis[i]) for n, i
in zip(self._beam_dims, dim_indices)]
self._initialised = True |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ebeam(self, context):
""" ebeam cube data source """ |
if context.shape != self.shape:
raise ValueError("Partial feeding of the "
"beam cube is not yet supported %s %s." % (context.shape, self.shape))
ebeam = np.empty(context.shape, context.dtype)
# Iterate through the correlations,
# assigning real and imaginary data, if present,
# otherwise zeroing the correlation
for i, (re, im) in enumerate(self._files.itervalues()):
ebeam[:,:,:,i].real[:] = 0 if re is None else re[0].data.T
ebeam[:,:,:,i].imag[:] = 0 if im is None else im[0].data.T
return ebeam |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def model_vis(self, context):
""" model visibility data sink """ |
column = self._vis_column
msshape = None
# Do we have a column descriptor for the supplied column?
try:
coldesc = self._manager.column_descriptors[column]
except KeyError as e:
coldesc = None
# Try to get the shape from the descriptor
if coldesc is not None:
try:
msshape = [-1] + coldesc['shape'].tolist()
except KeyError as e:
msshape = None
# Otherwise guess it and warn
if msshape is None:
guessed_shape = [self._manager._nchan, 4]
montblanc.log.warn("Could not obtain 'shape' from the '{c}' "
"column descriptor. Guessing it is '{gs}'.".format(
c=column, gs=guessed_shape))
msshape = [-1] + guessed_shape
lrow, urow = MS.row_extents(context)
self._manager.ordered_main_table.putcol(column,
context.data.reshape(msshape),
startrow=lrow, nrow=urow-lrow) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _cache(method):
""" Decorator for caching data source return values Create a key index for the proxied array in the context. Iterate over the array shape descriptor e.g. (ntime, nbl, 3) returning tuples containing the lower and upper extents of string dimensions. Takes (0, d) in the case of an integer dimensions. """ |
@functools.wraps(method)
def memoizer(self, context):
# Construct the key for the given index
idx = context.array_extents(context.name)
key = tuple(i for t in idx for i in t)
with self._lock:
# Access the sub-cache for this data source
array_cache = self._cache[context.name]
# Cache miss, call the data source
if key not in array_cache:
array_cache[key] = method(context)
return array_cache[key]
return memoizer |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _proxy(method):
""" Decorator returning a method that proxies a data source. """ |
@functools.wraps(method)
def memoizer(self, context):
return method(context)
return memoizer |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def start(self, start_context):
""" Perform any logic on solution start """ |
for p in self._providers:
p.start(start_context)
if self._clear_start:
self.clear_cache() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def stop(self, stop_context):
""" Perform any logic on solution stop """ |
for p in self._providers:
p.stop(stop_context)
if self._clear_stop:
self.clear_cache() |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def default_base_ant_pairs(self, context):
""" Compute base antenna pairs """ |
k = 0 if context.cfg['auto_correlations'] == True else 1
na = context.dim_global_size('na')
gen = (i.astype(context.dtype) for i in np.triu_indices(na, k))
# Cache np.triu_indices(na, k) as its likely that (na, k) will
# stay constant much of the time. Assumption here is that this
# method will be grafted onto a DefaultsSourceProvider with
# the appropriate members.
if self._is_cached:
array_cache = self._chunk_cache['default_base_ant_pairs']
key = (k, na)
# Cache miss
if key not in array_cache:
array_cache[key] = tuple(gen)
return array_cache[key]
return tuple(gen) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def default_antenna1(self, context):
""" Default antenna1 values """ |
ant1, ant2 = default_base_ant_pairs(self, context)
(tl, tu), (bl, bu) = context.dim_extents('ntime', 'nbl')
ant1_result = np.empty(context.shape, context.dtype)
ant1_result[:,:] = ant1[np.newaxis,bl:bu]
return ant1_result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def default_antenna2(self, context):
""" Default antenna2 values """ |
ant1, ant2 = default_base_ant_pairs(self, context)
(tl, tu), (bl, bu) = context.dim_extents('ntime', 'nbl')
ant2_result = np.empty(context.shape, context.dtype)
ant2_result[:,:] = ant2[np.newaxis,bl:bu]
return ant2_result |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def frequency(self, context):
""" Frequency data source """ |
channels = self._manager.spectral_window_table.getcol(MS.CHAN_FREQ)
return channels.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ref_frequency(self, context):
""" Reference frequency data source """ |
num_chans = self._manager.spectral_window_table.getcol(MS.NUM_CHAN)
ref_freqs = self._manager.spectral_window_table.getcol(MS.REF_FREQUENCY)
data = np.hstack((np.repeat(rf, bs) for bs, rf in zip(num_chans, ref_freqs)))
return data.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def uvw(self, context):
""" Per-antenna UVW coordinate data source """ |
# Hacky access of private member
cube = context._cube
# Create antenna1 source context
a1_actual = cube.array("antenna1", reify=True)
a1_ctx = SourceContext("antenna1", cube, context.cfg,
context.iter_args, cube.array("antenna1"),
a1_actual.shape, a1_actual.dtype)
# Create antenna2 source context
a2_actual = cube.array("antenna2", reify=True)
a2_ctx = SourceContext("antenna2", cube, context.cfg,
context.iter_args, cube.array("antenna2"),
a2_actual.shape, a2_actual.dtype)
# Get antenna1 and antenna2 data
ant1 = self.antenna1(a1_ctx).ravel()
ant2 = self.antenna2(a2_ctx).ravel()
# Obtain per baseline UVW data
lrow, urow = MS.uvw_row_extents(context)
uvw = self._manager.ordered_uvw_table.getcol(MS.UVW,
startrow=lrow,
nrow=urow-lrow)
# Perform the per-antenna UVW decomposition
ntime, nbl = context.dim_extent_size('ntime', 'nbl')
na = context.dim_global_size('na')
chunks = np.repeat(nbl, ntime).astype(ant1.dtype)
auvw = mbu.antenna_uvw(uvw, ant1, ant2, chunks, nr_of_antenna=na)
return auvw.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def antenna1(self, context):
""" antenna1 data source """ |
lrow, urow = MS.uvw_row_extents(context)
antenna1 = self._manager.ordered_uvw_table.getcol(
MS.ANTENNA1, startrow=lrow, nrow=urow-lrow)
return antenna1.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def antenna2(self, context):
""" antenna2 data source """ |
lrow, urow = MS.uvw_row_extents(context)
antenna2 = self._manager.ordered_uvw_table.getcol(
MS.ANTENNA2, startrow=lrow, nrow=urow-lrow)
return antenna2.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parallactic_angles(self, context):
""" parallactic angle data source """ |
# Time and antenna extents
(lt, ut), (la, ua) = context.dim_extents('ntime', 'na')
return (mbu.parallactic_angles(self._times[lt:ut],
self._antenna_positions[la:ua], self._phase_dir)
.reshape(context.shape)
.astype(context.dtype)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def observed_vis(self, context):
""" Observed visibility data source """ |
lrow, urow = MS.row_extents(context)
data = self._manager.ordered_main_table.getcol(
self._vis_column, startrow=lrow, nrow=urow-lrow)
return data.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def flag(self, context):
""" Flag data source """ |
lrow, urow = MS.row_extents(context)
flag = self._manager.ordered_main_table.getcol(
MS.FLAG, startrow=lrow, nrow=urow-lrow)
return flag.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def weight(self, context):
""" Weight data source """ |
lrow, urow = MS.row_extents(context)
weight = self._manager.ordered_main_table.getcol(
MS.WEIGHT, startrow=lrow, nrow=urow-lrow)
# WEIGHT is applied across all channels
weight = np.repeat(weight, self._manager.channels_per_band, 0)
return weight.reshape(context.shape).astype(context.dtype) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def load_tf_lib():
""" Load the tensorflow library """ |
from os.path import join as pjoin
import pkg_resources
import tensorflow as tf
path = pjoin('ext', 'rime.so')
rime_lib_path = pkg_resources.resource_filename("montblanc", path)
return tf.load_op_library(rime_lib_path) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def raise_validator_errors(validator):
""" Raise any errors associated with the validator. Parameters validator : :class:`cerberus.Validator` Validator Raises ------ ValueError Raised if errors existed on `validator`. Message describing each error and information associated with the configuration option causing the error. """ |
if len(validator._errors) == 0:
return
def _path_str(path, name=None):
""" String of the document/schema path. `cfg["foo"]["bar"]` """
L = [name] if name is not None else []
L.extend('["%s"]' % p for p in path)
return "".join(L)
def _path_leaf(path, dicts):
""" Dictionary Leaf of the schema/document given the path """
for p in path:
dicts = dicts[p]
return dicts
wrap = partial(textwrap.wrap, initial_indent=' '*4,
subsequent_indent=' '*8)
msg = ["There were configuration errors:"]
for e in validator._errors:
schema_leaf = _path_leaf(e.document_path, validator.schema)
doc_str = _path_str(e.document_path, "cfg")
msg.append("Invalid configuration option %s == '%s'." % (doc_str, e.value))
try:
otype = schema_leaf["type"]
msg.extend(wrap("Type must be '%s'." % otype))
except KeyError:
pass
try:
allowed = schema_leaf["allowed"]
msg.extend(wrap("Allowed values are '%s'." % allowed))
except KeyError:
pass
try:
description = schema_leaf["__description__"]
msg.extend(wrap("Description: %s" % description))
except KeyError:
pass
raise ValueError("\n".join(msg)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def indented(text, level, indent=2):
"""Take a multiline text and indent it as a block""" |
return "\n".join("%s%s" % (level * indent * " ", s) for s in text.splitlines()) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def dumped(text, level, indent=2):
"""Put curly brackets round an indented text""" |
return indented("{\n%s\n}" % indented(text, level + 1, indent) or "None", level, indent) + "\n" |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def copy_file( source_path, target_path, allow_undo=True, no_confirm=False, rename_on_collision=True, silent=False, extra_flags=0, hWnd=None ):
"""Perform a shell-based file copy. Copying in this way allows the possibility of undo, auto-renaming, and showing the "flying file" animation during the copy. The default options allow for undo, don't automatically clobber on a name clash, automatically rename on collision and display the animation. """ |
return _file_operation(
shellcon.FO_COPY,
source_path,
target_path,
allow_undo,
no_confirm,
rename_on_collision,
silent,
extra_flags,
hWnd
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def move_file( source_path, target_path, allow_undo=True, no_confirm=False, rename_on_collision=True, silent=False, extra_flags=0, hWnd=None ):
"""Perform a shell-based file move. Moving in this way allows the possibility of undo, auto-renaming, and showing the "flying file" animation during the copy. The default options allow for undo, don't automatically clobber on a name clash, automatically rename on collision and display the animation. """ |
return _file_operation(
shellcon.FO_MOVE,
source_path,
target_path,
allow_undo,
no_confirm,
rename_on_collision,
silent,
extra_flags,
hWnd
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def rename_file( source_path, target_path, allow_undo=True, no_confirm=False, rename_on_collision=True, silent=False, extra_flags=0, hWnd=None ):
"""Perform a shell-based file rename. Renaming in this way allows the possibility of undo, auto-renaming, and showing the "flying file" animation during the copy. The default options allow for undo, don't automatically clobber on a name clash, automatically rename on collision and display the animation. """ |
return _file_operation(
shellcon.FO_RENAME,
source_path,
target_path,
allow_undo,
no_confirm,
rename_on_collision,
silent,
extra_flags,
hWnd
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def delete_file( source_path, allow_undo=True, no_confirm=False, silent=False, extra_flags=0, hWnd=None ):
"""Perform a shell-based file delete. Deleting in this way uses the system recycle bin, allows the possibility of undo, and showing the "flying file" animation during the delete. The default options allow for undo, don't automatically clobber on a name clash and display the animation. """ |
return _file_operation(
shellcon.FO_DELETE,
source_path,
None,
allow_undo,
no_confirm,
False,
silent,
extra_flags,
hWnd
) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _get_queue_types(fed_arrays, data_sources):
""" Given a list of arrays to feed in fed_arrays, return a list of associated queue types, obtained from tuples in the data_sources dictionary """ |
try:
return [data_sources[n].dtype for n in fed_arrays]
except KeyError as e:
raise ValueError("Array '{k}' has no data source!"
.format(k=e.message)), None, sys.exc_info()[2] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def parse_python_assigns(assign_str):
""" Parses a string, containing assign statements into a dictionary. .. code-block:: python h5 = katdal.open('123456789.h5') kwargs = parse_python_assigns("spw=3; scans=[1,2];" "targets='bpcal,radec';" "channels=slice(0,2048)") h5.select(**kwargs) Parameters assign_str: str Assignment string. Should only contain assignment statements assigning python literals or builtin function calls, to variable names. Multiple assignment statements should be separated by semi-colons. Returns ------- dict Dictionary { name: value } containing assignment results. """ |
if not assign_str:
return {}
def _eval_value(stmt_value):
# If the statement value is a call to a builtin, try evaluate it
if isinstance(stmt_value, ast.Call):
func_name = stmt_value.func.id
if func_name not in _BUILTIN_WHITELIST:
raise ValueError("Function '%s' in '%s' is not builtin. "
"Available builtins: '%s'"
% (func_name, assign_str, list(_BUILTIN_WHITELIST)))
# Recursively pass arguments through this same function
if stmt_value.args is not None:
args = tuple(_eval_value(a) for a in stmt_value.args)
else:
args = ()
# Recursively pass keyword arguments through this same function
if stmt_value.keywords is not None:
kwargs = {kw.arg : _eval_value(kw.value) for kw
in stmt_value.keywords}
else:
kwargs = {}
return getattr(__builtin__, func_name)(*args, **kwargs)
# Try a literal eval
else:
return ast.literal_eval(stmt_value)
# Variable dictionary
variables = {}
# Parse the assignment string
stmts = ast.parse(assign_str, mode='single').body
for i, stmt in enumerate(stmts):
if not isinstance(stmt, ast.Assign):
raise ValueError("Statement %d in '%s' is not a "
"variable assignment." % (i, assign_str))
# Evaluate assignment lhs
values = _eval_value(stmt.value)
# "a = b = c" => targets 'a' and 'b' with 'c' as result
for target in stmt.targets:
# a = 2
if isinstance(target, ast.Name):
variables[target.id] = values
# Tuple/List unpacking case
# (a, b) = 2
elif isinstance(target, (ast.Tuple, ast.List)):
# Require all tuple/list elements to be variable names,
# although anything else is probably a syntax error
if not all(isinstance(e, ast.Name) for e in target.elts):
raise ValueError("Tuple unpacking in assignment %d "
"in expression '%s' failed as not all "
"tuple contents are variable names.")
# Promote for zip and length checking
if not isinstance(values, (tuple, list)):
elements = (values,)
else:
elements = values
if not len(target.elts) == len(elements):
raise ValueError("Unpacking '%s' into a tuple/list in "
"assignment %d of expression '%s' failed. "
"The number of tuple elements did not match "
"the number of values."
% (values, i, assign_str))
# Unpack
for variable, value in zip(target.elts, elements):
variables[variable.id] = value
else:
raise TypeError("'%s' types are not supported"
"as assignment targets." % type(target))
return variables |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _antenna_uvw(uvw, antenna1, antenna2, chunks, nr_of_antenna):
""" numba implementation of antenna_uvw """ |
if antenna1.ndim != 1:
raise ValueError("antenna1 shape should be (row,)")
if antenna2.ndim != 1:
raise ValueError("antenna2 shape should be (row,)")
if uvw.ndim != 2 or uvw.shape[1] != 3:
raise ValueError("uvw shape should be (row, 3)")
if not (uvw.shape[0] == antenna1.shape[0] == antenna2.shape[0]):
raise ValueError("First dimension of uvw, antenna1 "
"and antenna2 do not match")
if chunks.ndim != 1:
raise ValueError("chunks shape should be (utime,)")
if nr_of_antenna < 1:
raise ValueError("nr_of_antenna < 1")
ant_uvw_shape = (chunks.shape[0], nr_of_antenna, 3)
antenna_uvw = np.full(ant_uvw_shape, np.nan, dtype=uvw.dtype)
start = 0
for ci, chunk in enumerate(chunks):
end = start + chunk
# one pass should be enough!
_antenna_uvw_loop(uvw, antenna1, antenna2, antenna_uvw, ci, start, end)
start = end
return antenna_uvw |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _raise_decomposition_errors(uvw, antenna1, antenna2, chunks, ant_uvw, max_err):
""" Raises informative exception for an invalid decomposition """ |
start = 0
problem_str = []
for ci, chunk in enumerate(chunks):
end = start + chunk
ant1 = antenna1[start:end]
ant2 = antenna2[start:end]
cuvw = uvw[start:end]
ant1_uvw = ant_uvw[ci, ant1, :]
ant2_uvw = ant_uvw[ci, ant2, :]
ruvw = ant2_uvw - ant1_uvw
# Identifty rows where any of the UVW components differed
close = np.isclose(ruvw, cuvw)
problems = np.nonzero(np.logical_or.reduce(np.invert(close), axis=1))
for row in problems[0]:
problem_str.append("[row %d [%d, %d] (chunk %d)]: "
"original %s recovered %s "
"ant1 %s ant2 %s" % (
start+row, ant1[row], ant2[row], ci,
cuvw[row], ruvw[row],
ant1_uvw[row], ant2_uvw[row]))
# Exit inner loop early
if len(problem_str) >= max_err:
break
# Exit outer loop early
if len(problem_str) >= max_err:
break
start = end
# Return early if nothing was wrong
if len(problem_str) == 0:
return
# Add a preamble and raise exception
problem_str = ["Antenna UVW Decomposition Failed",
"The following differences were found "
"(first 100):"] + problem_str
raise AntennaUVWDecompositionError('\n'.join(problem_str)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _raise_missing_antenna_errors(ant_uvw, max_err):
""" Raises an informative error for missing antenna """ |
# Find antenna uvw coordinates where any UVW component was nan
# nan + real == nan
problems = np.nonzero(np.add.reduce(np.isnan(ant_uvw), axis=2))
problem_str = []
for c, a in zip(*problems):
problem_str.append("[chunk %d antenna %d]" % (c, a))
# Exit early
if len(problem_str) >= max_err:
break
# Return early if nothing was wrong
if len(problem_str) == 0:
return
# Add a preamble and raise exception
problem_str = ["Antenna were missing"] + problem_str
raise AntennaMissingError('\n'.join(problem_str)) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def antenna_uvw(uvw, antenna1, antenna2, chunks, nr_of_antenna, check_missing=False, check_decomposition=False, max_err=100):
""" Computes per-antenna UVW coordinates from baseline ``uvw``, ``antenna1`` and ``antenna2`` coordinates logically grouped into baseline chunks. The example below illustrates two baseline chunks of size 6 and 5, respectively. .. code-block:: python ant1 = np.array([0, 0, 0, 1, 1, 2, 0, 0, 0, 1, 1], dtype=np.int32) ant2 = np.array([1, 2, 3, 2, 3, 3, 1, 2, 3, 1, 2], dtype=np.int32) chunks = np.array([6, 5], dtype=np.int32) ant_uv = antenna_uvw(uvw, ant1, ant2, chunks, nr_of_antenna=4) The first antenna of the first baseline of a chunk is chosen as the origin of the antenna coordinate system, while the second antenna is set to the negative of the baseline UVW coordinate. Subsequent antenna UVW coordinates are iteratively derived from the first two coordinates. Thus, the baseline indices need not be properly ordered (within the chunk). If it is not possible to derive coordinates for an antenna, it's coordinate will be set to nan. Parameters uvw : np.ndarray Baseline UVW coordinates of shape (row, 3) antenna1 : np.ndarray Baseline first antenna of shape (row,) antenna2 : np.ndarray Baseline second antenna of shape (row,) chunks : np.ndarray Number of baselines per unique timestep with shape (chunks,) :code:`np.sum(chunks) == row` should hold. nr_of_antenna : int Total number of antenna in the solution. check_missing (optional) : bool If ``True`` raises an exception if it was not possible to compute UVW coordinates for all antenna (i.e. some were nan). Defaults to ``False``. check_decomposition (optional) : bool If ``True``, checks that the antenna decomposition accurately reproduces the coordinates in ``uvw``, or that :code:`ant_uvw[c,ant1,:] - ant_uvw[c,ant2,:] == uvw[s:e,:]` where ``s`` and ``e`` are the start and end rows of chunk ``c`` respectively. Defaults to ``False``. max_err (optional) : integer Maximum numbers of errors when checking for missing antenna or innacurate decompositions. Defaults to ``100``. Returns ------- np.ndarray Antenna UVW coordinates of shape (chunks, nr_of_antenna, 3) """ |
ant_uvw = _antenna_uvw(uvw, antenna1, antenna2, chunks, nr_of_antenna)
if check_missing:
_raise_missing_antenna_errors(ant_uvw, max_err=max_err)
if check_decomposition:
_raise_decomposition_errors(uvw, antenna1, antenna2, chunks,
ant_uvw, max_err=max_err)
return ant_uvw |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def default_sources(**kwargs):
""" Returns a dictionary mapping source types to number of sources. If the number of sources for the source type is supplied in the kwargs these will be placed in the dictionary. e.g. if we have 'point', 'gaussian' and 'sersic' source types, then default_sources(point=10, gaussian=20) will return an OrderedDict {'point': 10, 'gaussian': 20, 'sersic': 0} """ |
S = OrderedDict()
total = 0
invalid_types = [t for t in kwargs.keys() if t not in SOURCE_VAR_TYPES]
for t in invalid_types:
montblanc.log.warning('Source type %s is not yet '
'implemented in montblanc. '
'Valid source types are %s' % (t, SOURCE_VAR_TYPES.keys()))
# Zero all source types
for k, v in SOURCE_VAR_TYPES.iteritems():
# Try get the number of sources for this source
# from the kwargs
value = kwargs.get(k, 0)
try:
value = int(value)
except ValueError:
raise TypeError(('Supplied value %s '
'for source %s cannot be '
'converted to an integer') % \
(value, k))
total += value
S[k] = value
# Add a point source if no others exist
if total == 0:
S[POINT_TYPE] = 1
return S |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def sources_to_nr_vars(sources):
""" Converts a source type to number of sources mapping into a source numbering variable to number of sources mapping. If, for example, we have 'point', 'gaussian' and 'sersic' source types, then passing the following dict as an argument sources_to_nr_vars({'point':10, 'gaussian': 20}) will return an OrderedDict {'npsrc': 10, 'ngsrc': 20, 'nssrc': 0 } """ |
sources = default_sources(**sources)
try:
return OrderedDict((SOURCE_VAR_TYPES[name], nr)
for name, nr in sources.iteritems())
except KeyError as e:
raise KeyError((
'No source type ''%s'' is '
'registered. Valid source types '
'are %s') % (e, SOURCE_VAR_TYPES.keys())) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def source_range_slices(start, end, nr_var_dict):
""" Given a range of source numbers, as well as a dictionary containing the numbers of each source, returns a dictionary containing slices for each source variable type. """ |
return OrderedDict((k, slice(s,e,1))
for k, (s, e)
in source_range_tuple(start, end, nr_var_dict).iteritems()) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def point_lm(self, context):
""" Return a lm coordinate array to montblanc """ |
lm = np.empty(context.shape, context.dtype)
# Print the array schema
montblanc.log.info(context.array_schema.shape)
# Print the space of iteration
montblanc.log.info(context.iter_args)
(ls, us) = context.dim_extents('npsrc')
lm[:,0] = 0.0008
lm[:,1] = 0.0036
lm[:,:] = 0
return lm |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def point_stokes(self, context):
""" Return a stokes parameter array to montblanc """ |
stokes = np.empty(context.shape, context.dtype)
stokes[:,:,0] = 1
stokes[:,:,1:4] = 0
return stokes |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def ref_frequency(self, context):
""" Return a reference frequency array to montblanc """ |
ref_freq = np.empty(context.shape, context.dtype)
ref_freq[:] = 1.415e9
return ref_freq |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update(self, scopes=[], add_scopes=[], rm_scopes=[], note='', note_url=''):
"""Update this authorization. :param list scopes: (optional), replaces the authorization scopes with these :param list add_scopes: (optional), scopes to be added :param list rm_scopes: (optional), scopes to be removed :param str note: (optional), new note about authorization :param str note_url: (optional), new note URL about this authorization :returns: bool """ |
success = False
json = None
if scopes:
d = {'scopes': scopes}
json = self._json(self._post(self._api, data=d), 200)
if add_scopes:
d = {'add_scopes': add_scopes}
json = self._json(self._post(self._api, data=d), 200)
if rm_scopes:
d = {'remove_scopes': rm_scopes}
json = self._json(self._post(self._api, data=d), 200)
if note or note_url:
d = {'note': note, 'note_url': note_url}
json = self._json(self._post(self._api, data=d), 200)
if json:
self._update_(json)
success = True
return success |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def iter_labels(self, number=-1, etag=None):
"""Iterate over the labels for every issue associated with this milestone. .. versionchanged:: 0.9 Add etag parameter. :param int number: (optional), number of labels to return. Default: -1 returns all available labels. :param str etag: (optional), ETag header from a previous response :returns: generator of :class:`Label <github3.issues.label.Label>`\ s """ |
url = self._build_url('labels', base_url=self._api)
return self._iter(int(number), url, Label, etag=etag) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _trace(self, frame, event, arg):
""" Build a record of called functions using the trace mechanism """ |
# Return if this is not a function call
if event != 'call':
return
# Filter calling and called functions by module names
src_mod = current_module_name(frame.f_back)
dst_mod = current_module_name(frame)
# Avoid tracing the tracer (specifically, call from
# ContextCallTracer.__exit__ to CallTracer.stop)
if src_mod == __modulename__ or dst_mod == __modulename__:
return
# Apply source and destination module filters
if not self.srcmodflt.match(src_mod):
return
if not self.dstmodflt.match(dst_mod):
return
# Get calling and called functions
src_func = current_function(frame.f_back)
dst_func = current_function(frame)
# Filter calling and called functions by qnames
if not self.srcqnmflt.match(function_qname(src_func)):
return
if not self.dstqnmflt.match(function_qname(dst_func)):
return
# Get calling and called function full names
src_name = function_fqname(src_func)
dst_name = function_fqname(dst_func)
# Modify full function names if necessary
if self.fnmsub is not None:
src_name = re.sub(self.fnmsub[0], self.fnmsub[1], src_name)
dst_name = re.sub(self.fnmsub[0], self.fnmsub[1], dst_name)
# Update calling function count
if src_func is not None:
if src_name in self.fncts:
self.fncts[src_name][0] += 1
else:
self.fncts[src_name] = [1, 0]
# Update called function count
if dst_func is not None and src_func is not None:
if dst_name in self.fncts:
self.fncts[dst_name][1] += 1
else:
self.fncts[dst_name] = [0, 1]
# Update caller/calling pair count
if dst_func is not None and src_func is not None:
key = (src_name, dst_name)
if key in self.calls:
self.calls[key] += 1
else:
self.calls[key] = 1 |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def _clrgen(n, h0, hr):
"""Default colour generating function Parameters n : int Number of colours to generate h0 : float Initial H value in HSV colour specification hr : float Size of H value range to use for colour generation (final H value is h0 + hr) Returns ------- clst : list of strings List of HSV format colour specification strings """ |
n0 = n if n == 1 else n-1
clst = ['%f,%f,%f' % (h0 + hr*hi/n0, 0.35, 0.85) for
hi in range(n)]
return clst |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_review_comment(self, body, commit_id, path, position):
"""Create a review comment on this pull request. All parameters are required by the GitHub API. :param str body: The comment text itself :param str commit_id: The SHA of the commit to comment on :param str path: The relative path of the file to comment on :param int position: The line index in the diff to comment on. :returns: The created review comment. :rtype: :class:`~github3.pulls.ReviewComment` """ |
url = self._build_url('comments', base_url=self._api)
data = {'body': body, 'commit_id': commit_id, 'path': path,
'position': int(position)}
json = self._json(self._post(url, data=data), 201)
return ReviewComment(json, self) if json else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def diff(self):
"""Return the diff""" |
resp = self._get(self._api,
headers={'Accept': 'application/vnd.github.diff'})
return resp.content if self._boolean(resp, 200, 404) else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_merged(self):
"""Checks to see if the pull request was merged. :returns: bool """ |
url = self._build_url('merge', base_url=self._api)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def iter_comments(self, number=-1, etag=None):
"""Iterate over the comments on this pull request. :param int number: (optional), number of comments to return. Default: -1 returns all available comments. :param str etag: (optional), ETag from a previous request to the same endpoint :returns: generator of :class:`ReviewComment <ReviewComment>`\ s """ |
url = self._build_url('comments', base_url=self._api)
return self._iter(int(number), url, ReviewComment, etag=etag) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def iter_files(self, number=-1, etag=None):
"""Iterate over the files associated with this pull request. :param int number: (optional), number of files to return. Default: -1 returns all available files. :param str etag: (optional), ETag from a previous request to the same endpoint :returns: generator of :class:`PullFile <PullFile>`\ s """ |
url = self._build_url('files', base_url=self._api)
return self._iter(int(number), url, PullFile, etag=etag) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def iter_issue_comments(self, number=-1, etag=None):
"""Iterate over the issue comments on this pull request. :param int number: (optional), number of comments to return. Default: -1 returns all available comments. :param str etag: (optional), ETag from a previous request to the same endpoint :returns: generator of :class:`IssueComment <IssueComment>`\ s """ |
url = self._build_url(base_url=self.links['comments'])
return self._iter(int(number), url, IssueComment, etag=etag) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def merge(self, commit_message='', sha=None):
"""Merge this pull request. :param str commit_message: (optional), message to be used for the merge commit :returns: bool """ |
parameters = {'commit_message': commit_message}
if sha:
parameters['sha'] = sha
url = self._build_url('merge', base_url=self._api)
json = self._json(self._put(url, data=dumps(parameters)), 200)
self.merge_commit_sha = json['sha']
return json['merged'] |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def patch(self):
"""Return the patch""" |
resp = self._get(self._api,
headers={'Accept': 'application/vnd.github.patch'})
return resp.content if self._boolean(resp, 200, 404) else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def update(self, title=None, body=None, state=None):
"""Update this pull request. :param str title: (optional), title of the pull :param str body: (optional), body of the pull request :param str state: (optional), ('open', 'closed') :returns: bool """ |
data = {'title': title, 'body': body, 'state': state}
json = None
self._remove_none(data)
if data:
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def reply(self, body):
"""Reply to this review comment with a new review comment. :param str body: The text of the comment. :returns: The created review comment. :rtype: :class:`~github3.pulls.ReviewComment` """ |
url = self._build_url('comments', base_url=self.pull_request_url)
index = self._api.rfind('/') + 1
in_reply_to = self._api[index:]
json = self._json(self._post(url, data={
'body': body, 'in_reply_to': in_reply_to
}), 201)
return ReviewComment(json, self) if json else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_member(self, login):
"""Add ``login`` to this team. :returns: bool """ |
warnings.warn(
'This is no longer supported by the GitHub API, see '
'https://developer.github.com/changes/2014-09-23-one-more-week'
'-before-the-add-team-member-api-breaking-change/',
DeprecationWarning)
url = self._build_url('members', login, base_url=self._api)
return self._boolean(self._put(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_repo(self, repo):
"""Add ``repo`` to this team. :param str repo: (required), form: 'user/repo' :returns: bool """ |
url = self._build_url('repos', repo, base_url=self._api)
return self._boolean(self._put(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def edit(self, name, permission=''):
"""Edit this team. :param str name: (required) :param str permission: (optional), ('pull', 'push', 'admin') :returns: bool """ |
if name:
data = {'name': name, 'permission': permission}
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def has_repo(self, repo):
"""Checks if this team has access to ``repo`` :param str repo: (required), form: 'user/repo' :returns: bool """ |
url = self._build_url('repos', repo, base_url=self._api)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def invite(self, username):
"""Invite the user to join this team. This returns a dictionary like so:: :param str username: (required), user to invite to join this team. :returns: dictionary """ |
url = self._build_url('memberships', username, base_url=self._api)
return self._json(self._put(url), 200) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def membership_for(self, username):
"""Retrieve the membership information for the user. :param str username: (required), name of the user :returns: dictionary """ |
url = self._build_url('memberships', username, base_url=self._api)
json = self._json(self._get(url), 200)
return json or {} |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_member(self, login):
"""Remove ``login`` from this team. :param str login: (required), login of the member to remove :returns: bool """ |
warnings.warn(
'This is no longer supported by the GitHub API, see '
'https://developer.github.com/changes/2014-09-23-one-more-week'
'-before-the-add-team-member-api-breaking-change/',
DeprecationWarning)
url = self._build_url('members', login, base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def revoke_membership(self, username):
"""Revoke this user's team membership. :param str username: (required), name of the team member :returns: bool """ |
url = self._build_url('memberships', username, base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def remove_repo(self, repo):
"""Remove ``repo`` from this team. :param str repo: (required), form: 'user/repo' :returns: bool """ |
url = self._build_url('repos', repo, base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_member(self, login, team):
"""Add ``login`` to ``team`` and thereby to this organization. .. warning:: This method is no longer valid. To add a member to a team, you must now retrieve the team directly, and use the ``invite`` method. Any user that is to be added to an organization, must be added to a team as per the GitHub api. .. note:: This method is of complexity O(n). This iterates over all teams in your organization and only adds the user when the team name matches the team parameter above. If you want constant time, you should retrieve the team and call ``add_member`` on that team directly. :param str login: (required), login name of the user to be added :param str team: (required), team name :returns: bool """ |
warnings.warn(
'This is no longer supported by the GitHub API, see '
'https://developer.github.com/changes/2014-09-23-one-more-week'
'-before-the-add-team-member-api-breaking-change/',
DeprecationWarning)
for t in self.iter_teams():
if team == t.name:
return t.add_member(login)
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def add_repo(self, repo, team):
"""Add ``repo`` to ``team``. .. note:: This method is of complexity O(n). This iterates over all teams in your organization and only adds the repo when the team name matches the team parameter above. If you want constant time, you should retrieve the team and call ``add_repo`` on that team directly. :param str repo: (required), form: 'user/repo' :param str team: (required), team name """ |
for t in self.iter_teams():
if team == t.name:
return t.add_repo(repo)
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_repo(self, name, description='', homepage='', private=False, has_issues=True, has_wiki=True, has_downloads=True, team_id=0, auto_init=False, gitignore_template=''):
"""Create a repository for this organization if the authenticated user is a member. :param str name: (required), name of the repository :param str description: (optional) :param str homepage: (optional) :param bool private: (optional), If ``True``, create a private repository. API default: ``False`` :param bool has_issues: (optional), If ``True``, enable issues for this repository. API default: ``True`` :param bool has_wiki: (optional), If ``True``, enable the wiki for this repository. API default: ``True`` :param bool has_downloads: (optional), If ``True``, enable downloads for this repository. API default: ``True`` :param int team_id: (optional), id of the team that will be granted access to this repository :param bool auto_init: (optional), auto initialize the repository. :param str gitignore_template: (optional), name of the template; this is ignored if auto_int = False. :returns: :class:`Repository <github3.repos.Repository>` .. warning: ``name`` should be no longer than 100 characters """ |
url = self._build_url('repos', base_url=self._api)
data = {'name': name, 'description': description,
'homepage': homepage, 'private': private,
'has_issues': has_issues, 'has_wiki': has_wiki,
'has_downloads': has_downloads, 'auto_init': auto_init,
'gitignore_template': gitignore_template}
if team_id > 0:
data.update({'team_id': team_id})
json = self._json(self._post(url, data), 201)
return Repository(json, self) if json else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def conceal_member(self, login):
"""Conceal ``login``'s membership in this organization. :returns: bool """ |
url = self._build_url('public_members', login, base_url=self._api)
return self._boolean(self._delete(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def create_team(self, name, repo_names=[], permission=''):
"""Assuming the authenticated user owns this organization, create and return a new team. :param str name: (required), name to be given to the team :param list repo_names: (optional) repositories, e.g. ['github/dotfiles'] :param str permission: (optional), options: - ``pull`` -- (default) members can not push or administer repositories accessible by this team - ``push`` -- members can push and pull but not administer repositories accessible by this team - ``admin`` -- members can push, pull and administer repositories accessible by this team :returns: :class:`Team <Team>` """ |
data = {'name': name, 'repo_names': repo_names,
'permission': permission}
url = self._build_url('teams', base_url=self._api)
json = self._json(self._post(url, data), 201)
return Team(json, self._session) if json else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def edit(self, billing_email=None, company=None, email=None, location=None, name=None):
"""Edit this organization. :param str billing_email: (optional) Billing email address (private) :param str company: (optional) :param str email: (optional) Public email address :param str location: (optional) :param str name: (optional) :returns: bool """ |
json = None
data = {'billing_email': billing_email, 'company': company,
'email': email, 'location': location, 'name': name}
self._remove_none(data)
if data:
json = self._json(self._patch(self._api, data=dumps(data)), 200)
if json:
self._update_(json)
return True
return False |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def is_public_member(self, login):
"""Check if the user with login ``login`` is a public member. :returns: bool """ |
url = self._build_url('public_members', login, base_url=self._api)
return self._boolean(self._get(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def iter_repos(self, type='', number=-1, etag=None):
"""Iterate over repos for this organization. :param str type: (optional), accepted values: ('all', 'public', 'member', 'private', 'forks', 'sources'), API default: 'all' :param int number: (optional), number of members to return. Default: -1 will return all available. :param str etag: (optional), ETag from a previous request to the same endpoint :returns: generator of :class:`Repository <github3.repos.Repository>` """ |
url = self._build_url('repos', base_url=self._api)
params = {}
if type in ('all', 'public', 'member', 'private', 'forks', 'sources'):
params['type'] = type
return self._iter(int(number), url, Repository, params, etag) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def iter_teams(self, number=-1, etag=None):
"""Iterate over teams that are part of this organization. :param int number: (optional), number of teams to return. Default: -1 returns all available teams. :param str etag: (optional), ETag from a previous request to the same endpoint :returns: generator of :class:`Team <Team>`\ s """ |
url = self._build_url('teams', base_url=self._api)
return self._iter(int(number), url, Team, etag=etag) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def publicize_member(self, login):
"""Make ``login``'s membership in this organization public. :returns: bool """ |
url = self._build_url('public_members', login, base_url=self._api)
return self._boolean(self._put(url), 204, 404) |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def team(self, team_id):
"""Returns Team object with information about team specified by ``team_id``. :param int team_id: (required), unique id for the team :returns: :class:`Team <Team>` """ |
json = None
if int(team_id) > 0:
url = self._build_url('teams', str(team_id))
json = self._json(self._get(url), 200)
return Team(json, self._session) if json else None |
<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
def edit(self, state):
"""Edit the user's membership. :param str state: (required), the state the membership should be in. Only accepts ``"active"``. :returns: itself """ |
if state and state.lower() == 'active':
data = dumps({'state': state.lower()})
json = self._json(self._patch(self._api, data=data))
self._update_attributes(json)
return self |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.