Update translate

master3.3
Mike Hiretsky 12 years ago
parent 0a3677ed21
commit 4bf3be335f

@ -87,7 +87,7 @@ class updateConfFiles(color_print):
return False
clTempl = templateClt(self.clVars)
if not cltTemplatePath.endswith(clTempl.extFileTemplate):
self.printERROR(_("extension of the file '%s' not 'clt'")
self.printERROR(_("the extension of file '%s' is not 'clt'")
%cltTemplatePath)
return False
calcPkg = self.clVars.Get("cl_name")+"-" + self.clVars.Get("cl_ver")
@ -102,7 +102,7 @@ class updateConfFiles(color_print):
return False
if nameFile is True:
if clTempl.executedFiles:
self.printWARNING(_("Template %s was executed")
self.printWARNING(_("Template %s was applied")
%cltTemplatePath)
else:
self.printWARNING(_("Template %s not applied")

@ -25,7 +25,7 @@ from calculate.lib.utils.files import listDirectory,pathJoin
from calculate.lib.cl_lang import setLocalTranslate
setLocalTranslate('cl_install3',sys.modules[__name__])
USAGE = _("%prog [options] path_to_clt_file")
USAGE = _("%prog [options] path_to_the_clt_file")
COMMENT_EXAMPLES = _("Apply all templates to all packages")

@ -547,12 +547,12 @@ class MultiPartitions:
notFoundAttr = set(dictDataPart.keys()) - set(argv.keys())
if notFoundAttr:
raise DistributiveError(_("The following attributes "
"(%s) are not specified")\
"are not specified: (%s)")\
%", ".join(map(lambda x:"DataPartition.%s"%x, notFoundAttr)))
unnecessaryAttr = (set(dictDataPart.keys()) ^ set(argv.keys())) -\
set(dictDataPart.keys())
if unnecessaryAttr:
raise DistributiveError(_("Failed to use (%s) attributes")\
raise DistributiveError(_("Failed to use attributes (%s) ")\
%", ".join(map(lambda x:"DataPartition.%s"%x, unnecessaryAttr)))
else:
partObj = DataPartition()
@ -794,19 +794,18 @@ class PartitionDistributive(Distributive):
"""Checking mount point"""
if isMount(dev):
raise DistributiveError(
_("Failed to format %s, because this partition is mounted")%dev)
_("Failed to format %s: this partition is mounted")%dev)
def formatPartition(self, dev,format="reiserfs",label=""):
"""Format partition"""
if not format in self.formatUtilities:
raise DistributiveError(
_("Specified format of '%s' is not supported")%format)
_("The specified format of '%s' is not supported")%format)
if dev in map(lambda y: y.split(" ")[0],
filter(lambda x: x.startswith("/"),
open("/proc/swaps"))):
raise DistributiveError(\
_("Failed to format %s, because this partition "
"is used as swap")%dev)
_("Failed to format %s: this partition is used as swap")%dev)
self._checkMount(dev)
if not os.access(dev,os.W_OK):
raise DistributiveError(_("Failed to format the partition") +
@ -887,11 +886,11 @@ class PartitionDistributive(Distributive):
filter(lambda x: x.startswith("/"),
open("/proc/swaps"))):
raise DistributiveError(\
_("Failed to execute 'mkswap %s', as the swap partition is used"
" by the current system") %dev)
_("Failed to execute 'mkswap %s': the swap partition is used "
"by the current system") %dev)
if isMount(dev):
raise DistributiveError(
_("Failed to format %s, because this partition is mounted")%dev)
_("Failed to format %s: this partition is mounted")%dev)
execStr = self.formatUtilities["swap"]%dev
res,errmes = self.runOsCommand(execStr)
if res == 0:
@ -959,10 +958,10 @@ class ArchiveDistributive(Distributive):
res,mes = self.runOsCommand("tar xf %s -C %s/"%
(archfile,directory))
else:
raise DistributiveError(_("Unknown archive type by '%s'")%
raise DistributiveError(_("Unknown archive type '%s'")%
archfile)
if res != 0:
raise DistributiveError(_("Error during unpacking\n%s")%mes)
raise DistributiveError(_("Unpacking error\n%s")%mes)
def unpackTo(self,directory):
"""Unpack currect archive to directory"""
@ -1231,7 +1230,7 @@ class FlashDistributive(PartitionDistributive):
self._umountDirectory(mp)
else:
raise DistributiveError(
_("Failed to format %s, because this partition is mounted")
_("Failed to format %s: this partition is mounted")
%dev)
def getType(self):
@ -1257,7 +1256,7 @@ class FlashDistributive(PartitionDistributive):
**kwargs)
else:
raise DistributiveError(
_("Installation on a Flash does not support %s")%
_("Flash install does not support %s")%
source.__class__.__name__)
class ScratchDistributive(Distributive):
@ -1409,5 +1408,5 @@ class PxeDistributive(Distributive):
**kwargs)
else:
raise DistributiveError(
_("Installation for PXE does not support %s"%
_("PXE install does not support %s"%
source.__class__.__name__))

@ -425,7 +425,7 @@ class Install(color_print):
else:
sleep(waittime)
raise InstallError(
_("Failed to found partition %s after changing the activity")%
_("Failed to find partition %s after changing the activity")%
partition)
def installSyslinuxBootloader(self,target):
@ -744,7 +744,7 @@ class Install(color_print):
self.endTask()
# migrate users
self.startTask(_("Migrate users"))
self.startTask(_("Migrating users"))
objMigrate = migrate(targetDistr.getDirectory())
if not objMigrate.migrate(self.clVars.Get('cl_migrate_data'),[],[]):
raise InstallError(_("Failed to migrate users onto the new system"))
@ -868,14 +868,14 @@ class Install(color_print):
self.clVars.Get('os_root_type') != 'livecd':
target = self.clVars.Get('cl_image')
if self.clVars.Get('os_install_mbr'):
self.startTask(_("Installing bootloader"))
self.startTask(_("Installing the bootloader"))
self.prepareBoot(target)
self.endTask()
root_dev = self.clVars.Select('os_disk_parent',
where='os_disk_mount',
eq='/',limit=1)
if root_dev:
self.startTask(_("Changing I/O scheduler"))
self.startTask(_("Changing the I/O scheduler"))
try:
schedpath = ("/sys%s/queue/scheduler"%
(getUdevDeviceInfo(name=root_dev).get('DEVPATH','')))
@ -884,7 +884,7 @@ class Install(color_print):
self.clVars.Get('os_install_kernel_scheduler'))
self.endTask()
except:
self.printERROR(_("Unable change I/O scheduler"))
self.printERROR(_("Unable to change the I/O scheduler"))
pass
if not setupType:
self.installDesktopClient()
@ -964,12 +964,12 @@ class Install(color_print):
self.setTaskNumber(25)
# cmd options
if targetDistr.needFormat:
self.startTask(_("Formatting partitions"),progress=True)
self.startTask(_("Formatting the partitions"),progress=True)
targetDistr.performFormat()
self.endTask()
# install distributive
#raise InstallError("Manual stop")
self.startTask(_("Unpacking the system image into target"),
self.startTask(_("Unpacking the system image to the target"),
progress=True,num=18)
self.clVars.Get('os_grub_conf')
# set spinner flag
@ -993,18 +993,18 @@ class Install(color_print):
# join templates
if self.clVars.Get('os_install_pxe') == 'on':
self.startTask(
_("Configure PXE installation"),progress=True)
_("Configuring the PXE install"),progress=True)
self.applyTemplatesFlash('/')
else:
self.startTask(
_("Configuring flash installation"),progress=True)
_("Configuring the Flash install"),progress=True)
self.applyTemplatesFlash(targetDistr.getDirectory())
self.endTask()
self.closeClTemplate()
# change boot config
if self.clVars.Get('os_install_mbr') and \
self.clVars.Get('os_install_pxe') == "off":
self.startTask(_("Preparing system for reboot"))
self.startTask(_("Preparing the system for reboot"))
self.prepareBoot(targetDistr)
self.endTask()
except EOFError as e:
@ -1031,7 +1031,7 @@ class Install(color_print):
sourceDistr.close()
self.endTask()
if targetDistr and targetDistr.childs:
self.startTask(_("Unmount the target system volume"))
self.startTask(_("Unmounting the target system volume"))
targetDistr.close()
self.endTask()
except (VariableError,TemplatesError,
@ -1041,7 +1041,7 @@ class Install(color_print):
except KeyboardInterrupt,e:
pass
if error:
self.printERROR(_("System installation failed")+"!")
self.printERROR(_("Failed to install the system")+"!")
return False
self.printSUCCESS(_("System successfully installed")+"!")
self.endTask()

@ -154,7 +154,7 @@ class Wsdl:
return []
@rpc(Integer, InstallInfo, _returns = Array(ReturnedMessage))
@core_method(category=__('Installation'),title=__('System installation'),
@core_method(category=__('Installation'),title=__("System install"),
image='calculate-install,system-installer,applications-other,'
'drive-harddisk',
gui=True,command='cl-install',
@ -171,7 +171,7 @@ class Wsdl:
dv.addGroup(_("Language and locale"),
image="welcome",
normal=('os_install_locale_lang','os_install_clock_timezone'))
dv.addGroup(_("Choice of distro"),
dv.addGroup(_("Distribution"),
normal=('cl_image_filename',),
expert=('cl_image_linux_shortname', 'cl_image_arch_machine'))
dv.addGroup(_("Allocate drive space"),

@ -42,7 +42,7 @@ class VideoVariable(Variable):
"""
if self.Get('os_install_root_type') == 'flash':
return \
_("Video configuration unavailable for Flash installation")
_("Video configuration unavailable for Flash install")
if self.Get('os_install_x11_server_set') == 'no' and self.xorg_need:
return \
_("This distribution does not provide a Xorg server")
@ -130,10 +130,10 @@ class VariableOsInstallX11VideoDrv(VideoVariable):
def choice(self):
"""Get available (already installed or installable drivers"""
return self.Get('os_install_x11_video_available')
def get(self):
# get available videodriver list from install or configure distributive
list_video = self.Choice('os_install_x11_video_drv')#getAvailableVideo(distrPath)
list_video = self.Choice('os_install_x11_video_drv')
if not list_video:
return "other"
# if type system is usb-hdd then get detect video driver
@ -162,12 +162,12 @@ class VariableOsInstallX11VideoDrv(VideoVariable):
if self.Get('cl_action') == 'system':
availDrvs = self.Get('os_install_x11_video_available')
if not value in availDrvs:
raise VariableError(_("Available only %s drivers")%
raise VariableError(_("Only drivers % are available")%
",".join(availDrvs))
else:
if not value in getInstalledVideo(prefix="/") and \
not value in ("auto","other"):
error =_("videodriver %s is unavailable")%value
error =_("video driver %s is unavailable")%value
if value in self.pkgDrvMap:
error += ". " + (_("Install driver %s with:")
%self.pkgDrvMap[value][0])

@ -252,7 +252,7 @@ class AutoPartition:
if not self._createVolumesGroup(vgname,disks):
raise AutopartitionError(
_("Failed to create volumes group {groupname} from {disks}")
_("Failed to create volume group {groupname} from {disks}")
.format(groupname=vgname,
disks=",".join(devices)))
@ -316,8 +316,8 @@ class AutopartitionHelper:
def uncompatible(self):
if self.Get('cl_autopartition_set') == "off":
return \
_("Autopartition parameters are not available "
"with manual partitioning")
_("Autopartition options are not available with manual "
"partitioning")
return ""
class VariableHrMemorySize(ReadonlyVariable):
@ -362,7 +362,7 @@ class VariableClAutopartitionDevice(AutopartitionHelper,Variable):
untrusted = True
def init(self):
self.help = _("set the autopartition device")
self.help = _("set the device for autopartition")
self.label = _("Devices for install")
def get(self):
@ -421,14 +421,14 @@ class VariableClAutopartitionDevice(AutopartitionHelper,Variable):
for value in valuelist:
if value in useDisks:
raise VariableError(
_("Device %s is now used by the current system")%value)
_("Device %s is already in use by the current "
"system")%value)
self.checkOnLvm(valuelist)
self.checkOnRaid(valuelist)
if len(valuelist) > 1 and \
self.Get('cl_autopartition_lvm_set') == 'off':
raise VariableError(
_("You should use LVM for installation on "
"more that one device"))
_("You should use LVM to install on more that one device"))
freeSize = int(self.Get('cl_autopartition_free_size'))
if freeSize < 0 and (abs(freeSize))/(Sizes.M*100) > 0:
availSize = int(self.Get('cl_autopartition_device_size'))
@ -452,7 +452,7 @@ class VariableClAutopartitionSet(Variable):
self.help = _("autopartition")
def choice(self):
return [("off",_("Use current partitions")),
return [("off",_("Use the current partitions")),
("on",_("Autopartition"))]
class VariableClAutopartitionScheme(AutopartitionHelper,Variable,AutoPartition):

@ -594,7 +594,7 @@ class LocationHelper:
"""
if self.Get('cl_autopartition_set') == "on":
return \
_("Location is not available with autopartitioning")
_("Locations are not available with autopartitioning")
return ""
class VariableOsLocationData(LocationHelper,TableVariable):
@ -611,9 +611,10 @@ class VariableOsLocationData(LocationHelper,TableVariable):
"os_location_size"]
def init(self):
self.help = _("DISK bound for installation will be mounted to DIR DIR "
"set to 'none' will cancel the mount point transfer For creating bind "
"mount point you have to specify the source directory as DISK")
self.help = _("DISK bound for installation will be mounted to the "
"DIR directory. If set to 'none', the mount point will "
"not be moved. To create a bind mount point, you have "
"to specify the source directory as DISK")
self.label = _("Locations")
class VariableOsLocationSource(LocationHelper,DeviceHelper,Variable):
@ -705,11 +706,11 @@ class VariableOsLocationSource(LocationHelper,DeviceHelper,Variable):
wrongDevices = list(set(disks) - \
set(self.fixOsDiskDev()))
if wrongDevices:
raise VariableError(_("Incorrect device '%s'")%wrongDevices[0])
raise VariableError(_("Wrong device '%s'")%wrongDevices[0])
wrongSource = filter(lambda x:x and not x.startswith('/'),value)
if wrongSource:
raise VariableError(
_("Incorrect bind mount point '%s'")%wrongSource[0])
_("Wrong bind mount point '%s'")%wrongSource[0])
##########################
# detect duplicate devices
##########################
@ -822,7 +823,7 @@ class VariableOsLocationDest(LocationHelper,Variable):
wrongMP = filter(lambda x:x and not x.startswith("/") and x != "swap",
value)
if wrongMP:
raise VariableError(_("Incorrect mount point '%s'")%wrongMP[0])
raise VariableError(_("Wrong mount point '%s'")%wrongMP[0])
#########################################
# Check using current root
#########################################
@ -861,7 +862,7 @@ class VariableOsLocationDest(LocationHelper,Variable):
incompBind = filter(lambda x:x[1]==wrongBind[0],
zip(srcMountPoints,destMountPoints))
raise VariableError(
_("Source directory %(src)s already used "
_("Source directory %(src)s is already used "
"for binding '%(bindSrc)s' to '%(bindDst)s'")\
%{'src':wrongBind[0],
'bindSrc':incompBind[0][0],
@ -873,11 +874,11 @@ class VariableOsLocationDest(LocationHelper,Variable):
if osInstallRootType == "flash":
if filter(lambda x: x and x != '/', value):
raise VariableError(
_("Installation on a Flash disk is not supported for "
"multipartition install"))
_("The Flash install is not supported for "
"multipartition install"))
if filter(lambda x: x == "swap",value):
raise VariableError(_("Installation on a Flash disk is not "
"supported for swap disks"))
raise VariableError(_("The Flash install is not supported "
"for swap disks"))
########################################
# check install on member of RAID or LVM
########################################
@ -958,9 +959,9 @@ class VariableOsLocationFormat(LocationHelper,Variable):
if not FileSystemManager.checkFSForType(fs,
osInstallRootType):
raise VariableError(
_("Filesystem for '%(mp)s' should not be '%(opt)s'")
_("The filesystem for '%(mp)s' should not be '%(opt)s'")
%{'mp':mp, 'opt':fs}+" "+
_("for {typedisk} installation").format(
_("for the {typedisk} install").format(
typedisk=osInstallRootType))
if mp == "swap" and fs != "swap":
raise VariableError(
@ -1016,9 +1017,8 @@ class VariableOsLocationPerformFormat(LocationHelper,Variable):
# partition use in current system
if diskMount.get(dev,''):
raise VariableError(
_("{device}should, but cannot be formatted, because "
"mounted to {mountpoint} in "
"the current system").format(
_("{device}should, but cannot be formatted, as it is "
"mounted to {mountpoint} on the current system").format(
device=dev,mountpoint=diskMount.get(dev,'')))
if isMount(dev):
raise VariableError(
@ -1042,8 +1042,8 @@ class VariableOsLocationPerformFormat(LocationHelper,Variable):
_("Bind mount points should not be formatted"))
elif isMount(dev):
raise VariableError(
_("Please unmount disk {device} for using in"
" installation").format(device=dev))
_("Please unmount disk {device} to "
"use it for install").format(device=dev))
def defaultPerformFormat(self):
diskFormat = dict(zip(self.Get('os_disk_dev'),
@ -1440,7 +1440,7 @@ class VariableOsInstallMbr(LocationHelper,Variable):
if rootType == "flash":
if len(value) > 1:
raise VariableError(
_("For Flash installation, you need only one disk"))
_("For the Flash install, you need only one disk"))
for mbrDisk in value:
if self.Get('cl_autopartition_set') == 'on':
tableOnBootDisk = self.Get('cl_autopartition_table')
@ -1449,12 +1449,12 @@ class VariableOsInstallMbr(LocationHelper,Variable):
where="os_device_dev",eq=mbrDisk,limit=1)
if not tableOnBootDisk:
raise VariableError(
_("Disk '%s' without partition table "
"contains no boot record")%mbrDisk)
_("Disk '%s' need a partition table for the boot record")%
mbrDisk)
if rootType == "flash":
if tableOnBootDisk == "gpt":
raise VariableError(_("For Flash installation, you need "
"a disk with dos table"))
raise VariableError(_("For the Flash install, you "
"need a disk with a dos table"))
if value:
if self.Get('os_grub2_path'):
self.checkForGrub2()

@ -300,7 +300,8 @@ class VariableClImageFilename(Variable,DistroRepository):
if subname:
subname=" %s"%subname
return "{fullname} {march} {build}".format(
fullname="%s%s"%(fullname,subname),filepath=filepath,**distroinfo)
fullname="%s%s"%(fullname,subname),filepath=filepath,
**distroinfo)
else:
return filepath
@ -317,7 +318,8 @@ class VariableClImageFilename(Variable,DistroRepository):
discardType=discardType)
if self.wasSet:
distros.append(self.value)
return sorted(map(lambda x:(x,self.humanImageName(self._getDistrInfo(x),x)),
return sorted(map(lambda x:(x,
self.humanImageName(self._getDistrInfo(x),x)),
distros),key=itemgetter(1))
class VariableClImageArchMachine(Variable,DistroRepository):

@ -38,7 +38,7 @@ class LocaleVariable(ReadonlyVariable,Locale):
"""
if self.Get('os_install_root_type') == 'flash':
return \
_("Locale configuration unavailable for Flash installation")
_("Locale configuration unavailable for the Flash install")
return ""
class VariableOsInstallLinguas(LocaleVariable):
@ -179,7 +179,7 @@ class VariableOsInstallClockTimezone(LocaleVariable):
def check(self,value):
if not value or not path.isfile(path.join(
"/usr/share/zoneinfo",value)):
raise VariableError(_("%s timezone is wrong")%value)
raise VariableError(_("the %s timezone is wrong")%value)
def generateComments(self,tzs):
"""

@ -44,12 +44,12 @@ class NetHelper:
"""
if self.Get('os_install_root_type') == 'flash':
return \
_("Network configuration unavailable for Flash installation")
_("Network configuration is unavailable for the Flash install")
if self.routing and not self.Select('os_install_net_interfaces',
where='os_install_net_dhcp_set',
eq='off',limit=1):
return _("Network routing is not available "
"if all interfaces are set to DHCP")
return _("Network routing configuration is not available if all "
"interfaces are set to DHCP")
return ""
class VariableOsInstallNtp(NetHelper,Variable):
@ -138,7 +138,7 @@ class VariableOsInstallNetFqdn(NetHelper,Variable):
def init(self):
self.label = _("Hostname")
self.help = _("set the short or full hostname")
self.help = _("set either the short or the full hostname")
def set(self,value):
if "." in value:
@ -610,7 +610,7 @@ class VariableOsInstallNetDnsSearch(NetHelper,Variable):
def init(self):
self.label = _("Search domains")
self.help = _("search domains (comma delimeter)")
self.help = _("search domains (comma-separated)")
def isDNSByDHCP(self):
"""
@ -634,7 +634,7 @@ class VariableOsInstallNetDnsSearch(NetHelper,Variable):
return "" if self.isDNSByDHCP() else dnsSearch
def humanReadable(self):
return self.Get() or (_("Received by DHCP")
return self.Get() or (_("Get via DHCP")
if self.isDNSByDHCP()
else _("Not used"))
@ -646,8 +646,8 @@ class VariableOsInstallNetDns(VariableOsInstallNetDnsSearch):
metavalue = "DNS"
def init(self):
self.label = _("Domain name servers")
self.help = _("domain name servers (comma delimeter)")
self.label = _("Domain name server")
self.help = _("domain name server (comma-separated)")
def set(self,value):
return " ".join(re.split('[; ,]',value))
@ -662,10 +662,10 @@ class VariableOsInstallNetDns(VariableOsInstallNetDnsSearch):
def check(self,value):
reIp = re.compile(ip.IP_ADDR)
if any(ifilterfalse(reIp.match,value.split(','))):
raise VariableError(_("Wrong DNS IP addresses"))
raise VariableError(_("Wrong IP addresses for DNS"))
def humanReadable(self):
return self.Get() or (_("Received by DHCP")
return self.Get() or (_("Get via DHCP")
if self.isDNSByDHCP()
else _("Not used"))

@ -42,7 +42,7 @@ class UserHelper:
User setting up unavailable for flash installation
"""
if self.Get('os_install_root_type') == 'flash':
return _("User configuration unavailable for Flash installation")
return _("User configuration unavailable for Flash install")
if self.Get('os_install_x11_server_set') == 'no' and self.xorg_need:
return _("Autologin is available for Xorg sessions only")
return ""
@ -56,7 +56,7 @@ class VariableOsInstallScratch(Variable):
def init(self):
self.label = _("Builder mode")
self.help = _("installation for build")
self.help = _("build installation")
def get(self):
# for installation default - normal system
@ -70,8 +70,7 @@ class VariableOsInstallScratch(Variable):
# scratch not use for falsh and multipartition
if self.Get('os_install_root_type') == "flash":
raise VariableError(
_("Installation on a Flash disk is not supported"
" in the builder mode"))
_("The Flash install is not supported in the builder mode"))
if filter(lambda x: not x in ('/','swap'),
self.Get('os_install_disk_mount')):
raise VariableError(
@ -235,7 +234,7 @@ class VariableClAutologin(UserHelper,Variable):
Autologin only for migrated non-root users
"""
if value and not value in self.Get('cl_migrate_user'):
raise VariableError(_("User %s is not exists")%value)
raise VariableError(_("User %s does not exist")%value)
if value == "root":
raise VariableError(_("Autologin is unavailable for user %s")%value)
@ -444,7 +443,7 @@ class VariableClSetup(Variable):
def check(self,value):
if value == "boot" and self.Get('os_install_root_type') == 'livecd':
raise VariableError(
_("Boot configuration is not available on LiveCD"))
_("Boot configuration is not available on a LiveCD"))
class VariableClLive(Variable):
"""
@ -455,8 +454,8 @@ class VariableClLive(Variable):
opt = ['--live']
def init(self):
self.label = _("Configure only dynamic parameters")
self.help = _("configure only dynamic parameters")
self.label = _("Configure only dynamic options")
self.help = _("configure only dynamic options")
class VariableClTemplatesLocate(Variable):
"""
@ -471,7 +470,7 @@ class VariableClTemplatesLocate(Variable):
def init(self):
self.label = _("Location templates")
self.help = _("select location templates %s") \
self.help = _("select location for templates %s") \
%"'overlay','local','remote','clt'"
def choice(self):
@ -492,12 +491,12 @@ class VariableOsInstallPxe(ReadonlyVariable):
if value == "on":
if self.Get('os_linux_system') != "server":
raise VariableError(
_("PXE installation is available for Calculate Directory "
_("The PXE install is available for Calculate Directory "
"Server only")+'.')
for pkg in ['net-misc/dhcp','net-ftp/tftp-hpa','net-fs/nfs-utils']:
if not isPkgInstalled(pkg):
raise VariableError(
_("You must to install %s package for PXE installation")
_("For the PXE install, you need to install package %s")
%pkg)
try:
config = cl_template.iniParser('/etc/calculate/calculate.env')
@ -507,8 +506,8 @@ class VariableOsInstallPxe(ReadonlyVariable):
except:
pass
raise VariableError(
_("PXE installation is available with "
"DHCP service configured only"))
_("The PXE install is only available if the DHCP service has "
"been configured first"))
class VariableOsInstallPxePath(Variable):
"""
@ -520,4 +519,4 @@ class VariableOsInstallPxePath(Variable):
def init(self):
self.label = _("Path for installation")
self.help = _("path for PXE installation")
self.help = _("path for the PXE install")

Loading…
Cancel
Save