def restore_junction(old_path, new_path):
if os.path_exists(new_path):
if os.path_exists(old_path):
if junction.isjunction(old_path):
print("Already junctioned: {}".format(old_path))
else:
print("Cannot junction; conflicting folder already exists: {}".format(old_path))
else:
link_save(old_path, new_path)
hide_directory(old_path)
def resume_download():
file_exists = False
Custom_URL_Class = CustomURLOpener(
) # create object from class to override it
if os.path_exists(TARGET_FILE):
out_file = open(TARGET_FILE, "ab")
file_exists_size = os.path.getsize(TARGET_FILE) # get file size
### if the file exists then only download the ubfinished part
Custom_URL_Class.addheader("Download range",
"bytes=%s-" % (file_exists_size))
else:
out_file = open(TARGET_FILE, "wb")
web_page = Custome_URL_Class.open(TARGET_URL + TARGET_FILE)
# if the file exists but we already have the whole thing,don't download again
if int(web_page.headers['Content-Length']) == file_exists_size:
loop = 0
print("File already downloaded ..")
byte_count = 0
while True:
data = web_page.read(8192)
if not data:
break
out_file.write(data)
byte_count = byte_count + len(data)
web_page.close()
out_file.close()
for k, v in web_page.headers.items():
print(k, "=", v)
print("file copied ", byte_count, "byte from", web_page.url)
def create(self, project_directory):
""" Sets up what needs to be set up.
Should only be called if current state is STATE_UNINITIALIZED
"""
# redo setup based on passed project directory
self.project_directory = project_directory
self.directory = '{}{}.project'.format(project_directory, os.sep)
self.conf_path = '{}{}book.cnf'.format(self.directory, os.sep)
# make sure the project directory exists
if not os.path_exists(self.directory):
os.makedirs(self.directory)
# make sure our config is loaded
if not self.config:
self.config = ConfigParser()
if os.path_exists(self.conf_path):
self.config.read(self.conf_path)
# make sure all the sections of the config exist
sections = (
'extract_text',
'metadata',
'process',
)
for section in sections:
if not self.config.has_section(section):
self.config.add_section(section)
# set current status if it hasn't been set
if not self.config.has_option('process', 'current_status'):
self.config.set('process', 'current_status', STATE_NEEDS_METADATA)
metadata = (
'author',
'title'
)
# set metadata if it hasn't been set
for data in metadata:
if not self.config.get('metadata', data):
self.config.set('metadata', data, '')
# write the config
self.write_config()
def czytaj_dane(plik):
if not os.path_exists(plik):
print('Plik niedostepny!')
return False
teksty = []
with open(plik, "r") as f:
for wiersz in f:
teksty.append(linia.strip())
return teksty
def run(self, context) :
"""
Run Meshlab using selected filter
"""
server = findmeshlab() # find meshlabserver executable
if server is None :
self.report({'ERROR'}, "Can't find Meshlab Server program. 'meshlabserver' must be in your PATH for command line programs.")
return
# Preliminary checks complete, OK to attempt operation
try :
scriptfile = self.script_filename # name of script we will run
working_dir = tempfile.mkdtemp(prefix='Blender-Meshlab') # scratch file directory
# Name export file from blender, and meshlab output file for re-import
temp_ply_path = os.path.join(working_dir,"temp_mesh.ply")
temp_o_ply_path = os.path.join(working_dir,"temp_mesh_o.ply")
# Export file
bpy.ops.export_mesh.ply(filepath=temp_ply_path, check_existing = False) # exports entire scene, revise
# Call Meshlabserver to do the work.
result = subprocess.call([server,"-i",temp_ply_path,"-o",temp_o_ply_path, "-m","vcvnfnfcvt", "-s",scriptfile])
if result != 0 :
self.report({'ERROR'},"\"%s\" running script \"%s\" failed, status %d" % (server, scriptfile, result)) # trouble
return
# Import file exported by Meshlab.
bpy.ops.import_mesh.ply(filepath=temp_o_ply_path)
# Postprocessing after import
new_obj = bpy.data.objects["temp_mesh_o"]
####new_obj.name = name + "_meshlab"
####bpy.ops.object.select_all(action = 'DESELECT')
####new_obj.select = True
####bpy.context.scene.objects.active = new_obj
####bpy.ops.transform.rotate(value = (math.pi/2,),axis = (1,0,0))
####new_obj.scale = scale
finally: # clean up, even if things went wrong
assert(working_dir)
if not KEEPTEMPDIR : # clean up, unless debugging
if os.path.exists(temp_ply_path) :
os.remove(temp_ply_path)
if os.path_exists(temp_o_ply_path) :
os.remove(temp_o_ply_path)
os.rmdir(working_dir) # temp directory should always exist
def tiles(self, id):
datatype = id
x = request.params.get('x', None)
y = request.params.get('y', None)
z = request.params.get('z', None)
id = request.params.get('id', None)
overwrite = True if request.params.get('overwrite', None) is not None else False
logging.info('Creating tileset type: ' + datatype)
if datatype=="range":
mapfile = os.path.join(app_globals.RANGESHP_DIR, id + '.mapfile.xml')
if not os.path_exists(mapfile):
url = "http://mol.colorado.edu/layers/api/newtileset/range?id=%s&range_ids=%s" % (id,id)
req = urllib2.Request(url)
response = urllib2.urlopen(req)
tile_dir = os.path.join(app_globals.TILE_DIR, id)
tile = os.path.join(tile_dir, z, x, "%s.png" % y)
null_tile = os.path.join(tile_dir, z, x, "%s.null" % y)
elif datatype=="ecoregion":
mapfile = os.path.join(app_globals.ECOSHP_DIR, id + '.mapfile.xml')
tile_dir = os.path.join(app_globals.ECOTILE_DIR, id)
tile = os.path.join(tile_dir, z, x, "%s.png" % y)
null_tile = os.path.join(tile_dir, z, x, "%s.null" % y)
logging.info('Generating new ' + datatype +' tiles: ' + id)
bbox = bboxfromxyz(int(x),int(y),int(z) )
GenerateTiles.render_tiles(bbox,
str(mapfile),
str(tile_dir),
int(z),
int(z+1),
str(id),
num_threads=app_globals.TILE_QUEUE_THREADS,
overwrite=overwrite)
def create_dir(directory):
if not os.path_exists(directory):
os.makedir(directory)
def calculate_twi(self,
esfile,
save_path,
use_cache=True,
do_edges=False,
skip_uca_twi=False):
"""
Calculates twi for supplied elevation file
Parameters
-----------
esfile : str
Path to elevation file to be processed
save_path: str
Root path to location where TWI will be saved. TWI will be saved in
a subdirectory 'twi'.
use_cache : bool (optional)
Default True. If a temporary file exists (from a previous run),
the cached file will be used. Otherwise, if False, existing files
will be recomputed
do_edges : bool (optional)
See :py:func:`process_twi` for details on this argument.
skip_uca_twi : bool (optional)
Skips the calculation of the UCA and TWI (only calculates the
magnitude and direction)
"""
if os.path.exists(os.path.join(save_path, 'tile_edge.pkl')) and \
self.tile_edge is None:
with open(os.path.join(save_path, 'tile_edge.pkl'), 'r') as fid:
self.tile_edge = cPickle.load(fid)
elif self.tile_edge is None:
self.tile_edge = TileEdgeFile(self.elev_source_files, save_path)
with open(os.path.join(save_path, 'tile_edge.pkl'), 'wb') as fid:
cPickle.dump(self.tile_edge, fid)
status = 'Success' # optimism
# Check if file is locked
lckfn = _get_lockfile_name(esfile)
coords = parse_fn(esfile)
fn = get_fn_from_coords(coords, 'twi')
print '*' * 79
if skip_uca_twi:
print '*' * 10, fn, 'Slope Calculation starting...:', '*' * 10
else:
print '*' * 10, fn, 'TWI Calculation starting...:', '*' * 10
print '*' * 79
if os.path.exists(lckfn): # another process is working on it
print fn, 'is locked'
return fn, "Locked"
else: # lock this tile
fid = file(lckfn, 'w')
fid.close()
dem_proc = DEMProcessor(esfile)
# check if the slope already exists for the file. If yes, we should
# move on to the next tile without doing anything else
if skip_uca_twi \
and os.path.exists(dem_proc.get_full_fn('mag', save_path)
+ '.npz') \
and os.path.exists(dem_proc.get_full_fn('ang', save_path)
+ '.npz'):
print dem_proc.get_full_fn('mag',
save_path) + '.npz', 'already exists'
print dem_proc.get_full_fn('ang',
save_path) + '.npz', 'already exists'
# remove lock file
os.remove(lckfn)
return fn, 'Cached: Slope'
# check if the twi already exists for the file. If not in the edge
# resolution round, we should move on to the next tile
if os.path.exists(dem_proc.get_full_fn('twi', save_path)) \
and (do_edges is False):
print dem_proc.get_full_fn('twi', save_path), 'already exists'
# remove lock file
os.remove(lckfn)
return fn, 'Cached'
# only calculate the slopes and direction if they do not exist in cache
fn_ang = dem_proc.get_full_fn('ang', save_path)
fn_mag = dem_proc.get_full_fn('mag', save_path)
if os.path.exists(fn_ang + '.npz') and os.path.exists(fn_mag + '.npz')\
and not self.overwrite_cache:
dem_proc.load_direction(fn_ang)
dem_proc.load_slope(fn_mag)
dem_proc.find_flats()
else:
if os.path.exists(fn_ang + '.npz') and os.path_exists(fn_mag + '.npz')\
and self.overwrite_cache:
os.remove(fn_ang)
os.remove(fn_mag)
dem_proc.calc_slopes_directions()
dem_proc.save_slope(save_path, raw=True)
dem_proc.save_direction(save_path, raw=True)
if self._DEBUG:
dem_proc.save_slope(save_path, as_int=False)
dem_proc.save_direction(save_path, as_int=False)
if skip_uca_twi:
# remove lock file
os.remove(lckfn)
return fn, status + ":mag-dir-only"
fn_uca = dem_proc.get_full_fn('uca', save_path)
fn_uca_ec = dem_proc.get_full_fn('uca_edge_corrected', save_path)
fn_twi = dem_proc.get_full_fn('twi', save_path)
# check if edge structure exists for this tile and initialize
edge_init_data, edge_init_done, edge_init_todo = \
self.tile_edge.get_edge_init_data(esfile, save_path)
# Check if uca data exists (if yes, we are in the
# edge-resolution round)
uca_init = None
if os.path.exists(fn_uca + '.npz'):
if os.path.exists(fn_uca_ec + '.npz'):
dem_proc.load_uca(fn_uca_ec)
else:
dem_proc.load_uca(fn_uca)
uca_init = dem_proc.uca
if do_edges or uca_init is None:
dem_proc.calc_uca(uca_init=uca_init,
edge_init_data=[
edge_init_data, edge_init_done,
edge_init_todo
])
if uca_init is None:
dem_proc.save_uca(save_path, raw=True)
if self._DEBUG:
# Also save a geotiff for debugging
dem_proc.save_uca(save_path, as_int=False)
else:
if os.path.exists(fn_uca_ec):
os.remove(fn_uca_ec)
dem_proc.save_array(dem_proc.uca,
None,
'uca_edge_corrected',
save_path,
raw=True)
if self._DEBUG:
dem_proc.save_array(dem_proc.uca,
None,
'uca_edge_corrected',
save_path,
as_int=False)
# Saving Edge Data, and updating edges
self.tile_edge.update_edges(esfile, dem_proc)
dem_proc.calc_twi()
if os.path.exists(fn_twi):
os.remove(fn_twi)
dem_proc.save_twi(save_path, raw=False)
# clean up for in case
gc.collect()
# remove lock file
os.remove(lckfn)
# Save last-used dem_proc for debugging purposes
if self._DEBUG:
self.dem_proc = dem_proc
return fn, status
def get_price(self, tracker_file, stock): if os.path_exists(tracker_file): with open(tracker_file) as fp: json_data = json.load(fp) return json_data[stock]
