rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
equal_to("got: bananas").matches(44, mismatch_output) assert_equals(["44"], mismatch_output) | equal_to("banana").matches("coconut", mismatch_output) assert_equals(["got 'coconut'"], mismatch_output) | def test_equal_to_writes_str_of_non_matching_values_to_mismatch_output(): mismatch_output = [] equal_to("got: bananas").matches(44, mismatch_output) assert_equals(["44"], mismatch_output) |
def test_equal_to_does_not_write_to_mismatch_output_if_it_matches(): | def test_is_does_not_write_to_mismatch_output_if_it_matches(): | def test_equal_to_does_not_write_to_mismatch_output_if_it_matches(): m = {} mismatch_output = [] assert is_(None).matches(None, mismatch_output) assert is_(m).matches(m, mismatch_output) assert not mismatch_output |
t_ = {'tolower':'uppercase','toupper':'lowercase','none':'none'} | t_ = {'tolower':'lowercase','toupper':'uppercase','none':'none'} | def handle_attr_changes(sym): # http://www.w3schools.com/css/pr_text_text-transform.asp # http://code.google.com/p/mapnik-utils/issues/detail?id=32&colspec=ID%20Type%20Status%20Priority%20Component%20Owner%20Summary text_transform = sym.attrib.get('text_convert') # note: css supports text-transform:capitalize but Mapni... |
query = Query(self.envelope(),1.0) | query = Query(self.envelope()) | def all_features(self): query = Query(self.envelope(),1.0) for fld in self.fields(): query.add_property_name(fld) return self.features(query).features |
class _injector(object, metaclass=_MapnikMetaclass): pass | _injector = _MapnikMetaclass('_injector', (object, ), {}) | def __init__(self, name, bases, dict): for b in bases: if type(b) not in (self, type): for k,v in list(dict.items()): if hasattr(b, k): setattr(b, '_c_'+k, getattr(b, k)) setattr(b,k,v) return type.__init__(self, name, bases, dict) |
eq_(s.transform, 'matrix(1.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000)') | eq_(s.transform, 'matrix(1, 0, 0, 1, 0, 0)') | def test_shieldsymbolizer_init(): s = mapnik2.ShieldSymbolizer(mapnik2.Expression('[Field Name]'), 'DejaVu Sans Bold', 6, mapnik2.Color('#000000'), mapnik2.PathExpression('../data/images/dummy.png')) eq_(s.anchor, (0.0,0.5,)) eq_(s.displacement, (0.0,0.0)) eq_(s.allow_overlap, False) eq_(s.avoid_edges, False) eq_(s.cha... |
geometry -- inline WKT text of the geometry | wkt -- inline WKT text of the geometry | def Geos(**keywords): """Create a GEOS Vector Datasource. Required keyword arguments: geometry -- inline WKT text of the geometry Optional keyword arguments: multiple_geometries -- boolean, direct the GEOS wkt reader to interpret as multigeometries (default False) extent -- manually specified data extent (comma delim... |
eq_(num_feats, 3) | eq_(num_feats, 5) def test_reading_json_from_string(): json = open('../data/json/points.json','r').read() lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Ogr(file=json,layer_by_index=0) features = lyr.datasource.all_features() num_feats = len(features) eq_(num_feats, 5) | def test_total_feature_count_json(): lyr = mapnik2.Layer('test') lyr.datasource = mapnik2.Ogr(file='../data/json/points.json',layer_by_index=0) features = lyr.datasource.all_features() num_feats = len(features) eq_(num_feats, 3) |
class _Symbolizer(Symbolizer,_injector): def symbol(self): return getattr(self,self.type())() | def _as_wkb(self, geometry): if hasattr(geometry, 'wkb'): # a shapely.geometry.Geometry geometry = geometry.wkb if isinstance(geometry, str): # ignoring unicode un purpose for type_ in ('POINT', 'POLYGON', 'LINE'): if type_ in geometry: # A WKT encoded string from shapely import wkt geometry = wkt.loads(geometry).wkb r... | |
'Color', 'Coord', | 'Color', 'Coord', 'ColorBand', | def register_fonts(path=fontscollectionpath): """Recursively register fonts using path argument as base directory""" for dirpath, _, filenames in os.walk(path): for filename in filenames: if os.path.splitext(filename)[1] == '.ttf': FontEngine.instance().register_font(os.path.join(dirpath, filename)) |
'Geometry2d', | 'Geometry2d', 'GlyphSymbolizer', | def register_fonts(path=fontscollectionpath): """Recursively register fonts using path argument as base directory""" for dirpath, _, filenames in os.walk(path): for filename in filenames: if os.path.splitext(filename)[1] == '.ttf': FontEngine.instance().register_font(os.path.join(dirpath, filename)) |
if hasattr(tree,'xinclude') | if hasattr(tree,'xinclude'): | def fixup_sym_attributes(sym): #if not sym.find('CssParameter'): # return attrib = {} metawriter = sym.attrib.get('meta-writer') if metawriter: attrib['meta-writer'] = metawriter metaoutput = sym.attrib.get('meta-output') if metaoutput: attrib['meta-output'] = metaoutput for css in sym.findall('CssParameter'): key ... |
updated_xml = etree.tostring(tree) (handle, path) = tempfile.mkstemp(suffix='.xml', prefix='mapnik-') os.close(handle) open(path,'w').write(updated_xml) indented = etree.parse(path) indent(indented.getroot()) output_file = open(sys.argv[2], 'w') output_file.write(etree.tostring(indented)) output_file.close() | indent(root) tree.write(sys.argv[2]) | def fixup_sym_attributes(sym): #if not sym.find('CssParameter'): # return attrib = {} metawriter = sym.attrib.get('meta-writer') if metawriter: attrib['meta-writer'] = metawriter metaoutput = sym.attrib.get('meta-output') if metaoutput: attrib['meta-output'] = metaoutput for css in sym.findall('CssParameter'): key ... |
assert len(imdata) > 0 | bytes = [imdata[i:i+4] for i in xrange(0, len(imdata), 4)] | def test_dataraster_coloring(): srs = '+init=epsg:32630' lyr = mapnik2.Layer('dataraster') lyr.datasource = mapnik2.Gdal( file = '../data/raster/dataraster.tif', band = 1, ) lyr.srs = srs _map = mapnik2.Map(256,256, srs) style = mapnik2.Style() rule = mapnik2.Rule() sym = mapnik2.RasterSymbolizer() # Assigning a colori... |
assert '\xff\xff\xff\x00' in imdata | assert '\xff\xff\x00\xff' in bytes | def test_dataraster_coloring(): srs = '+init=epsg:32630' lyr = mapnik2.Layer('dataraster') lyr.datasource = mapnik2.Gdal( file = '../data/raster/dataraster.tif', band = 1, ) lyr.srs = srs _map = mapnik2.Map(256,256, srs) style = mapnik2.Style() rule = mapnik2.Rule() sym = mapnik2.RasterSymbolizer() # Assigning a colori... |
stop_loss_condition, anagrad=False, epsilon_init=1e-6, verbose=True, callback=None): | stop_loss_condition, anagrad=False, epsilon=1e-6, verbose=True, callback=None): | def __init__(self, x_init, fun, line_search, convergence_condition, stop_loss_condition, anagrad=False, epsilon_init=1e-6, verbose=True, callback=None): """Initialize the minimizer |
self.epsilon = epsilon_init self.epsilon_max = epsilon_init | self.epsilon = epsilon | def __init__(self, x_init, fun, line_search, convergence_condition, stop_loss_condition, anagrad=False, epsilon_init=1e-6, verbose=True, callback=None): """Initialize the minimizer |
if self.step_rms > 0: self.epsilon = min(self.step_rms*1e-2, self.epsilon_max) | def _iterate(self): """Run the conjugate gradient algorithm""" self.f = self.fun(self.x) self._compute_direction_sd() self._update_sd() # the cg loop self.counter = 0 while True: if self.counter % 20 == 0: self._print_header() self._screen("% 5i " % self.counter) # perform a line search line_success = self._line_opt()... | |
tmp = self.x.copy() | def _compute_direction_sd(self): """Update the gradient""" self.direction_sd_old[:] = self.direction_sd if self.anagrad: self.f, tmp = self.fun(self.x, do_gradient=True) self.direction_sd[:] = -tmp else: tmp = self.x.copy() for j in xrange(len(self.x)): tmp[j] += self.epsilon self.direction_sd[j] = -(self.fun(tmp) - se... | |
tmp[j] += self.epsilon self.direction_sd[j] = -(self.fun(tmp) - self.f)/self.epsilon tmp[j] = self.x[j] | xh = self.x.copy() xh[j] += 0.5*self.epsilon xl = self.x.copy() xl[j] -= 0.5*self.epsilon self.direction_sd[j] = -(self.fun(xh) - self.fun(xl))/self.epsilon | def _compute_direction_sd(self): """Update the gradient""" self.direction_sd_old[:] = self.direction_sd if self.anagrad: self.f, tmp = self.fun(self.x, do_gradient=True) self.direction_sd[:] = -tmp else: tmp = self.x.copy() for j in xrange(len(self.x)): tmp[j] += self.epsilon self.direction_sd[j] = -(self.fun(tmp) - se... |
def __set__(self, instance, value): | def __set__(self, instance, value, do_check=True): | def __set__(self, instance, value): if value is None and not self.none: raise TypeError("This attribute may not be assigned None.") if self.ptype is not None and issubclass(self.ptype, tuple) and value is not None: # convert to a tuple of it is supposed one. value = tuple(value) if not (self.ptype is None or value is N... |
setattr(instance, self.attribute_name, value) | def __set__(self, instance, value): if value is None and not self.none: raise TypeError("This attribute may not be assigned None.") if self.ptype is not None and issubclass(self.ptype, tuple) and value is not None: # convert to a tuple of it is supposed one. value = tuple(value) if not (self.ptype is None or value is N... | |
descriptor.__set__(self, val) | descriptor.__set__(self, val, do_check=False) for key, val in state.iteritems(): descriptor = self.__class__.__dict__[key] descriptor.check_wrapper(self, val) | def __setstate__(self, state): """Part of the pickle protocol""" for key, val in state.iteritems(): descriptor = self.__class__.__dict__[key] if not isinstance(descriptor, ReadOnlyAttribute): raise RunTimeError("Got wrong class attribute during unpickling.") descriptor.__set__(self, val) |
self._dependencies.append(package) package._dependents.append(package) | self._dependencies.append(package.fullname) package._dependents.append(package.fullname) | def depends_on(self, package): self._dependencies.append(package) package._dependents.append(package) |
return [(k,v) for k,v in module.__dict__ if not k.startswith('_')] | return [(k,v) for k,v in module.__dict__.iteritems() if not k.startswith('_')] | def filter_local(module): return [(k,v) for k,v in module.__dict__ if not k.startswith('_')] |
def remove_package(self, name): | def remove_package(self, name, recurse=False): | def remove_package(self, name): shortname, version = _splitname(name) current_version = os.environ.get('SETPKG_VERSION_%s' % shortname, None) if current_version is None: raise PackageError(shortname, "package is not currently set") package = self.shelf[shortname] if version: if package.version != version: raise Invalid... |
def unsetpkg(packages, update_pypath=False, pid=None): | def unsetpkg(packages, recurse=False, update_pypath=False, pid=None): | def unsetpkg(packages, update_pypath=False, pid=None): """ :param update_pythonpath: set to True if changes to PYTHONPATH should be reflected in sys.path :param force: set to True if package should be re-run (unloaded, then loaded again) if already loaded """ session = Session(pid=pid) for name in packages: session.rem... |
session.remove_package(name) | session.remove_package(name, recurse=recurse) | def unsetpkg(packages, update_pypath=False, pid=None): """ :param update_pythonpath: set to True if changes to PYTHONPATH should be reflected in sys.path :param force: set to True if package should be re-run (unloaded, then loaded again) if already loaded """ session = Session(pid=pid) for name in packages: session.rem... |
session = Session(pid=pid) versions = session['__versions__'] | VER_PREFIX = 'SETPKG_VERSION_' versions = dict([(k[len(VER_PREFIX):] ,os.environ[k]) for k in os.environ if k.startswith(VER_PREFIX)]) | def list_active_packages(package=None, pid=None): session = Session(pid=pid) versions = session['__versions__'] if package: if package in versions: print '%s-%s' % (package, versions[package]) else: print "package %s is not currently active" % package else: return ['%s-%s' % (pkg, versions[pkg]) for pkg in sorted(versi... |
removed = unsetpkg(packages, pid=args.pid) | removed = unsetpkg(packages, pid=args.pid, recurse=args.recurse) | def f(): if args.all: packages = list_active_packages(pid=args.pid) else: packages = args.packages removed = unsetpkg(packages, pid=args.pid) changed = set([]) for package in removed: changed.update(package.environ.keys()) return sorted(changed) |
if f.endswith('.pykg'): | if f.endswith('.pykg') and f not in discovered: discovered.add(f) | def walk_package_files(): for path in _pkgpaths(): for f in sorted(os.listdir(path)): if f.endswith('.pykg'): yield os.path.join(path, f) |
pass | def __str__(self): return 'error during execution of %s.pykg file: %s' % (self.package, self.detail) | def __str__(self): return '%s: invalid version %s: %s' % (self.package, self.bad_version, self.detail) |
shutil.copy(old_filename, filename) | logger.info('copying cache from %s to %s' % (old_filename, filename)) try: shutil.copy(old_filename, filename) except: for suffix in ['.bak', '.dat', '.dir']: shutil.copy(old_filename + suffix, filename + suffix) | def _open_shelf(self, protocol=None, writeback=False, pid=None): """ """ SESSION_PREFIX = 'setpkg_session_' if 'SETPKG_SESSION' in os.environ: filename = os.environ['SETPKG_SESSION'] # see if our pid differs from the existing if pid: old_pid = filename.rsplit('_')[-1] if pid != old_pid: # make a unique copy for us old_... |
logger.info( "opening existing session %s" % filename ) | def _open_shelf(self, protocol=None, writeback=False, pid=None): """ """ SESSION_PREFIX = 'setpkg_session_' if 'SETPKG_SESSION' in os.environ: filename = os.environ['SETPKG_SESSION'] # see if our pid differs from the existing if pid: old_pid = filename.rsplit('_')[-1] if pid != old_pid: # make a unique copy for us old_... | |
logger.info( "opening new session %s" % filename ) | def _open_shelf(self, protocol=None, writeback=False, pid=None): """ """ SESSION_PREFIX = 'setpkg_session_' if 'SETPKG_SESSION' in os.environ: filename = os.environ['SETPKG_SESSION'] # see if our pid differs from the existing if pid: old_pid = filename.rsplit('_')[-1] if pid != old_pid: # make a unique copy for us old_... | |
return self._name in os.environ and self.value() | return bool(self.value()) | def __nonzero__(self): return self._name in os.environ and self.value() |
return "alias %s='%s';" % ( key, value) | return "%(key)s() { %(value)s; };\nexport -f %(key)s;" % locals() | def alias(self, key, value): return "alias %s='%s';" % ( key, value) |
if self.config.has_option('main', 'default-version'): version = self.config.get('main', 'default-version') elif len(self.versions) == 1: version = self.versions[0] else: raise PackageError(self.name, "no 'default-version' specified in package header ([main] section)") | version = self.default_version | def version(self): version = self._version if not version: if self.config.has_option('main', 'default-version'): version = self.config.get('main', 'default-version') elif len(self.versions) == 1: version = self.versions[0] else: raise PackageError(self.name, "no 'default-version' specified in package header ([main] sec... |
raise | raise PackageRemovedError(self.name) | def hash(self): try: version, hash = os.environ[VER_PREFIX + self.name].split(META_SEP) except KeyError: # TODO: different error raise self.version = version return hash |
raise | raise PackageRemovedError(self.name) | def version(self): try: version, hash = os.environ[VER_PREFIX + self.name].split(META_SEP) except KeyError: # TODO: different error raise if self._version: if self._version != version: raise InvalidPackageVersion(self.name, self._version, 'active version is %s' % version) self.hash = hash return version |
self.remove_package(depend.fullname, depth=depth+1) | if depend.name in current_versions(): self.remove_package(depend.fullname, depth=depth+1) | def remove_package(self, name, recurse=False, depth=0, reloading=False): shortname, version = _splitname(name) curr_version = current_version(shortname) if curr_version is None: raise PackageError(shortname, "package is not currently set") package = self.shelf[shortname] if version: if package.version != version: raise... |
self._status('skipping', shortname) | def add_package(self, name, parent=None, force=False): package = get_package(name) shortname = package.name current_version = os.environ.get('SETPKG_VERSION_%s' % shortname, None) if force: self.remove_package(shortname) # check if we've already been set: elif current_version is not None: if not package.explicit_versi... | |
if not self.has_key(shortname): | current_version = os.environ.get('SETPKG_VERSION_%s' % shortname, None) if current_version is None: | def remove_package(self, name): shortname, version = _splitname(name) if not self.has_key(shortname): raise PackageError(shortname, "package is not currently set") package = self.shelf[shortname] if version: if package.version != version: raise InvalidPackageVersion(package, version, "cannot be removed because it is no... |
os.environ.pop('SETPKG_VERSION_%s' % shortname) | def remove_package(self, name): shortname, version = _splitname(name) if not self.has_key(shortname): raise PackageError(shortname, "package is not currently set") package = self.shelf[shortname] if version: if package.version != version: raise InvalidPackageVersion(package, version, "cannot be removed because it is no... | |
import px return px.__version__ | from os.path import join, dirname sys.path.insert(0, join(dirname(__file__), "lib")) import p4lib return p4lib.__version__ | def _getVersion(): import px return px.__version__ |
super(drQ,self).__init__(*args,**kwargs) | super(drQt,self).__init__(*args,**kwargs) | def __init__(self,*args,**kwargs): super(drQ,self).__init__(*args,**kwargs) try: drqueue.request_job_list(drqueue.CLIENT) except: raise "NO MASTER FOUND" self.setupUi(self) self._timer_=drQtLib.Timer(parent=self) self.timer_interrupt=0 self.jobs_tab_list=[] self.nodes_tab_list=[] self.setup_main() self.PB_refresh.cli... |
return urlparse.unquote(link.getAttribute(attribute_name).encode('utf-8')) | return urllib.unquote(link.getAttribute(attribute_name).encode('utf-8')) | def extract_path(link, attribute_name = 'href'): return urlparse.unquote(link.getAttribute(attribute_name).encode('utf-8')) |
self.response.out.write('No permission: Picasa') | self.response.out.write('No permission for Picasa.') | def post(self): archive = self.request.get("fbContents") if archive: archive_file = StringIO(archive) archive_reader = zipfile.ZipFile(archive_file, 'r') archive_files = archive_reader.namelist() |
self.response.out.write('No file') | self.response.out.write('No file.') | def post(self): archive = self.request.get("fbContents") if archive: archive_file = StringIO(archive) archive_reader = zipfile.ZipFile(archive_file, 'r') archive_files = archive_reader.namelist() |
def check_user_service(self): | def check_user_services(self): | def check_user_service(self): return models.User.gql('WHERE name = :1', self.user).get().services |
name = getattr(comp, '__name__', '') | name = getattr(comp, '__name__', None) | def _extractUtilities(self): fragment = self._doc.createDocumentFragment() |
child.setAttribute('id', name) | if name is not None: child.setAttribute('id', name) else: child.setAttribute('id', ofs_id) | def _extractUtilities(self): fragment = self._doc.createDocumentFragment() |
README = ( _docs_doc('index.rst') | README = ( open('README.txt').read() | def _docs_doc(name): f = open(os.path.join(docs, name)) return f.read() |
+ _boundary + "\nDownload\n========" | def _docs_doc(name): f = open(os.path.join(docs, name)) return f.read() | |
setup(name='Products.%s' % NAME, | setup(name='Products.GenericSetup', | def _docs_doc(name): f = open(os.path.join(docs, name)) return f.read() |
events.add_event_listener("reverse-linefeed", self._reverse_linefeed) | def attach(self, events): """ Attach this screen to a events that processes commands and dispatches events. Sets up the appropriate event handlers so that the screen will update itself automatically as the events processes data. """ | |
def _reverse_linefeed(self): """ Performs a reverse index and then a carriage return. """ self._reverse_index() self.x = 0 | def _reverse_linefeed(self): """ Performs a reverse index and then a carriage return. """ | |
def process(self, input): while len(input) > 0: self.consume(input[0]) input = input[1:] | def process(self, chars): """ Consume a string of and advance the state as necessary. """ while len(chars) > 0: self.consume(chars[0]) chars = chars[1:] | def process(self, input): while len(input) > 0: self.consume(input[0]) input = input[1:] |
self.display = [row + (" " * (cols - self.size[1])) for row in self.display] | self.display = \ [row + (" " * (cols - self.size[1])) for row in self.display] | def resize(self, (rows, cols)): # Honestly though, you can't trust anyone these days... assert(rows > 0 and cols > 0) |
def _erase(self, row, type): if type == 0x31: | def _erase(self, row, type_of): """ Erases the row in a specific way, depending on the type_of. """ if type_of == 0x31: | def _erase(self, row, type): if type == 0x31: # Erase from the beginning of the line to the cursor, including it row = " " * (self.x+1) + row[self.x+1:] elif type == 0x32: # Erase the entire line. row = " " * self.size[1] elif 0x30: # Erase from the cursor to the end of line, including the cursor row = row[:self.x] + "... |
elif type == 0x32: | elif type_of == 0x32: | def _erase(self, row, type): if type == 0x31: # Erase from the beginning of the line to the cursor, including it row = " " * (self.x+1) + row[self.x+1:] elif type == 0x32: # Erase the entire line. row = " " * self.size[1] elif 0x30: # Erase from the cursor to the end of line, including the cursor row = row[:self.x] + "... |
def _erase_in_line(self, type=0x30): row = self._erase(self.display[self.y], type) | def _erase_in_line(self, type_of=0x30): row = self._erase(self.display[self.y], type_of) | def _erase_in_line(self, type=0x30): row = self._erase(self.display[self.y], type) self.display[self.y] = row |
def _erase_in_display(self, type=0x30): self.display = [self._erase(r, type) for r in self.display] | def _erase_in_display(self, type_of=0x30): self.display = [self._erase(r, type_of) for r in self.display] | def _erase_in_display(self, type=0x30): self.display = [self._erase(r, type) for r in self.display] |
def _clear_tab_stop(self, type=0x33): if type == 0x30: | def _clear_tab_stop(self, type_of=0x33): if type_of == 0x30: | def _clear_tab_stop(self, type=0x33): if type == 0x30: # Clears a horizontal tab stop at cursor position. try: self.tabstops.remove(self.x) except ValueError,e: pass elif type == 0x33: # Clears all horizontal tab stops self.tabstops = [] |
try: self.tabstops.remove(self.x) except ValueError,e: pass elif type == 0x33: | try: self.tabstops.remove(self.x) except ValueError: pass elif type_of == 0x33: | def _clear_tab_stop(self, type=0x33): if type == 0x30: # Clears a horizontal tab stop at cursor position. try: self.tabstops.remove(self.x) except ValueError,e: pass elif type == 0x33: # Clears all horizontal tab stops self.tabstops = [] |
self['LOGGING'] = self["ansi"] del self['LOGGING'] | self['LOGGING']["ansi"] = self["ansi"] del self['ansi'] | def updates(self): """ This function does a variety of things to try to gracefully update config files. """ if "version" not in self: # before we started tracking the config file version if "ansi" in self: self['LOGGING'] = self["ansi"] del self['LOGGING'] if self.has_key("repository"): # repository was an old way of s... |
(self.r_index,total_reps)) | (self.r_index+1,total_reps)) | def check_complete(self): complete = True missing_maps = {} total_reps = self.instance.experiment.get_num_replicates() self.log.debug("Checking replicate %d/%d is complete" % \ (self.r_index,total_reps)) ls_keys = self.instance.experiment.get_lifestage_ids() for ls_key in ls_keys: try: self.get_saved_maps(ls_key) excep... |
log.error("Model file %s is not a file."%model_fn) | self.log.error("Model file %s is not a file."%model_fn) | def add_model(self, model_fn): import shutil if not os.path.isfile(model_fn): log.error("Model file %s is not a file."%model_fn) sys.exit(5) |
self.zip_maps(map_list,r.get_img_filenames(ls, extension=False, gif=True)) | zip_fn = r.get_img_filenames(ls, extension=False, gif=True)[:-5] self.zip_maps(map_list, zip_fn) | def do_instance_map_pack(self,i): # TODO: only overwrite files if -o flag is set import OutputFormats model_name = i.experiment.get_name() ls = self.options.output_lifestage if ls not in i.experiment.get_lifestage_ids(): self.log.error("No such lifestage called %s in model." % str(ls)) raise InvalidLifestageException()... |
map_list.append(self.export_map(m,img_filenames[t])) | map_list.append(self.export_map(m,img_filenames[t],envelope=True)) | def do_instance_map_pack(self,i): # TODO: only overwrite files if -o flag is set import OutputFormats model_name = i.experiment.get_name() ls = self.options.output_lifestage if ls not in i.experiment.get_lifestage_ids(): self.log.error("No such lifestage called %s in model." % str(ls)) raise InvalidLifestageException()... |
self.zip_maps(map_list,i.get_occ_envelope_img_filenames(ls, extension=False, gif=True) ) | zip_fn = i.get_occ_envelope_img_filenames(ls, extension=False, gif=True)[:-5] self.zip_maps(map_list, zip_fn) | def do_instance_map_pack(self,i): # TODO: only overwrite files if -o flag is set import OutputFormats model_name = i.experiment.get_name() ls = self.options.output_lifestage if ls not in i.experiment.get_lifestage_ids(): self.log.error("No such lifestage called %s in model." % str(ls)) raise InvalidLifestageException()... |
cmd = cmd % (map, out_fn, 'Float32') | if self.float64: cmd = cmd % (map, out_fn, 'Float64') else: cmd = cmd % (map, out_fn, 'Float32') | def export_map(self,map,out_fn,envelope=False): old_region = "ExportActionBackupRegion" g = GRASSInterface.get_g() g.run_command('g.region --o save='+old_region) g.set_region(raster=map) cmd = 'r.out.gdal input=%s output=%s.tif format=GTiff type=%s createopt="COMPRESS=PACKBITS,INTERLEAVE=PIXEL"' if envelope: cmd = cmd ... |
g.run_command(cmd) g.set_region(old_region) return out_fn + ".tif" | try: g.run_command(cmd) out_fn += ".tif" except GRASSInterface.GRASSCommandException, e: if "Precision loss" in e.stderr: self.float64 = True out_fn = self.export_map(map,out_fn,envelope) finally: g.set_region(old_region) return out_fn | def export_map(self,map,out_fn,envelope=False): old_region = "ExportActionBackupRegion" g = GRASSInterface.get_g() g.run_command('g.region --o save='+old_region) g.set_region(raster=map) cmd = 'r.out.gdal input=%s output=%s.tif format=GTiff type=%s createopt="COMPRESS=PACKBITS,INTERLEAVE=PIXEL"' if envelope: cmd = cmd ... |
ls_name = param_name[3:len(param_name)] | ls_name = param_name[4:len(param_name)] print "ls stage is " + ls_name print "pop_maps keys " + str(pop_maps) | def build_matrix(self, index_value, coords, pop_maps): tv_list=[] |
expanded_expression = expanded_expression.replace(param_name, pop_maps[ls_name]) | expanded_expression = expanded_expression.replace(param_name, str(pop_maps[ls_name])) | def build_matrix(self, index_value, coords, pop_maps): tv_list=[] |
tv_list.append(eval(expanded_expression)) | try: tv_list.append(eval(expanded_expression)) except ZeroDivisionError: self.log.error("ZeroDivisionError in expression: %s" % expanded_expression) | def build_matrix(self, index_value, coords, pop_maps): tv_list=[] |
output_file = str(output_file_source[0].childNodes[0].data) | output_file = str(output_file_source[0].childNodes[0].data).strip() | def xml_to_output_file(self): x = self.xml_dom.getElementsByTagName("populationModule")[0] output_file_source = x.getElementsByTagName("outputFile") output_file = str(output_file_source[0].childNodes[0].data) return output_file |
index = str(index[0].childNodes[0].data) | index = str(index[0].childNodes[0].data).strip() | def xml_to_param(self, model_dir): x = self.xml_dom.getElementsByTagName("populationModule")[0] parameters = x.getElementsByTagName("ParameterValue") param_dict = {} |
dist = str(dist[0].childNodes[0].data) | dist = str(dist[0].childNodes[0].data).strip() | def xml_to_param(self, model_dir): x = self.xml_dom.getElementsByTagName("populationModule")[0] parameters = x.getElementsByTagName("ParameterValue") param_dict = {} |
value_list.append(str(v.childNodes[0].data)) | value_list.append(str(v.childNodes[0].data).strip()) | def xml_to_param(self, model_dir): x = self.xml_dom.getElementsByTagName("populationModule")[0] parameters = x.getElementsByTagName("ParameterValue") param_dict = {} |
value_list.append(str(v.childNodes[0].data)) else: value_list.append(float(v.childNodes[0].data)) except: pass | value_list.append(str(v.childNodes[0].data).strip()) else: value_list.append(float(v.childNodes[0].data.strip())) except: pass | def xml_to_param(self, model_dir): x = self.xml_dom.getElementsByTagName("populationModule")[0] parameters = x.getElementsByTagName("ParameterValue") param_dict = {} |
position = int(position[0].childNodes[0].data) | position = int(position[0].childNodes[0].data.strip()) | def xml_to_expression_list(self): x = self.xml_dom.getElementsByTagName("populationModule")[0] expressions = x.getElementsByTagName("expression") expression_list = [0]*(self.tm_size * self.tm_size) |
formula = str(formula[0].childNodes[0].data) | formula = str(formula[0].childNodes[0].data).strip() | def xml_to_expression_list(self): x = self.xml_dom.getElementsByTagName("populationModule")[0] expressions = x.getElementsByTagName("expression") expression_list = [0]*(self.tm_size * self.tm_size) |
index = str(index[0].childNodes[0].data) | index = str(index[0].childNodes[0].data).strip() | def get_coda_files_in_xml(self): x = self.xml_dom.getElementsByTagName("populationModule")[0] parameters = x.getElementsByTagName("ParameterValue") coda_files = [] |
coda_files.append(str(v.childNodes[0].data)) | coda_files.append(str(v.childNodes[0].data).strip()) | def get_coda_files_in_xml(self): x = self.xml_dom.getElementsByTagName("populationModule")[0] parameters = x.getElementsByTagName("ParameterValue") coda_files = [] |
os.path.join(os.path.dirname(sys.argv[0]), "mdig", "ImageShow.py"), fileToWatch]).pid | os.path.join(os.path.dirname(sys.argv[0]), "mdig", "imageshow.py"), fileToWatch]).pid | def spawn_display(self, fileToWatch): pid = Popen(["python", os.path.join(os.path.dirname(sys.argv[0]), "mdig", "ImageShow.py"), fileToWatch]).pid return pid |
self.coda = [] self.coda.append(read_array(index)) | self.coda = {} self.coda_index = read_array(index) | def __init__(self, source, index, dist, vals): self.data = [0] self.source = source self.coda = None self.log = logging.getLogger("mdig.paramgen") print '%s %s %s %s is parameter value source' %(source, index, dist, vals) try: if source == 'map': # TODO create a GRASSInterface command to load map to an array g = ... |
for j in range(len(self.coda[0])): self.coda.append(temp[int(self.coda[0][j,1])-1:int(self.coda[0][j,2]),1]) | for j in range(len(self.coda_index[:,0])): self.coda[j+1] = temp[int(self.coda_index[j,1])-1:int(self.coda_index[j,2]),1] | def __init__(self, source, index, dist, vals): self.data = [0] self.source = source self.coda = None self.log = logging.getLogger("mdig.paramgen") print '%s %s %s %s is parameter value source' %(source, index, dist, vals) try: if source == 'map': # TODO create a GRASSInterface command to load map to an array g = ... |
for j in range(len(self.coda[0])): | for j in range(len(self.coda_index[:,0])): | def __init__(self, source, index, dist, vals): self.data = [0] self.source = source self.coda = None self.log = logging.getLogger("mdig.paramgen") print '%s %s %s %s is parameter value source' %(source, index, dist, vals) try: if source == 'map': # TODO create a GRASSInterface command to load map to an array g = ... |
temp[int(self.coda[0][j,1]-1):int(self.coda[0][j,2]), 1])) | temp[int(self.coda_index[j,1]-1):int(self.coda_index[j,2]), 1])) | def __init__(self, source, index, dist, vals): self.data = [0] self.source = source self.coda = None self.log = logging.getLogger("mdig.paramgen") print '%s %s %s %s is parameter value source' %(source, index, dist, vals) try: if source == 'map': # TODO create a GRASSInterface command to load map to an array g = ... |
param_dict[parameter][index] = ParamGenerator(source, index, dist, | if source == 'CODA': param_dict[parameter]["None"] = ParamGenerator(source, index, dist, value_list) else: param_dict[parameter][index] = ParamGenerator(source, index, dist, | def xml_to_param(self): x = self.xml_dom.firstChild parameters = x.getElementsByTagName("ParameterValue") param_dict = {} |
def _fill_in_map_parameters(self,rep,p): | def _fill_in_map_parameters(self,rep,p,map_name): | def _fill_in_map_parameters(self,rep,p): ls_id = self.get_lifestage_id() # fill in map parameters for p_name,val_tuple in p.items(): value = val_tuple[0] if len(val_tuple) > 1: a = val_tuple[1] else: a = None if value == "currentMap": p[p_name]=in_name elif value == "previousMap": # TODO currently get_previous_maps is... |
p[p_name]=in_name | p[p_name]=map_name | def _fill_in_map_parameters(self,rep,p): ls_id = self.get_lifestage_id() # fill in map parameters for p_name,val_tuple in p.items(): value = val_tuple[0] if len(val_tuple) > 1: a = val_tuple[1] else: a = None if value == "currentMap": p[p_name]=in_name elif value == "previousMap": # TODO currently get_previous_maps is... |
p=self._fill_in_map_parameters(rep,self.get_params()) | p=self._fill_in_map_parameters(rep,self.get_params(),in_name) | def run(self,in_name,rep): """ Run the analysis on a replicate. |
base_cmd = "" | base_cmd = cmd | def run(self,in_name,rep): """ Run the analysis on a replicate. |
g.change_mapset(dm.get_location(),"PERMANENT") | g.change_mapset("PERMANENT",dm.get_location()) | def add_model(self, model_fn): import shutil if not os.path.isfile(model_fn): raise RepositoryException("Model file %s is not a file."%model_fn) g = GRASSInterface.get_g() dm = DispersalModel.DispersalModel(model_fn,setup=False) loc = dm.get_location() if dm.get_location() == None: raise RepositoryException("Model does... |
for a in Actions.mdig_actions: | for a in actions.mdig_actions: | def usage(db): usage_line = mdig.version_string + "\n" usage_line += "Usage: mdig.py <action> [options] [model_name|model.xml]" max_length = 0 for a in Actions.mdig_actions: max_length = max(len(a),max_length) actions_list = [] for a in Actions.mdig_actions: a_str = a + (" "*(max_length - len(a))) + " - " + \ Actions... |
Actions.mdig_actions[a].description | actions.mdig_actions[a].description | def usage(db): usage_line = mdig.version_string + "\n" usage_line += "Usage: mdig.py <action> [options] [model_name|model.xml]" max_length = 0 for a in Actions.mdig_actions: max_length = max(len(a),max_length) actions_list = [] for a in Actions.mdig_actions: a_str = a + (" "*(max_length - len(a))) + " - " + \ Actions... |
if Actions.mdig_actions.has_key( action_keyword ): | if actions.mdig_actions.has_key( action_keyword ): | def process_options(argv): global logger model_file = None mdig_config = config.get_config() # Remove action keyword first action_keyword = None if len(argv) >= 1: action_keyword = argv[0] the_action = None if Actions.mdig_actions.has_key( action_keyword ): # Initialise with the class corresponding to the action the... |
the_action = Actions.mdig_actions[action_keyword]() | the_action = actions.mdig_actions[action_keyword]() | def process_options(argv): global logger model_file = None mdig_config = config.get_config() # Remove action keyword first action_keyword = None if len(argv) >= 1: action_keyword = argv[0] the_action = None if Actions.mdig_actions.has_key( action_keyword ): # Initialise with the class corresponding to the action the... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.