def main():
infile = options['input']
# create temporary directory
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = %s' % tmp_dir)
# check if the input file exists
if not os.path.exists(infile):
grass.fatal(_("File <%s> not found") % infile)
# copy the files to tmp dir
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_name = tar.getnames()[0]
except:
grass.fatal(_("Pack file unreadable"))
# set the output name
if options['output']:
map_name = options['output']
else:
map_name = data_name
# grass env
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'],
gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
new_dir = os.path.join(mset_dir, 'vector', map_name)
gfile = grass.find_file(name=map_name, element='vector', mapset='.')
overwrite = os.getenv('GRASS_OVERWRITE')
if gfile['file'] and overwrite != '1':
grass.fatal(_("Vector map <%s> already exists") % map_name)
elif overwrite == '1' and gfile['file']:
grass.warning(_("Vector map <%s> already exists and will be overwritten") % map_name)
grass.run_command('g.remove', flags='f', quiet=True, type='vector',
name=map_name)
shutil.rmtree(new_dir, True)
# extract data
tar.extractall()
if os.path.exists(os.path.join(data_name, 'coor')):
pass
elif os.path.exists(os.path.join(data_name, 'cell')):
grass.fatal(_("This GRASS GIS pack file contains raster data. Use "
"r.unpack to unpack <%s>" % map_name))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
loc_proj = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
loc_proj_units = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
skip_projection_check = False
if not os.path.exists(os.path.join(tmp_dir, 'PROJ_INFO')):
if os.path.exists(loc_proj):
grass.fatal(
_("PROJ_INFO file is missing, unpack vector map in XY (unprojected) location."))
skip_projection_check = True # XY location
if not skip_projection_check:
diff_result_1 = diff_result_2 = None
if not grass.compare_key_value_text_files(filename_a=os.path.join(tmp_dir, 'PROJ_INFO'),
filename_b=loc_proj, proj=True):
diff_result_1 = diff_files(os.path.join(tmp_dir, 'PROJ_INFO'),
loc_proj)
if not grass.compare_key_value_text_files(filename_a=os.path.join(tmp_dir, 'PROJ_UNITS'),
filename_b=loc_proj_units,
units=True):
diff_result_2 = diff_files(os.path.join(tmp_dir, 'PROJ_UNITS'),
loc_proj_units)
if diff_result_1 or diff_result_2:
if flags['o']:
grass.warning(_("Projection information does not match. Proceeding..."))
else:
if diff_result_1:
grass.warning(_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(diff=''.join(diff_result_2)))
grass.fatal(_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
# new db
fromdb = os.path.join(tmp_dir, 'db.sqlite')
# copy file
shutil.copytree(data_name, new_dir)
# exist fromdb
if os.path.exists(fromdb):
# the db connection in the output mapset
dbconn = grassdb.db_connection(force=True)
todb = dbconn['database']
# return all tables
list_fromtable = grass.read_command('db.tables', driver='sqlite',
database=fromdb).splitlines()
# return the list of old connection for extract layer number and key
dbln = open(os.path.join(new_dir, 'dbln'), 'r')
dbnlist = dbln.readlines()
dbln.close()
# check if dbf or sqlite directory exists
if dbconn['driver'] == 'dbf' and not os.path.exists(os.path.join(mset_dir, 'dbf')):
os.mkdir(os.path.join(mset_dir, 'dbf'))
elif dbconn['driver'] == 'sqlite' and not os.path.exists(os.path.join(mset_dir, 'sqlite')):
os.mkdir(os.path.join(mset_dir, 'sqlite'))
# for each old connection
for t in dbnlist:
# it split the line of each connection, to found layer number and key
if len(t.split('|')) != 1:
values = t.split('|')
else:
values = t.split(' ')
from_table = values[1]
layer = values[0].split('/')[0]
# we need to take care about the table name in case of several layer
if options["output"]:
if len(dbnlist) > 1:
to_table = "%s_%s" % (map_name, layer)
else:
to_table = map_name
else:
to_table = from_table
grass.verbose(_("Coping table <%s> as table <%s>") % (from_table,
to_table))
# copy the table in the default database
try:
grass.run_command('db.copy', to_driver=dbconn['driver'],
to_database=todb, to_table=to_table,
from_driver='sqlite',
from_database=fromdb,
from_table=from_table)
except CalledModuleError:
grass.fatal(_("Unable to copy table <%s> as table <%s>") % (from_table, to_table))
grass.verbose(_("Connect table <%s> to vector map <%s> at layer <%s>") %
(to_table, map_name, layer))
# and connect the new tables with the right layer
try:
grass.run_command('v.db.connect', flags='o', quiet=True,
driver=dbconn['driver'], database=todb,
map=map_name, key=values[2],
layer=layer, table=to_table)
except CalledModuleError:
grass.fatal(_("Unable to connect table <%s> to vector map <%s>") %
(to_table, map_name))
grass.message(_("Vector map <%s> successfully unpacked") % map_name)
def main():
infile = options['input']
# create temporary directory
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = %s' % tmp_dir)
# check if the input file exists
if not os.path.exists(infile):
grass.fatal(_("File <%s> not found") % infile)
# copy the files to tmp dir
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_name = tar.getnames()[0]
except:
grass.fatal(_("Pack file unreadable"))
if flags['p']:
# print proj info and exit
try:
for fname in ['PROJ_INFO', 'PROJ_UNITS']:
f = tar.extractfile(fname)
sys.stdout.write(f.read())
except KeyError:
grass.fatal(
_("Pack file unreadable: file '{}' missing".format(fname)))
tar.close()
return 0
# set the output name
if options['output']:
map_name = options['output']
else:
map_name = data_name
# grass env
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'], gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
new_dir = os.path.join(mset_dir, 'vector', map_name)
gfile = grass.find_file(name=map_name, element='vector', mapset='.')
overwrite = os.getenv('GRASS_OVERWRITE')
if gfile['file'] and overwrite != '1':
grass.fatal(_("Vector map <%s> already exists") % map_name)
elif overwrite == '1' and gfile['file']:
grass.warning(
_("Vector map <%s> already exists and will be overwritten") %
map_name)
grass.run_command('g.remove',
flags='f',
quiet=True,
type='vector',
name=map_name)
shutil.rmtree(new_dir, True)
# extract data
tar.extractall()
tar.close()
if os.path.exists(os.path.join(data_name, 'coor')):
pass
elif os.path.exists(os.path.join(data_name, 'cell')):
grass.fatal(
_("This GRASS GIS pack file contains raster data. Use "
"r.unpack to unpack <%s>" % map_name))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
loc_proj = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
loc_proj_units = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
skip_projection_check = False
if not os.path.exists(os.path.join(tmp_dir, 'PROJ_INFO')):
if os.path.exists(loc_proj):
grass.fatal(
_("PROJ_INFO file is missing, unpack vector map in XY (unprojected) location."
))
skip_projection_check = True # XY location
if not skip_projection_check:
diff_result_1 = diff_result_2 = None
if not grass.compare_key_value_text_files(filename_a=os.path.join(
tmp_dir, 'PROJ_INFO'),
filename_b=loc_proj,
proj=True):
diff_result_1 = diff_files(os.path.join(tmp_dir, 'PROJ_INFO'),
loc_proj)
if not grass.compare_key_value_text_files(filename_a=os.path.join(
tmp_dir, 'PROJ_UNITS'),
filename_b=loc_proj_units,
units=True):
diff_result_2 = diff_files(os.path.join(tmp_dir, 'PROJ_UNITS'),
loc_proj_units)
if diff_result_1 or diff_result_2:
if flags['o']:
grass.warning(
_("Projection information does not match. Proceeding..."))
else:
if diff_result_1:
grass.warning(
_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(
_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_2)))
grass.fatal(
_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
# new db
fromdb = os.path.join(tmp_dir, 'db.sqlite')
# copy file
shutil.copytree(data_name, new_dir)
# exist fromdb
if os.path.exists(fromdb):
# the db connection in the output mapset
dbconn = grassdb.db_connection(force=True)
todb = dbconn['database']
# return all tables
list_fromtable = grass.read_command('db.tables',
driver='sqlite',
database=fromdb).splitlines()
# return the list of old connection for extract layer number and key
dbln = open(os.path.join(new_dir, 'dbln'), 'r')
dbnlist = dbln.readlines()
dbln.close()
# check if dbf or sqlite directory exists
if dbconn['driver'] == 'dbf' and not os.path.exists(
os.path.join(mset_dir, 'dbf')):
os.mkdir(os.path.join(mset_dir, 'dbf'))
elif dbconn['driver'] == 'sqlite' and not os.path.exists(
os.path.join(mset_dir, 'sqlite')):
os.mkdir(os.path.join(mset_dir, 'sqlite'))
# for each old connection
for t in dbnlist:
# it split the line of each connection, to found layer number and key
if len(t.split('|')) != 1:
values = t.split('|')
else:
values = t.split(' ')
from_table = values[1]
layer = values[0].split('/')[0]
# we need to take care about the table name in case of several layer
if options["output"]:
if len(dbnlist) > 1:
to_table = "%s_%s" % (map_name, layer)
else:
to_table = map_name
else:
to_table = from_table
grass.verbose(
_("Coping table <%s> as table <%s>") % (from_table, to_table))
# copy the table in the default database
try:
grass.run_command('db.copy',
to_driver=dbconn['driver'],
to_database=todb,
to_table=to_table,
from_driver='sqlite',
from_database=fromdb,
from_table=from_table)
except CalledModuleError:
grass.fatal(
_("Unable to copy table <%s> as table <%s>") %
(from_table, to_table))
grass.verbose(
_("Connect table <%s> to vector map <%s> at layer <%s>") %
(to_table, map_name, layer))
# and connect the new tables with the right layer
try:
grass.run_command('v.db.connect',
flags='o',
quiet=True,
driver=dbconn['driver'],
database=todb,
map=map_name,
key=values[2],
layer=layer,
table=to_table)
except CalledModuleError:
grass.fatal(
_("Unable to connect table <%s> to vector map <%s>") %
(to_table, map_name))
grass.message(_("Vector map <%s> successfully unpacked") % map_name)
def main():
infile = options['input']
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = {tmpdir}'.format(tmpdir=tmp_dir))
if not os.path.exists(infile):
grass.fatal(_('File {name} not found.'.format(name=infile)))
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'], gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_name = tar.getnames()[0]
except:
grass.fatal(_("Pack file unreadable"))
if options['output']:
map_name = options['output']
else:
map_name = data_name.split('@')[0]
gfile = grass.find_file(name=map_name, element='cell', mapset='.')
if gfile['file']:
if os.environ.get('GRASS_OVERWRITE', '0') != '1':
grass.fatal(
_('Raster map <{name}> already exists'.format(name=map_name)))
else:
grass.warning(
_('Raster map <{name}> already exists and will be overwritten'.
format(name=map_name)))
# extract data
tar.extractall()
os.chdir(data_name)
if os.path.exists('cell'):
pass
elif os.path.exists('coor'):
grass.fatal(
_('This GRASS GIS pack file contains vector data. Use '
'v.unpack to unpack <{name}>'.format(name=map_name)))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
if flags['o']:
grass.warning(
_("Overriding projection check (using current location's projection)."
))
else:
diff_result_1 = diff_result_2 = None
proj_info_file_1 = 'PROJ_INFO'
proj_info_file_2 = os.path.join(mset_dir, '..', 'PERMANENT',
'PROJ_INFO')
skip_projection_check = False
if not os.path.exists(proj_info_file_1):
if os.path.exists(proj_info_file_2):
grass.fatal(
_("PROJ_INFO file is missing, unpack raster map in XY (unprojected) location."
))
skip_projection_check = True # XY location
if not skip_projection_check:
if not grass.compare_key_value_text_files(
filename_a=proj_info_file_1,
filename_b=proj_info_file_2,
proj=True):
diff_result_1 = diff_files(proj_info_file_1, proj_info_file_2)
proj_units_file_1 = 'PROJ_UNITS'
proj_units_file_2 = os.path.join(mset_dir, '..', 'PERMANENT',
'PROJ_UNITS')
if not grass.compare_key_value_text_files(
filename_a=proj_units_file_1,
filename_b=proj_units_file_2,
units=True):
diff_result_2 = diff_files(proj_units_file_1,
proj_units_file_2)
if diff_result_1 or diff_result_2:
if diff_result_1:
grass.warning(
_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(
_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_2)))
grass.fatal(
_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
# install in $MAPSET
for element in [
'cats', 'cell', 'cellhd', 'cell_misc', 'colr', 'fcell', 'hist'
]:
if not os.path.exists(element):
continue
path = os.path.join(mset_dir, element)
if not os.path.exists(path):
os.mkdir(path)
if element == 'cell_misc':
path = os.path.join(mset_dir, element, map_name)
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree('cell_misc', path)
else:
shutil.copyfile(element, os.path.join(mset_dir, element, map_name))
grass.message(_('Raster map <{name}> unpacked'.format(name=map_name)))
def main():
infile = options["input"]
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug("tmp_dir = {tmpdir}".format(tmpdir=tmp_dir))
if not os.path.exists(infile):
grass.fatal(_("File {name} not found.".format(name=infile)))
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv["GISDBASE"], gisenv["LOCATION_NAME"],
gisenv["MAPSET"])
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode="r")
try:
data_names = [
tarinfo.name for tarinfo in tar.getmembers()
if "/" not in tarinfo.name
]
except:
grass.fatal(_("Pack file unreadable"))
if flags["p"]:
# print proj info and exit
try:
for fname in ["PROJ_INFO", "PROJ_UNITS"]:
f = tar.extractfile("{}/{}".format(data_names[0], fname))
sys.stdout.write(f.read().decode())
except KeyError:
grass.fatal(
_("Pack file unreadable: file '{}' missing".format(fname)))
tar.close()
return 0
if options["output"]:
map_name = options["output"]
else:
map_name = data_names[0].split("@")[0]
gfile = grass.find_file(name=map_name, element="cell", mapset=".")
if gfile["file"]:
if os.environ.get("GRASS_OVERWRITE", "0") != "1":
grass.fatal(
_("Raster map <{name}> already exists".format(name=map_name)))
else:
grass.warning(
_("Raster map <{name}> already exists and will be overwritten".
format(name=map_name)))
# extract data
tar.extractall()
tar.close()
os.chdir(data_names[0])
if os.path.exists("cell"):
pass
elif os.path.exists("coor"):
grass.fatal(
_("This GRASS GIS pack file contains vector data. Use "
"v.unpack to unpack <{name}>".format(name=map_name)))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
if flags["o"]:
grass.warning(
_("Overriding projection check (using current location's projection)."
))
else:
diff_result_1 = diff_result_2 = None
proj_info_file_1 = "PROJ_INFO"
proj_info_file_2 = os.path.join(mset_dir, "..", "PERMANENT",
"PROJ_INFO")
skip_projection_check = False
if not os.path.exists(proj_info_file_1):
if os.path.exists(proj_info_file_2):
grass.fatal(
_("PROJ_INFO file is missing, unpack raster map in XY (unprojected) location."
))
skip_projection_check = True # XY location
if not skip_projection_check:
if not grass.compare_key_value_text_files(
filename_a=proj_info_file_1,
filename_b=proj_info_file_2,
proj=True):
diff_result_1 = diff_files(proj_info_file_1, proj_info_file_2)
proj_units_file_1 = "PROJ_UNITS"
proj_units_file_2 = os.path.join(mset_dir, "..", "PERMANENT",
"PROJ_UNITS")
if not grass.compare_key_value_text_files(
filename_a=proj_units_file_1,
filename_b=proj_units_file_2,
units=True):
diff_result_2 = diff_files(proj_units_file_1,
proj_units_file_2)
if diff_result_1 or diff_result_2:
if diff_result_1:
grass.warning(
_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(
diff="".join(diff_result_1)))
if diff_result_2:
grass.warning(
_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(
diff="".join(diff_result_2)))
grass.fatal(
_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
maps = []
vrt_file = None
for index, data in enumerate(data_names):
if index > 0:
map_name = data
for element in [
"cats", "cell", "cellhd", "cell_misc", "colr", "fcell", "hist"
]:
src_path = os.path.join(tmp_dir, data, element)
if not os.path.exists(src_path):
continue
path = os.path.join(mset_dir, element)
if not os.path.exists(path):
os.mkdir(path)
if element == "cell_misc":
if index > 0:
maps.append(
"{map_name}@{mapset}".format(
map_name=map_name,
mapset=gisenv["MAPSET"],
), )
path = os.path.join(
mset_dir,
element,
map_name,
)
if index == 0:
vrt_file = os.path.join(path, "vrt")
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree(src_path, path)
else:
shutil.copyfile(
src_path,
os.path.join(mset_dir, element, map_name),
)
# Update vrt file
if maps:
if vrt_file and os.path.exists(vrt_file):
files = "\n".join(maps)
with open(vrt_file, "w") as f:
f.write(files)
grass.message(_("Raster map <{name}> unpacked".format(name=map_name)))
def main():
infile = options['input']
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = {tmpdir}'.format(tmpdir=tmp_dir))
if not os.path.exists(infile):
grass.fatal(_('File {name} not found.'.format(name=infile)))
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'],
gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_name = tar.getnames()[0]
except:
grass.fatal(_("Pack file unreadable"))
if options['output']:
map_name = options['output']
else:
map_name = data_name.split('@')[0]
gfile = grass.find_file(name=map_name, element='cell', mapset='.')
if gfile['file']:
if os.environ.get('GRASS_OVERWRITE', '0') != '1':
grass.fatal(_('Raster map <{name}> already exists'.format(name=map_name)))
else:
grass.warning(_('Raster map <{name}> already exists and will be overwritten'.format(name=map_name)))
# extract data
tar.extractall()
os.chdir(data_name)
if os.path.exists('cell'):
pass
elif os.path.exists('coor'):
grass.fatal(_('This GRASS GIS pack file contains vector data. Use '
'v.unpack to unpack <{name}>'.format(name=map_name)))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
if flags['o']:
grass.warning(_("Overriding projection check (using current location's projection)."))
else:
diff_result_1 = diff_result_2 = None
proj_info_file_1 = 'PROJ_INFO'
proj_info_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
skip_projection_check = False
if not os.path.exists(proj_info_file_1):
if os.path.exists(proj_info_file_2):
grass.fatal(_("PROJ_INFO file is missing, unpack raster map in XY (unprojected) location."))
skip_projection_check = True # XY location
if not skip_projection_check:
if not grass.compare_key_value_text_files(filename_a=proj_info_file_1,
filename_b=proj_info_file_2,
proj=True):
diff_result_1 = diff_files(proj_info_file_1, proj_info_file_2)
proj_units_file_1 = 'PROJ_UNITS'
proj_units_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
if not grass.compare_key_value_text_files(filename_a=proj_units_file_1,
filename_b=proj_units_file_2,
units=True):
diff_result_2 = diff_files(proj_units_file_1, proj_units_file_2)
if diff_result_1 or diff_result_2:
if diff_result_1:
grass.warning(_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(diff=''.join(diff_result_2)))
grass.fatal(_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
# install in $MAPSET
for element in ['cats', 'cell', 'cellhd', 'cell_misc', 'colr', 'fcell', 'hist']:
if not os.path.exists(element):
continue
path = os.path.join(mset_dir, element)
if not os.path.exists(path):
os.mkdir(path)
if element == 'cell_misc':
path = os.path.join(mset_dir, element, map_name)
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree('cell_misc', path)
else:
shutil.copyfile(element, os.path.join(mset_dir, element, map_name))
grass.message(_('Raster map <{name}> unpacked'.format(name=map_name)))
def main():
infile = options['input']
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = {tmpdir}'.format(tmpdir=tmp_dir))
if not os.path.exists(infile):
grass.fatal(_('File {name} not found.'.format(name=infile)))
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'],
gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_names = [
tarinfo.name for tarinfo in tar.getmembers()
if '/' not in tarinfo.name
]
except:
grass.fatal(_("Pack file unreadable"))
if flags['p']:
# print proj info and exit
try:
for fname in ['PROJ_INFO', 'PROJ_UNITS']:
f = tar.extractfile('{}/{}'.format(data_names[0], fname))
sys.stdout.write(f.read().decode())
except KeyError:
grass.fatal(_("Pack file unreadable: file '{}' missing".format(fname)))
tar.close()
return 0
if options['output']:
map_name = options['output']
else:
map_name = data_names[0].split('@')[0]
gfile = grass.find_file(name=map_name, element='cell', mapset='.')
if gfile['file']:
if os.environ.get('GRASS_OVERWRITE', '0') != '1':
grass.fatal(_('Raster map <{name}> already exists'.format(name=map_name)))
else:
grass.warning(
_('Raster map <{name}> already exists and will be overwritten'.format(name=map_name)))
# extract data
tar.extractall()
tar.close()
os.chdir(data_names[0])
if os.path.exists('cell'):
pass
elif os.path.exists('coor'):
grass.fatal(_('This GRASS GIS pack file contains vector data. Use '
'v.unpack to unpack <{name}>'.format(name=map_name)))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
if flags['o']:
grass.warning(_("Overriding projection check (using current location's projection)."))
else:
diff_result_1 = diff_result_2 = None
proj_info_file_1 = 'PROJ_INFO'
proj_info_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
skip_projection_check = False
if not os.path.exists(proj_info_file_1):
if os.path.exists(proj_info_file_2):
grass.fatal(
_("PROJ_INFO file is missing, unpack raster map in XY (unprojected) location."))
skip_projection_check = True # XY location
if not skip_projection_check:
if not grass.compare_key_value_text_files(filename_a=proj_info_file_1,
filename_b=proj_info_file_2,
proj=True):
diff_result_1 = diff_files(proj_info_file_1, proj_info_file_2)
proj_units_file_1 = 'PROJ_UNITS'
proj_units_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
if not grass.compare_key_value_text_files(filename_a=proj_units_file_1,
filename_b=proj_units_file_2,
units=True):
diff_result_2 = diff_files(proj_units_file_1, proj_units_file_2)
if diff_result_1 or diff_result_2:
if diff_result_1:
grass.warning(_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(diff=''.join(diff_result_2)))
grass.fatal(_("Projection of dataset does not appear to match current location."
" In case of no significant differences in the projection definitions,"
" use the -o flag to ignore them and use"
" current location definition."))
maps = []
vrt_file = None
for index, data in enumerate(data_names):
if index > 0:
map_name = data
for element in [
'cats', 'cell', 'cellhd', 'cell_misc', 'colr', 'fcell',
'hist'
]:
src_path = os.path.join(tmp_dir, data, element)
if not os.path.exists(src_path):
continue
path = os.path.join(mset_dir, element)
if not os.path.exists(path):
os.mkdir(path)
if element == 'cell_misc':
if index > 0:
maps.append(
"{map_name}@{mapset}".format(
map_name=map_name, mapset=gisenv['MAPSET'],
),
)
path = os.path.join(
mset_dir, element, map_name,
)
if index == 0:
vrt_file = os.path.join(path, 'vrt')
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree(src_path, path)
else:
shutil.copyfile(
src_path, os.path.join(mset_dir, element, map_name),
)
# Update vrt file
if maps:
if vrt_file and os.path.exists(vrt_file):
files = '\n'.join(maps)
with open(vrt_file, 'w') as f:
f.write(files)
grass.message(_('Raster map <{name}> unpacked'.format(name=map_name)))
def main():
infile = options['input']
global tmp_dir
tmp_dir = grass.tempdir()
grass.debug('tmp_dir = %s' % tmp_dir)
if not os.path.exists(infile):
grass.fatal(_("File <%s> not found") % infile)
gisenv = grass.gisenv()
mset_dir = os.path.join(gisenv['GISDBASE'], gisenv['LOCATION_NAME'],
gisenv['MAPSET'])
input_base = os.path.basename(infile)
shutil.copyfile(infile, os.path.join(tmp_dir, input_base))
os.chdir(tmp_dir)
tar = tarfile.TarFile.open(name=input_base, mode='r')
try:
data_name = tar.getnames()[0]
except:
grass.fatal(_("Pack file unreadable"))
if options['output']:
map_name = options['output']
else:
map_name = data_name.split('@')[0]
gfile = grass.find_file(name=map_name, element='cell', mapset='.')
if gfile['file']:
if os.environ.get('GRASS_OVERWRITE', '0') != '1':
grass.fatal(_("Raster map <%s> already exists") % map_name)
else:
grass.warning(
_("Raster map <%s> already exists and will be overwritten") %
map_name)
# extract data
tar.extractall()
os.chdir(data_name)
if os.path.exists('cell'):
pass
elif os.path.exists('coor'):
grass.fatal(
_("This GRASS GIS pack file contains vector data. Use "
"v.unpack to unpack <%s>" % map_name))
else:
grass.fatal(_("Pack file unreadable"))
# check projection compatibility in a rather crappy way
diff_result_1 = diff_result_2 = None
proj_info_file_1 = 'PROJ_INFO'
proj_info_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_INFO')
if not grass.compare_key_value_text_files(filename_a=proj_info_file_1,
filename_b=proj_info_file_2,
proj=True):
diff_result_1 = diff_files(proj_info_file_1, proj_info_file_2)
proj_units_file_1 = 'PROJ_UNITS'
proj_units_file_2 = os.path.join(mset_dir, '..', 'PERMANENT', 'PROJ_UNITS')
if not grass.compare_key_value_text_files(filename_a=proj_units_file_1,
filename_b=proj_units_file_2,
units=True):
diff_result_2 = diff_files(proj_units_file_1, proj_units_file_2)
if diff_result_1 or diff_result_2:
if flags['o']:
grass.warning(
_("Projection information does not match. Proceeding..."))
else:
if diff_result_1:
grass.warning(
_("Difference between PROJ_INFO file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_1)))
if diff_result_2:
grass.warning(
_("Difference between PROJ_UNITS file of packed map "
"and of current location:\n{diff}").format(
diff=''.join(diff_result_2)))
grass.fatal(_("Projection information does not match. Aborting."))
# install in $MAPSET
for element in [
'cats', 'cell', 'cellhd', 'cell_misc', 'colr', 'fcell', 'hist'
]:
if not os.path.exists(element):
continue
path = os.path.join(mset_dir, element)
if not os.path.exists(path):
os.mkdir(path)
if element == 'cell_misc':
path = os.path.join(mset_dir, element, map_name)
if os.path.exists(path):
shutil.rmtree(path)
shutil.copytree('cell_misc', path)
else:
shutil.copyfile(element, os.path.join(mset_dir, element, map_name))
grass.message(_("Raster map <%s> unpacked") % map_name)
