Current File : //usr/lib/python3/dist-packages/xkit/xorgparser.py
# xorgparser.py -- Core class of X-Kit's parser
#
# Copyright 2008 Alberto Milone <albertomilone@alice.it>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
from __future__ import print_function
from __future__ import unicode_literals
import sys
from sys import stdout, stderr
import copy
class IdentifierException(Exception):
'''Raise if no identifier can be found'''
pass
class OptionException(Exception):
'''Raise when an option is not available.'''
pass
class SectionException(Exception):
'''Raise when a section is not available.'''
pass
class ParseException(Exception):
'''Raise when a postion is not available.'''
pass
class Parser(object):
'''Only low-level methods here.
See the xutils.XUtils subclass for higher-level methods.'''
def __init__(self, source=None):
'''source = can be an object or a file. If set to None (default)
Parser will start from scratch with an empty
configuration.
Public:
comments = name of the section which stores the commented lines
located outside of the sections in the xorg.conf.
globaldict = a global dictionary containing all the sections and
options. For further information on globaldict, have a
look at __check_sanity() and at get_value().
globaldict['Comments'] = stores the commented lines located inside of
the sections in the xorg.conf.
require_id = a list of the sections which require to have an
"Identifier" set in the xorg.conf (e.g. Device sections).
identifiers = a dictionary of the sections which require identifiers.
sections = a tuple containing the names of all the sections in
globaldict. Their names are not guaranteed to be all legal
in xorg.conf (see "valid_sections").
valid_sections = a tuple containing the names of all the sections
which __check_sanity() will look for in the
xorg.conf. Sections with other names will be ignored
by self._check_sanity().
references = a list containing the names of all the possible
references.'''
self.subsection = 'SubSection'
self.commentsection = 'Comments'
self.source = source
self.sections = ('InputDevice',
'Device',
'Module',
'Monitor',
'Screen',
'ServerLayout',
'ServerFlags',
'Extensions',
'Files',
'InputClass',
'DRI',
'VideoAdaptor',
'Vendor',
'Modes',
self.subsection,
self.commentsection)
# "Comments" is not a valid section
self.valid_sections = self.sections[:-1]
self.require_id = [
'InputClass',
'InputDevice',
'Device',
'Monitor',
'Screen',
'ServerLayout'
]
self.references = [
'Device',
'InputDevice',
'Monitor',
'Screen'
]
self.identifiers = {}.fromkeys(self.require_id)
self.comments = []
self._gdict = {}.fromkeys(self.sections, 0)
for elem in self._gdict:
self._gdict[elem] = {}
self._check_sanity()
def _get_global(self):
return self._gdict
def _set_global(self, global_dict):
self._gdict = global_dict
# Property to expose _gdict as globaldict
globaldict = property(_get_global, _set_global)
def _check_sanity(self):
'''Perform a sanity check of the file and fill self.globaldict with
all the sections and subsections in the xorg.conf
empty = is the file empty? If yes, then don't check if:
* the last section is not complete
* there are duplicates
has_section:
* == True: a section is already open
* == False: a section is closed and/or a new section can be opened
has_subsection:
* == True: a subsection is already open
* == False: a section is closed and/or a new section can be opened
section_flag:
* == '':a section is closed and/or a new section can be opened
* == the name the current section
section_tags = counter of the number of Section and EndSection strings
subsection_tags = counter of the number of SubSection and EndSubSection
strings
lines_list = the list of the lines in the source object.
global_iters = counts how many times each kind of section
(section_flag) is found in the xorg.conf'''
#See if the source is a file or a file object
#and act accordingly
file = self.source
if file == None:
lines_list = []
else:
if not hasattr(file, 'write'):#it is a file
myfile = open(file, 'r')
lines_list = myfile.readlines()
myfile.close()
else:#it is a file object
lines_list = file.readlines()
# Create a dictionary such as the following:
# {'Device': {}, 'InputDevice': {}}
global_iters = {}.fromkeys(self.sections, 0)
empty = True
has_section = False
has_subsection = False
section_flag = ''
section_tags = 0
subsection_tags = 0
it = 0
for line in lines_list:
if line.strip().startswith('#'):
if has_section == False:
self.comments.append(line)
else:#has_section == True
section_pos = global_iters[section_flag]
if has_subsection == False:
self._gdict[self.commentsection].setdefault(section_flag, {})
temp_dict = self._gdict[self.commentsection][section_flag]
temp_dict.setdefault(section_pos, {})
temp_dict[section_pos].setdefault('identifier', None)
temp_dict[section_pos].setdefault('position', section_pos)
temp_dict[section_pos].setdefault('section', None)
temp_dict[section_pos].setdefault('options', [])
temp_dict[section_pos]['options'].append(line.strip())
else:#has_subsection == True
curlength = global_iters[self.subsection]
self._gdict[self.commentsection].setdefault(self.subsection, {})
temp_dict = self._gdict[self.commentsection][self.subsection]
temp_dict.setdefault(curlength, {})
temp_dict[curlength].setdefault('identifier', subsection_id)
temp_dict[curlength].setdefault('position', section_pos)
temp_dict[curlength].setdefault('section', section_flag)
temp_dict[curlength].setdefault('options', [])
temp_dict[curlength]['options'].append(line.strip())
del temp_dict
# See if the name of the section is acceptable
# i.e. included in self.valid_sections
elif line.lower().strip().startswith('section'):#Begin Section
test_line_found = False
for sect in self.valid_sections:
if line.lower().find('"' + sect.lower() + '"') != -1:
test_line_found = True
section = sect
break
if not test_line_found:
# e.g. in case the name of the section is not
# recognised:
# Section "whatever"
error = ('The name in the following line is invalid for a '
'section:\n%s' % (line))
raise ParseException(error)
else:
if has_section == False:
section_tags += 1
section_flag = section
empty = False
has_section = True
else:
error = 'Sections cannot be nested in other sections.'
raise ParseException(error)
elif line.lower().strip().startswith('endsection') == True:
#End Section
section_tags += 1
if has_section == True and has_subsection == False:
global_iters[section_flag] += 1
section_flag = ''
has_section = False
else:
error = 'An EndSection is in the wrong place.'
raise ParseException(error)
elif line.lower().strip().startswith('subsection') == True:
#Begin SubSection
subsection_tags += 1
if has_section == True and has_subsection == False:
has_subsection = True
subsection_id = line[line.find('"') + 1:
line.rfind('"')].strip()
self._gdict.setdefault(self.subsection, {})
curlength = global_iters[self.subsection]
self._gdict[self.subsection][curlength] = {}
# self._gdict - keys:
#
# section = the section in which the subsection is
# located (e.g. "Screen")
# position = e.g. in key 0 of the
# self._gdict['Screen']
# identifier = e.g. 'Display' (in SubSection "Display")
# options = a list of lines with the options
temp_dict = self._gdict[self.subsection][curlength]
temp_dict['section'] = section_flag
try:
temp_dict['position'] = global_iters[section_flag]
except KeyError:
del temp_dict
error = ('SubSections can be nested only in well '
'formed sections.')
raise ParseException(error)
temp_dict['identifier'] = subsection_id
temp_dict['options'] = []
del temp_dict
else:
error = ('SubSections can be nested only in well formed '
'sections.')
raise ParseException(error)
elif line.lower().strip().startswith('endsubsection') == True:
#End SubSection
subsection_tags += 1
if has_subsection == True:
has_subsection = False
global_iters[self.subsection] += 1
else:
error = ('SubSections can be closed only after being '
'previously opened.')
raise ParseException(error)
else:
if section_flag != '':
#any other line
if line.strip() != '':
#options
if has_subsection == True:
# section = the section in which the subsection
# is located (e.g. "Screen")
# position = e.g. in key 0 of the
# self._gdict['Screen']
# identifier = e.g. 'Display' (in SubSection
# "Display")
# options = a list of lines with the options
self._gdict[self.subsection][curlength][
'options'].append('\t' + line.strip() + '\n')
else:
self._gdict.setdefault(section_flag, {})
curlength = global_iters[section_flag]
self._gdict[section_flag].setdefault(curlength,
[]).append('\t' + line.strip() + '\n')
it += 1
if not empty:
# If the last section is not complete
if section_tags % 2 != 0 or subsection_tags % 2 != 0:
error = 'The last section is incomplete.'
raise ParseException(error)
# Fill self.identifiers
self._fill_identifiers()
# Make sure that the configuration file is compliant with
# the rules of xorg
self._check_syntax()
else:
self._fill_identifiers()
def _check_syntax(self):
'''This method contains the several checks which can guarantee
compliance with the syntax rules of the xorg.conf'''
# '''
# Raise an exception if there are duplicate options i.e.
# options (not references) of the same kind with the same
# or with a different value.
#
# e.g. Driver "nvidia" and Driver "intel" cannot coexist in the
# same Device section.
# '''
# if len(self.check_duplicate_options()) > 0:
# error = ('There cannot be Duplicate Options:\n%s' %
# (str(self.check_duplicate_options())))
# raise ParseException(error)
# Raise an exception if there are duplicate sections i.e.
# sections of the same kind (e.g. "Device") with the same
# identifier.
#
# e.g. The following configuration is not allowed:
#
# Section "Device"
# Identifier "My Device"
# EndSection
#
# Section "Device"
# Identifier "My Device"
# EndSection
if len(self.get_duplicate_sections()) > 0:
error = ('There cannot be Duplicate Sections:\n%s'
% (str(self.get_duplicate_sections())))
raise ParseException(error)
# One word entries are not acceptable as either options or references.
# If one is found, ParseException will be raised.
self._validate_options()
# Raise an exception if there are broken references i.e. references
# to sections which don't exist.
#
# For example, if the xorg.conf were the following:
#
# Section "Device"
# Identifier "Another Device"
# EndSection
#
# Section "Screen"
# Identifier "My Screen"
# Device "My Device"
# EndSection
#
# There would be no Device section which has "My Device" as an
# identifier
broken = self.get_broken_references()
it = 0
for section in broken:
it += len(broken[section])
if it > 0:
error = 'There cannot be Broken References:\n%s' % (str(broken))
raise ParseException(error)
# If there are sections which don't have an identifier
# but they should (i.e. they are in self.require_id)
#
# NOTE: if there are empty sections without an identifier
# e.g. Section "Device"
# EndSection
#
# they won't trigger the ParseException but won't
# cause any problem since they will be completely
# ignored and won't appear in the target file.
for section in self.require_id:
if len(self._gdict[section]) != len(self.identifiers[section]):
error = ('Not all the sections which require an identifier '
'have an identifier.')
raise ParseException(error)
# The ServerLayout section must have at least 1 reference to a
# "Screen" section
if len(self._gdict['ServerLayout']) > 0:
for section in self._gdict['ServerLayout']:
screen_references = self.get_references('ServerLayout',
section,
reflist=['Screen'])
if len(screen_references['Screen']) == 0:
error = ('The ServerLayout section must have at '
'least 1 reference to a "Screen" section.')
raise ParseException(error)
# No more than one default ServerLayout can be specified in the
# ServerFlags section
default_layout = self.get_default_serverlayout()
if len(default_layout) > 0:
if len(default_layout) > 1:
error = ('No more than one default ServerLayout can be '
'specified in the ServerFlags section.')
raise ParseException(error)
if not self.is_section('ServerLayout', position=default_layout[0]):
error = 'The default ServerLayout does not exist.'
raise ParseException(error)
def _fill_identifiers(self):
'''Fill self.identifiers
self.identifiers has the section types as keys and a list of tuples
as values. The tuples contain the identifier and the position of
each section.
Here's a basic scheme:
self.identifiers = {section_type1: [
(identifier1, position1),
(identifier2, position2)
], etc.
}
Concrete example:
self.identifiers = {'Device': [
('Configured Video Device', 0),
('Another Video Device', 1)
],
'Screen': [
('Configured Screen Device', 0),
('Another Screen Device', 1)
],
} '''
for sect in self.require_id:#identifiers.keys():
self.identifiers[sect] = []
it = 0
for elem in self._gdict[sect]:
try:
identifier = self.get_value(sect, 'Identifier', it)
except (OptionException, SectionException):
#if no identifier can be found
error = ('No Identifier for section %s, position %d, '
'can be found.' % (sect, elem))
raise ParseException(error)
try:
identifier.append('')
identifier = identifier[0]
except AttributeError:
pass
self.identifiers[sect].append((identifier, it))
it += 1
def _validate_options(self):
'''One word entries are not acceptable as either options or references
If a one word entry is found, ParseException will be raised.'''
# Sections in sections_whitelist won't be validated
sections_whitelist = ['Files', 'Comments']
options_whitelist = ['endmode']
for section in self.sections:
if section not in sections_whitelist:
for position in self._gdict[section]:
if section == self.subsection:#'SubSection':
options = self._gdict[section][position]['options']
else:
options = self._gdict[section][position]
for option in options:
option = option.strip()
if option.find('#') != -1:#remove comments
option = option[0: option.find('#')]
error = ('The following option is invalid: %s'
% (option.strip()))
optbits = self._clean_duplicates(option,
include_null=True)
if (len(optbits) == 1
and optbits[0].strip().lower() not
in options_whitelist):
raise ParseException(error)
if not optbits[0][0].isalpha():
raise ParseException(error)
def get_duplicate_options(self, section, position):
'''See if there are duplicate options in a section
It is ok to have duplicated references e.g. several Load options, or
Screen, etc. though'''
blacklist = ['driver', 'busid', 'identifier']
total = []
duplicates = []
if section == 'SubSection':
options = self._gdict[section][position]['options']
else:
options = self._gdict[section][position]
for option in options:
option = option.strip()
if option.find('#') != -1:#remove comments
option = option[0: option.find('#')]
optbits = self._clean_duplicates(option)
# optbits may look like this:
#
# ['Option', 'TestOption1', '0']
#
# or
# ['Screen', 'My screen 1']
try:
if optbits[0].lower() in blacklist:
total.append(optbits[0])
elif optbits[0].lower() == 'option':
if len(optbits) > 1 and optbits[1] != None:
'''
make sure it's not a broken option e.g.
Option
'''
total.append(optbits[1])
except (AttributeError, IndexError):
pass
final = {}
for option in total:
if final.get(option) != None:
duplicates.append(option)
else:
final[option] = option
return duplicates
def check_duplicate_options(self):
'''Look for and return duplicate options in all sections'''
duplicates = {}
for section in self._gdict:
for elem in self._gdict[section]:
duplopt = self.get_duplicate_options(section, elem)
if len(duplopt) > 0:
duplicates.setdefault(section, {}).setdefault(elem,
duplopt)
return duplicates
def _clean_duplicates(self, option, include_null=None):
'''Clean the option and return all its components in a list
include_null - is used only by _validate_options() and makes
sure that options with a null value assigned in quotation
marks are not considered as one-word options'''
#print '\nCLEAN', repr(option)
optbits = []
optbit = ''
it = 0
quotation = 0
optcount = option.count('"')
if optcount > 0:#dealing with a section option
for i in option:
#print 'i', repr(i), 'optbit', optbit
if not i.isspace():
if i == '"':
quotation += 1
else:
optbit += i
else:
if quotation % 2 != 0:
optbit += i
else:
if len(optbit) > 0:
optbits.append(optbit)
#print 'i=', i, 'optbit=', optbit
optbit = ''
if it == len(option) - 1:
if optbit != '':
optbits.append(optbit)
#print 'i=END', 'optbit=', optbit
it += 1
else:#dealing with a subsection option
for i in option:
#print 'i', repr(i), 'optbit', optbit
if not i.isspace():
optbit += i
else:
if len(optbit) > 0:
optbits.append(optbit)
#print 'i=', i, 'optbit=', optbit
optbit = ''
if it == len(option) - 1:
if optbit != '':
optbits.append(optbit)
#print 'i=END', 'optbit=', optbit
else:
if include_null:
optbit = ''
optbits.append(optbit)
it += 1
if include_null and len(optbits) != optcount/2 +1:
# e.g. if the option looks like the following:
#
# Modelname ""
#
# add a '' which wouldn't be caught by this method otherwise.
optbit = ''
optbits.append(optbit)
return optbits
def get_duplicate_sections(self):
'''Return a dictionary with the duplicate sections i.e. sections
of the same kind, with the same identifier'''
duplicates = {}
for section in self.identifiers:
temp = []
for sect in self.identifiers[section]:
temp.append(sect[0])
for elem in temp:
if temp.count(elem) > 1:
duplicates.setdefault(section, {}).setdefault(elem,
temp.count(elem))
return duplicates
def add_option(self, section, option, value, option_type=None,
position=None, reference=None, prefix='"'):
'''Add an option to a section
section= the section which will have the option added
option= the option to add
value= the value which will be assigned to the option
position= e.g. 0 (i.e. the first element in the list of Screen
sections)
option_type= if set to "Option" it will cause the option to look like
the following:
Option "NameOfTheOption" "Value"
Otherwise it will look like the following:
NameOfTheOption "Value"
position= e.g. 0 (i.e. the first element in the list of Screen
sections)
reference= used only in a particular case of reference (see
add_reference)
prefix= usually quotation marks are used for the values (e.g. "True")
however sometimes they don't have to be used
(e.g. DefaultDepth 24) and prefix should be set to '' instead
of '"' '''
refSections = ['device']
#prefix = '"'#values are always in quotation marks
if position != None:
if self._gdict[section].get(position) == None:
raise SectionException
if reference:
# Remove an option if it has a certain assigned value. We want
# to do this when removing a reference.
self.remove_option(section, option, value=value,
position=position)
#print 'Remove', option, 'from', section, 'position', position
else:
# value has to be set to None, however there is no way to do
# so other than this since add_option() cannot be called with
# value=None. Hence the need for this ugly nested if-block.
self.remove_option(section, option, position=position)
else:
#print 'Remove', option, 'from all', section
self.remove_option(section, option)
if option_type == None:
if reference == None:
toadd = ('\t' + option + '\t' + prefix + str(value) + prefix
+ '\n')
else:
if section.strip().lower() not in refSections:
# e.g. Screen "New Screen"
toadd = ('\t' + option + '\t' + prefix + str(value)
+ prefix + '\n')
else:
# e.g. Screen 0
# which is used for Xinerama setups in the Device section
toadd = '\t' + option + '\t' + str(value) + '\n'
else:
toadd = ('\t' + option_type + '\t' + '"' + option + '"' + '\t'
+ prefix + str(value) + prefix + '\n')
if len(self._gdict[section]) == 0:
self._gdict[section] = {}
self._gdict[section][0] = []
if section in self.require_id:
identifier = '\tIdentifier\t"Default ' + section + '"\n'
self._gdict[section][0].append(identifier)
if position == None:
for elem in self._gdict[section]:
self._gdict[section][elem].append(toadd)
else:
self._gdict[section][position].append(toadd)
def _get_options_to_blacklist(self, section, option, value=None,
position=None, reference=None):
'''Private method shared by remove_option and comment_out_option'''
to_remove = {}
if len(self._gdict[section]) != 0:#if the section exists
if position == None:
#print 'Removing', option, 'from all', section, 'sections'
for elem in self._gdict[section]:
it = 0
for line in self._gdict[section][elem]:
if value != None:
#print 'line =', line, 'option=', option, 'value',
# value
if (line.lower().find(option.lower()) != -1
and line.lower().find(value.lower()) != -1):
to_remove.setdefault(elem, []).append(it)
else:
if line.lower().find(option.lower()) != -1:
to_remove.setdefault(elem, []).append(it)
it += 1
else:
if self._gdict[section].get(position) == None:
return
else:
#print 'Removing', option, 'from', section, 'position',
# position
it = 0
for line in self._gdict[section][position]:
if value != None:
# Remove the option only if it has a certain value
# assigned. This is useful in case we want to
# remove a reference to a certain Section from
# another section:
# e.g. Screen "Generic Screen".
if (line.lower().find(option.lower()) != -1
and line.lower().find(value.lower()) != -1):
to_remove.setdefault(position, []).append(it)
else:
# Remove the option without caring about the
# assigned value
if line.lower().find(option.lower()) != -1:
to_remove.setdefault(position, []).append(it)
it += 1
return to_remove
def remove_option(self, section, option, value=None, position=None,
reference=None):
'''Remove an option from a section.
section= the section which will have the option removed
option= the option to remove
value= if you want to remove an option only if it has a certain value
position= e.g. 0 (i.e. the first element in the list of Screen
sections)'''
to_remove = self._get_options_to_blacklist(section, option, value,
position, reference)
for part in to_remove:
modded = 0
for line in to_remove[part]:
realpos = line - modded
del self._gdict[section][part][realpos]
modded += 1
def make_section(self, section, identifier=None):
'''Create a new section and return the position of the section
The position is relative to the list of sections of the same type
(e.g. "Screen") so as to make it available in case the user wants
to add some options to it.
The identifier and the position of the new section is added to
self.identifiers[section]
section= the section to create
identifier= the identifier of a section (if the section requires
an identifier)'''
position = len(self._gdict[section])
if section in self.require_id:
if identifier != None:
option = 'Identifier'
# Don't create a new section if one of the same kind and
# with the same 'Identifier' is found
create = True
for sub in self._gdict[section]:
if self.get_value(section, option, sub):
try:
if (self.get_value(section,
option,
sub).strip().lower()
== identifier.strip().lower()):
create = False
break
except AttributeError:
for elem in self.get_value(section, option, sub):
#print 'elem=', elem, 'id=', identifier
if (elem.strip().lower()
== identifier.strip().lower()):
create = False
break
if create:
self._gdict[section][position] = []
self.add_option(section, option, value=identifier,
position=position)
# Add to identifiers
self.identifiers[section].append((identifier, position))
#print 'Created section', section, 'id =', identifier,
# 'position =', position
#else:
#print section, 'Section labelled as', identifier,
#'already exists. None will be created.'
else:
raise IdentifierException(('%s Section requires an identifier'
%(section)))
else:
self._gdict[section][position] = []
return position
def remove_section(self, section, identifier=None, position=None):
'''Remove Sections by identifier, position or type'''
# Remove any section of "section" type with the same identifier
# currently sections of the same type cannot have the same id
# for obvious reasons
to_remove = {}
if identifier:
try:
pos = self.get_position(section, identifier)
to_remove.setdefault(pos, None)
except IdentifierException:
pass
# Comment the section of "section" type at position "position"
elif position != None:
if self.is_section(section, position=position):
to_remove.setdefault(position, None)
# Comment any section of "section" type
else:
allkeys = list(self._gdict[section].keys())
to_remove = {}.fromkeys(allkeys)
# If the section has an identifier i.e. if the section
# is in self.require_id
if section in self.require_id:
# Get the references to remove from self.identifiers
it = 0
for reference in self.identifiers[section]:
try:
ref = list(to_remove.keys()).index(reference[1])
to_remove[list(to_remove.keys())[ref]] = it
except ValueError:
pass
it += 1
sorted_remove = list(to_remove.keys())
sorted_remove.sort()
modded = 0
for sect in sorted_remove:
subsections = self.get_subsections(section, sect)
# Remove all its SubSections from SubSection
for sub in subsections:
try:#remove subsection
del self._gdict[self.subsection][sub]
except KeyError:
pass
# Remember to remove any related entry from the "Comments"
# section
self._remove_comment_entries(section, sect)
# Remove the section from _gdict
del self._gdict[section][sect]
# Remove the reference from identifiers
# if such reference exists
identref = to_remove[sect]
if identref != None:
realpos = identref - modded
del self.identifiers[section][realpos]
modded += 1
def add_reference(self, section, reference, identifier, position=None):
'''Add a reference to a section from another section.
For example:
to put a reference to the Screen section named "Default Screen"
in the ServerLayout section you should do:
section='ServerLayout'
reference='Screen'
identifier='Default Screen'
position=0 #the first ServerLayout section
NOTE: if position is set to None it will add such reference to any
instance of the section (e.g. to any ServerLayout section)'''
self.add_option(section, reference, value=identifier,
position=position, reference=True)
def remove_reference(self, section, reference, identifier, position=None):
'''Remove a reference to a section from another section.
For example:
to remove a reference to Screen "Default Screen" from the
ServerLayout section you should do:
section='ServerLayout'
reference='Screen'
identifier='Default Screen'
position=0 #the first ServerLayout section
NOTE: if position is set to None it will remove such reference from
any instance of the section (e.g. from any ServerLayout section)'''
self.remove_option(section, reference, value=identifier,
position=position, reference=True)
def get_references(self, section, position, reflist=None):
'''Get references to other sections which are located in a section.
section= the section (e.g. "Screen")
position= e.g. 0 stands for the 1st Screen section
reflist= a list of references which this function should look for.
The default list of references is self.require_id but this
list can be overridden by the reflist argument so that, for
example, if reflist is set to ['Device'], this function will
look for references to other devices only (references to,
say, screens, will be ignored).'''
if reflist == None:
options = self.require_id
else:
# if the following operation fails
# an AttributeError will be raised
# since reflist must be a list
reflist.append('')
del reflist[-1]
options = reflist
references = {}.fromkeys(options)
for option in options:
references[option] = []
reference_dict = {}
try:
ref = self.get_value(section, option, position, reference=True)
except OptionException:
ref = []
if ref:
try:#if ref is already a list
ref.append('')
del ref[-1]
for elem in ref:
try:
elem.append('')
del elem[-1]
for extref in elem:
if elem:
reference_dict.setdefault(extref)
except AttributeError:# if ref is a string
if elem:
reference_dict.setdefault(elem)
except AttributeError:# if ref is a string
if ref:
reference_dict.setdefault(ref)
for reference in list(reference_dict.keys()):
references[option].append(reference)
return references
def make_subsection(self, section, identifier, position=None):
'''Create a new subsection inside of a section.
section= the section to which the subsection will belong
identifier= the name of the subsection
position= the position of the section in the dictionary with the
sections (e.g. the 1st "Screen" section would be 0).
If set to None, it will create a new subsection in all
the instances of the said section (e.g. in all the
"Screen" sections)'''
curlength = len(self._gdict[self.subsection])
if position == None:
for elem in self._gdict[section]:
# don't create a new subsection if one with the same
# 'section', 'identifier' and 'position' is found
create = True
for sub in self._gdict[self.subsection]:
if (self._gdict[self.subsection][sub].get('section') ==
section and
self._gdict[self.subsection][sub].get('identifier') ==
identifier and
self._gdict[self.subsection][sub].get('position') ==
elem):
create = False
if create:
temp_dict = self._gdict[self.subsection][curlength] = {}
temp_dict['section'] = section
temp_dict['identifier'] = identifier
temp_dict['options'] = []
temp_dict['position'] = elem
del temp_dict
curlength += 1
else:
# don't create a new subsection if one with the same
# 'section', 'identifier' and 'position' is found
create = True
for sub in self._gdict[self.subsection]:
if (self._gdict[self.subsection][sub].get('section') ==
section and
self._gdict[self.subsection][sub].get('identifier') ==
identifier and
self._gdict[self.subsection][sub].get('position') ==
position):
create = False
if create:
temp_dict = self._gdict[self.subsection][curlength] = {}
temp_dict['section'] = section
temp_dict['identifier'] = identifier
temp_dict['options'] = []
temp_dict['position'] = position
del temp_dict
def remove_subsection(self, section, identifier, position=None):
'''Remove a subsection from one or more sections.
section= the section to which the subsection belongs
identifier= the name of the subsection
position= the position of the section in the dictionary with the
sections (e.g. the 1st "Screen" section would be 0).
If set to None it will remove a subsection from all the
instances of the said section (e.g. in all the "Screen"
sections)'''
curlength = len(self._gdict[self.subsection])
to_remove = []
if position == None:
for elem in self._gdict[self.subsection]:
if (self._gdict[self.subsection][elem].get('section') ==
section and
self._gdict[self.subsection][elem].get('identifier') ==
identifier):
to_remove.append(elem)
else:
for elem in self._gdict[self.subsection]:
if (self._gdict[self.subsection][elem].get('section') ==
section and
self._gdict[self.subsection][elem].get('identifier') ==
identifier and
self._gdict[self.subsection][elem].get('position') ==
position):
to_remove.append(elem)
for item in to_remove:
del self._gdict[self.subsection][item]
def add_suboption(self, section, identifier, option, value,
option_type=None, position=None):
'''Add an option to one or more subsections.
section= the section which contains the subsection
identifier= the identifier of the SubSection (e.g. Display)
option= the option to add
value= the value which will be assigned to the option
option_type= if set to "Option" it will cause the option to look like
the following:
Option "NameOfTheOption" "Value"
Otherwise it will look like the following:
NameOfTheOption "Value"
position= e.g. 0 (i.e. the option will be added to a subsection which
is located in the first element in the list of Screen
sections)'''
prefix = '"'
not_to_create = []
to_modify = []
if position == None:
self.remove_suboption(section, identifier, option)
else:
self.remove_suboption(section, identifier, option,
position=position)
if option_type == None:
toadd = '\t' + option + '\t' + str(value) + '\n'
else:
toadd = ('\t' + option_type + '\t' + prefix + option + prefix +
'\t' + prefix + str(value) + prefix + '\n')
curlength = len(self._gdict[self.subsection])
if curlength == 0:
self._gdict[self.subsection][0] = {'section': section,
'identifier': identifier, 'options': []}
if position == None:
# if there is not a subsection for each selected section then
# create it
cursect_length = len(self._gdict[section])
it = 0
while it < cursect_length:
for elem in self._gdict[self.subsection]:
if (self._gdict[self.subsection][elem].get("position") ==
it and
self._gdict[self.subsection][elem].get("section") ==
section and
self._gdict[self.subsection][elem].get("identifier") ==
identifier):
not_to_create.append(it)
it += 1
for i in range(cursect_length + 1):
if i not in not_to_create:
self.make_subsection(section, identifier, position=i)
for elem in self._gdict[self.subsection]:
if (self._gdict[self.subsection][elem].get("identifier") ==
identifier and
self._gdict[self.subsection][elem].get("section") ==
section):
to_modify.append(elem)
else:
for elem in self._gdict[self.subsection]:
if (self._gdict[self.subsection][elem].get("position") ==
position and
self._gdict[self.subsection][elem].get("identifier") ==
identifier):
to_modify.append(elem)
if len(to_modify) == 0:
curlength = len(self._gdict[self.subsection])
self._gdict[self.subsection][
len(self._gdict[self.subsection])] = \
{'section': section, 'identifier': identifier,
'options': [], 'position': position}
to_modify.append(curlength)
for elem in to_modify:
self._gdict[self.subsection][elem]['options'].append(toadd)
def _get_suboptions_to_blacklist(self, section, identifier, option,
position=None):
'''Get a dictionay of the suboptions to blacklist.
See add_suboption() for an explanation on the arguments.
Used in both remove_option() and remove_suboption()'''
to_remove = {}
if len(self._gdict[section]) != 0:#if the section exists
if len(self._gdict[self.subsection]) != 0:
for elem in self._gdict[self.subsection]:
temp_elem = self._gdict[self.subsection][elem]
if position == None:
if (temp_elem.get('section') == section and
temp_elem.get('identifier') == identifier):
it = 0
for opt in temp_elem['options']:
if (opt.strip().lower()
.find(option.strip().lower()) != -1):
to_remove.setdefault(elem, []).append(it)
it += 1
else:
if (temp_elem.get('section') == section and
temp_elem.get('identifier') == identifier and
temp_elem.get('position') == position):
it = 0
for opt in temp_elem['options']:
if (opt.strip().lower()
.find(option.strip().lower()) != -1):
to_remove.setdefault(elem, []).append(it)
it += 1
del temp_elem
return to_remove
def remove_suboption(self, section, identifier, option, position=None):
'''Remove an option from a subsection.'''
to_remove = self._get_suboptions_to_blacklist(section, identifier,
option, position)
for elem in to_remove:
modded = 0
for part in to_remove[elem]:
real_pos = part - modded
del self._gdict[self.subsection][elem]['options'][real_pos]
modded += 1
def get_identifier(self, section, position):
'''Get the identifier of a specific section from its position.'''
error_msg = ('No identifier can be found for section "%s" No %d'
% (section, position))
try:
for sect in self.identifiers[section]:
if sect[1] == position:
return sect[0]
except KeyError:
raise SectionException
raise IdentifierException(error_msg)
def _clean_option(self, option, optname, reference=None, section=None):
'''Clean the option and return the value
This returns the last item of the list which this method generates.
If no value can be found, return False.'''
if reference:
# If it's a reference to another section then options such as
# Option "Device" "/dev/psaux" should not be taken into
# account.
if 'option' in option.strip().lower():
return False
# Do not confuse Device "Configure device" with InputDevice
# "device"
if not option.strip().lower().startswith(optname.strip().lower()):
return False
optbits = []
optbit = ''
it = 0
quotation = 0
optcount = option.count('"')
if optcount > 0:#dealing with a section option
for i in option:
if optcount in [2, 4] and section == 'ServerLayout':
if not i.isspace():
if i == '"':
if quotation != 0 and quotation % 2 != 0:
if len(optbit) > 0:
optbits.append(optbit)
optbit = ''
quotation += 1
else:
if quotation % 2 != 0:
optbit += i
else:
if quotation % 2 != 0:
optbit += i
else:
#print 'i', repr(i), 'optbit', optbit
if not i.isspace():
if i == '"':
quotation += 1
else:
optbit += i
else:
if quotation % 2 != 0:
optbit += i
else:
if len(optbit) > 0:
optbits.append(optbit)
#print 'i=', i, 'optbit=', optbit
optbit = ''
if it == len(option) - 1:
if optbit != '':
optbits.append(optbit)
#print 'i=END', 'optbit=', optbit
it += 1
else:#dealing with a subsection option
for i in option:
#print 'i', repr(i), 'optbit', optbit
if not i.isspace():
optbit += i
else:
if len(optbit) > 0:
optbits.append(optbit)
#print 'i=', i, 'optbit=', optbit
optbit = ''
if it == len(option) - 1:
if optbit != '':
optbits.append(optbit)
#print 'i=END', 'optbit=', optbit
it += 1
optlen = len(optbits)
if optlen > 1:
# Let's make sure that the option is the one we're looking for
# e.g. if we're looking for a reference to Device we are not
# interested in getting references to InputDevice
references_list = [x.lower().strip() for x in self.references]
if (section != 'ServerLayout' and
quotation == 0 and optlen == 2 and
optbits[0].lower().strip() in references_list):
# e.g. Screen 1 -> 1 stands for the position, therefore the
# identifier of the section at position 1 should be returned
# instead of the number (if possible).
#
# return [Screen, identifier]
try:
sect = ''
value = int(optbits[1].strip())
for item in self.require_id:
if optbits[0].lower().strip() == item.lower().strip():
sect = item
break
try:
identifier = self.get_identifier(sect, value)
return [identifier]
except (IdentifierException):
return False
except ValueError:
pass
if optcount != 4 and section != 'ServerLayout':
status = False
for elem in optbits:
if elem.lower() == optname.lower():
status = True
if status == False:
return False
if optlen == 2 and optbits[0].lower().strip() == 'option':
# e.g. Option "AddARGBGLXVisuals"
# (The value was omitted but it will be interpreted as True by
# Xorg)
return 'True'
sections = [sect.strip().lower() for sect in self.sections]
# if optlen == 2 and optbits[0].lower().strip() in sections:
# # Do not confuse Device "Configure device" with InputDevice
# # "device"
# if optbits[0].lower().strip() != optname.strip().lower():
# return False
if optcount == 4 and section == 'ServerLayout':
#If it's something like InputDevice "stylus" "SendCoreEvents"
if (optname.lower().strip() == 'inputdevice' and
len(optbits) == 2):
del optbits[1]
server_dict = {}
for elem in optbits:
server_dict.setdefault(elem)
return list(server_dict.keys())
elif optcount > 0 and optcount <= 4:
#dealing with a section option
return optbits[optlen -1]
elif optcount > 4:
del optbits[0]
return optbits
elif optcount == 0:
del optbits[0]
return ' '.join(optbits)
else:
if optcount in [2, 4] and section == 'ServerLayout':
return optbits
return False
def get_value(self, section, option, position, identifier=None,
sect=None, reference=None):
'''Get the value which is assigned to an option.
Return types:
* string (if only one value is available)
- usually in options
* list (if more than one option is found)
- having multiple references of the same type is allowed.
for example it is not unusual to have 2 references to
Screen sections in the ServerLayout section (in case of
Xinerama)
- if the options are actually options and not references
then there are duplicate options, which should be detected
in advance with get_duplicate_options()
* None (if no value can be found) - Not always true -> See below.
Use-case for returning None
* When dealing with incomplete references. For example:
Screen "Configured Screen"
is different from:
Screen
(which is an incomplete reference)
* When dealing with incomplete options. For example:
Depth 24
is different from:
Depth
(which is an incomplete option)
* Exception:
Some options (with the "Option" prefix) (not references)
can be used with no value (explicitly) assigned and are
considered as True by the Xserver. In such case get_value()
will return "True". For example:
Option "AddARGBGLXVisuals"
is the same as:
Option "AddARGBGLXVisuals" "True"
Meaning of keys in Sections and SubSections:
* When dealing with a Section:
section= e.g. 'Screen', 'Device', etc.
option= the option
position= e.g. 0 (i.e. the first element in the list of Screen
sections)
reference= used only by get_references()
* When dealing with a SubSection:
section= 'SubSection' (this is mandatory)
option= the option
position= e.g. 0 would mean that the subsection belongs to
the 1st item of the list of, say, "Screen" sections.
(i.e. the first element in the list of Screen
sections)
["position" is a key of an item of the list of
subsections see below]
identifier= the name of the subsection e.g. 'Display'
sect = the 'section' key of an item of the list of
subsections e.g. the "Display" subsection can be
found in the "Screen" section ('sect' is the latter)
Anatomy of Sections and SubSections:
* Anatomy of subsections:
self.globaldict['SubSection'] =
{0: {'section': 'Screen', 'identifier': 'Display',
'position': 0, 'options': [option1, option2, etc.],
etc.}
In this case we refer to the 'Display' subsection
which is located in the first 'Screen' section.
* Anatomy of a section:
self.globaldict['Screen'] =
{0: [option1, option2, etc.], 1: [...], ...}
0, 1, etc. is the position '''
values = []
if self._gdict[section].get(position) == None:
raise SectionException
#if len(values) == 0:
#raise OptionException
#return values
else:
try:
# see if it's a dictionary (e.g. in case of a subsection)
# or a list (in case of a normal section) and act
# accordingly
self._gdict[section][position].index('foo')
except AttributeError:#dict
if identifier == None:
raise Exception('An identifier is required for '
'subsections')
else:
for elem in self._gdict[section]:
if (self._gdict[section][elem].get('identifier') ==
identifier and
self._gdict[section][elem].get('position') ==
position and
self._gdict[section][elem].get('section') == sect):
for opt in self._gdict[section][elem]['options']:
if (option.strip().lower() in
opt.strip().lower()):
if opt.strip().find('#') != -1:
stropt = opt.strip()[0: opt
.strip().find('#')]
else:
stropt = opt.strip()
# clean the option and return the value
values.append(self._clean_option(stropt,
option, reference=reference))
if len(values) == 0:
raise OptionException
if len(values) > 1:
return values
else:
try:
return values[0]
except IndexError:
return None
except ValueError:#list
for elem in self._gdict[section][position]:
if option.strip().lower() in elem.strip().lower():
# clean the option and return the value
if elem.strip().find('#') != -1:
stropt = elem.strip()[0: elem.strip().find('#')]
else:
stropt = elem.strip()
values.append(self._clean_option(stropt, option,
reference=reference, section=section))
if len(values) == 0:
raise OptionException
if len(values) > 1:
return values
else:
try:
return values[0]
except IndexError:
return None
except KeyError:#not found
raise OptionException
def is_section(self, section, identifier=None, position=None):
'''See if a section with a certain identifier exists.
NOTE: either identifier or position must be provided.'''
if identifier != None:
try:
self.get_position(section, identifier)
return True
except IdentifierException:
return False
elif position != None:
return self._gdict[section].get(position) != None
else:
error_msg = 'Either identifier or position must be provided'
raise Exception(error_msg)
def get_position(self, section, identifier):
'''Get the position of a specific section from its identifier.'''
error_msg = ('No %s section named "%s" can be found' %
(section, identifier))
for sect in self.identifiers[section]:
try:
if sect[0].strip().lower() == identifier.strip().lower():
return sect[1]
except AttributeError:
pass
raise IdentifierException(error_msg)
def get_broken_references(self):
'''Look for references to sections which don't exist
This returns a dictionary having the items of self.require_id as keys
and a dictionary with the identifiers of the sections which are
being referred to by the broken references.
For example:
broken_references = {
'InputDevice': {'InputDevice 1': None,
'Another input device': None},
'Device': {...},
'Monitor' {...},
'Screen' {...},
'ServerLayout' {...}
}'''
broken_references = {}.fromkeys(self.require_id)
references_tree = {}
for section in self.require_id:#['Screen', 'ServerLayout']
references_tree[section] = {}
broken_references[section] = {}
for sect in self._gdict[section]:
references_tree[section][sect] = self.get_references(section,
sect)
#print >> stderr, 'REFERENCES = %s' % (str(references_tree))
for section in references_tree:
for elem in references_tree[section]:
for refsect in references_tree[section][elem]:
if len(references_tree[section][elem][refsect]) > 0:
#references_tree[section][elem][refsect]
for ref in references_tree[section][elem][refsect]:
for sect in self.sections:
if sect.lower() == refsect.strip().lower():
refsect = sect
if not self.is_section(refsect, ref):
#print '*****WARNING:', refsect, 'Section',
# ref, 'does not exist!*****'
broken_references[refsect].setdefault(ref)
#print 'FIX: Creating', refsect, 'Section',
# ref self.make_section(refsect,
# identifier=ref)
return broken_references
def get_default_serverlayout(self):
'''Return a list with the position of default ServerLayout sections
NOTE: If the section set as the default ServerLayout doesn't exist
it will raise a ParseException.'''
default = []
serverflags = self._gdict['ServerFlags']
it = 0
for flag in serverflags:
try:
default_layout = self.get_value('ServerFlags',
'DefaultServerLayout', it)
if default_layout:
def_it = 0
for identifier in self.identifiers['ServerLayout']:
if (identifier[0].lower().strip() ==
default_layout.lower().strip()):
default.append(identifier[1])#LayoutPosition
def_it += 1
if def_it == 0:
# If the section set as the default ServerLayout
# doesn't exist raise a ParseException
error = 'The default ServerLayout does not exist.'
raise ParseException(error)
except OptionException:#no default_layout
pass
it += 1
return default
def _merge_subsections(self, temp_dict):
'''Put SubSections back into the sections to which they belong.'''
for sect in temp_dict['SubSection']:
section = temp_dict['SubSection'][sect]['section']
identifier = temp_dict['SubSection'][sect]['identifier']
position = temp_dict['SubSection'][sect].get('position')
options = temp_dict['SubSection'][sect]['options']
temp_dict[section].setdefault(position, []).append(
'\tSubSection ' +
'"' + identifier +
'"' + '\n')
if len(options) > 0:
temp_dict[section][position].append('\t' +
'\t'.join(options) +
'\tEndSubSection\n')
else:
temp_dict[section][position].append('\t'.join(options) +
'\tEndSubSection\n')
try:
#remove subsection since it was merged
del temp_dict['SubSection']
except KeyError:
pass
return temp_dict
def write(self, destination, test=None):
'''Write the changes to the destination
The destination can be either a file (e.g. /etc/X11/xorg.conf)
or a file object (e.g. sys.stdout).
destination = the destination file or file object (mandatory)
test = if set to True write will append the result to the
destination file instead of overwriting it. It has no
effect on file objects. Useful for testing.'''
temp_dict = copy.deepcopy(self._gdict)
# Commented options must be dealt with first
temp_dict = self._merge_commented_options(temp_dict)
# Merge all the non-commented subsections
temp_dict = self._merge_subsections(temp_dict)
lines = []
comments = ''.join(self.comments) + '\n'
lines.append(comments)
for section in temp_dict:
if section != self.commentsection:
if len(temp_dict[section]) > 0:
for elem in temp_dict[section]:
lines.append('Section ' + '"' + section + '"' + '\n')
lines.append(''.join(temp_dict[section][elem]) +
'EndSection\n\n')
del temp_dict
if not hasattr(destination, 'write'):#it is a file
if test:
destination = open(destination, 'a')
else:
destination = open(destination, 'w')
destination.write(''.join(lines))
destination.close()
else:#it is a file object
try:
destination.write(str(bytes(''.join(lines), 'UTF-8')))
except TypeError:
destination.write(b''.join(lines))
def get_subsections(self, section, position):
'''Get all the subsections contained in a section'''
# loop through subsections and see what subsections match
# the section
subsections = []
for sub in self._gdict[self.subsection]:
if (self._gdict[self.subsection][sub]['section'] == section
and self._gdict[self.subsection][sub]['position'] == position):
subsections.append(sub)
return subsections
def _permanent_merge_subsections(self, subsections):
'''Put SubSections back into their sections and comment them out
This alters globaldict and should be used only in
comment_out_section() i.e. when the whole section is being
commented out.
subsections = the list of the indices subsections to merge and
remove'''
for sect in subsections:
section = self._gdict[self.subsection][sect]['section']
identifier = self._gdict[self.subsection][sect]['identifier']
position = self._gdict[self.subsection][sect].get('position')
options = self._gdict[self.subsection][sect]['options']
self.comments.append('#\tSubSection ' + '"' + identifier + '"' +
'\n')
for option in options:
opt = '#\t\t%s\n' % (option.strip())
self.comments.append(opt)
self.comments.append('#\tEndSubSection\n')
try:#remove subsection since it was merged
del self._gdict[self.subsection][sect]
except KeyError:
pass
def _get_comments(self, section, position):
'''Return the index of the entry in the Comments section of a section'''
comments = []
if self._gdict[self.commentsection].get(section):
for sect in self._gdict[self.commentsection][section]:
if (self._gdict[self.commentsection][section][sect]
.get('position') == position):
comments.append(sect)
return comments
def _merge_subsections_with_comments(self, subsections):
'''Put SubSections back into their sections and comment them out
This alters globaldict and should be used only to comment out
subsections (i.e. in comment_out_subsection()) when the whole section
is not being commented out.
subsections = the list of the indices subsections to merge and
remove'''
end_subsection = '#\tEndSubSection\n'
for sect in subsections:
section = self._gdict[self.subsection][sect]['section']
identifier = self._gdict[self.subsection][sect]['identifier']
position = self._gdict[self.subsection][sect].get('position')
options = self._gdict[self.subsection][sect]['options']
start_subsection = '#\tSubSection "%s"\n' % (identifier)
comments = self._get_comments(section, position)
if not comments:
self._gdict[self.commentsection][section] = {}
self._gdict[self.commentsection][section][position] = {}
temp_dict = self._gdict[self.commentsection][section][position]
temp_dict['identifier'] = None
temp_dict['position'] = position
temp_dict['section'] = None
temp_dict['options'] = []
del temp_dict
comments_options = self._gdict[self.commentsection][section
][position]['options']
comments_options.append(start_subsection)
for option in options:
opt = '#\t\t%s\n' % (option.strip())
comments_options.append(opt)
comments_options.append(end_subsection)
#remove subsection since it was merged
del self._gdict[self.subsection][sect]
def _comment_out_subsections(self, section, position):
'''Comment out all the subsections of a section.'''
subsections = self.get_subsections(section, position)
self._permanent_merge_subsections(subsections)
def _remove_comment_entries(self, section, position):
'''Remove comment sections of a "section" from the "Comments" section'''
comments = self._get_comments(section, position)
for comment_section in comments:
del self._gdict[self.commentsection][section][comment_section]
def comment_out_section(self, section, identifier=None, position=None):
'''Comment out a section and all its subsections.'''
start_section = '\n#Section "%s"\n' % (section)
end_section = '#EndSection\n'
# Comment any section of "section" type with the same identifier
# currently sections of the same type cannot have the same id
# for obvious reasons
to_remove = {}
if identifier:
try:
pos = self.get_position(section, identifier)
to_remove.setdefault(pos, None)
except IdentifierException:
pass
# Comment the section of "section" type at position "position"
elif position != None:
if self.is_section(section, position=position):
to_remove.setdefault(position, None)
# Comment any section of "section" type
else:
all_keys = list(self._gdict[section].keys())
to_remove = {}.fromkeys(all_keys)
# If the section has an identifier i.e. if the section
# is in self.require_id
if section in self.require_id:
# Get the references to remove from self.identifiers
it = 0
for reference in self.identifiers[section]:
try:
ref = list(to_remove.keys()).index(reference[1])
to_remove[list(to_remove.keys())[ref]] = it
except ValueError:
pass
it += 1
sorted_remove = list(to_remove.keys())
sorted_remove.sort()
modded = 0
for sect in sorted_remove:
self.comments.append(start_section)
for option in self._gdict[section][sect]:
commented_option = '#\t%s\n' % (option.strip())
self.comments.append(commented_option)
# Append all its SubSections (automatically commented
# out) and remove them from SubSection
self._comment_out_subsections(section, sect)
self.comments.append(end_section)
# Remember to remove any related entry from the "Comments"
# section
self._remove_comment_entries(section, sect)
# Remove the section from _gdict
del self._gdict[section][sect]
# Remove the reference from identifiers
# if such reference exists
ident_ref = to_remove[sect]
if ident_ref != None:
realpos = ident_ref - modded
del self.identifiers[section][realpos]
modded += 1
def comment_out_subsection(self, section, identifier, position):
'''Comment out a subsection.
section= the type of the section which contains the subsection
identifier= the identifier of the subsection
position= the position of the section'''
subsections = []
for subsection in self._gdict[self.subsection]:
temp_dict = self._gdict[self.subsection][subsection]
if (temp_dict['section'] == section
and temp_dict['identifier'] == identifier
and temp_dict['position'] == position):
subsections.append(subsection)
break
del temp_dict
# Add the subsection to the Comments section
self._merge_subsections_with_comments(subsections)
def comment_out_option(self, section, option, value=None, position=None,
reference=None):
'''Comment out an option in a section.
section= the section which will have the option commented out
option= the option to comment out
value= if you want to comment out an option only if it has a
certain value
position= e.g. 0 (i.e. the first element in the list of Screen
sections)'''
to_remove = self._get_options_to_blacklist(section, option, value,
position, reference)
for part in to_remove:
modded = 0
for line in to_remove[part]:
realpos = line - modded
self._gdict[section][part][realpos] = ('#%s'
% (self._gdict[section][part][realpos].strip()))
self._gdict[self.commentsection].setdefault(section, {})
curlength = len(self._gdict[self.commentsection][section])
temp_dict = self._gdict[self.commentsection][section]
temp_dict.setdefault(part, {})
temp_dict[part].setdefault('identifier', None)
temp_dict[part].setdefault('position', part)
temp_dict[part].setdefault('section', None)
temp_dict[part].setdefault('options', [])
# Copy the option to the Comments section
temp_dict[part]['options'].append(
self._gdict[section][part][realpos])
del temp_dict
#Remove it from its section in _gdict
del self._gdict[section][part][realpos]
modded += 1
def comment_out_suboption(self, section, identifier, option, position=None):
'''Comment out an option in a subsection.
section= the section which contains the subsection
identifier= the identifier of the subsection
option= the option to comment out
position= the position of the section which contains the subsection
e.g. 0 (i.e. the first element in the list of Screen
sections)'''
to_remove = self._get_suboptions_to_blacklist(section, identifier,
option, position)
for elem in to_remove:
modded = 0
for part in to_remove[elem]:
realpos = part - modded
self._gdict[self.subsection][part]['options'][realpos] = ('#%s'
% (self._gdict[self.subsection][part]['options'][realpos]
.strip()))
self._gdict[self.commentsection].setdefault(self.subsection,
{})
temp_dict = self._gdict[self.commentsection][self.subsection]
temp_dict.setdefault(part, {})
temp_dict[part].setdefault('identifier', identifier)
temp_dict[part].setdefault('position', part)
temp_dict[part].setdefault('section', section)
temp_dict[part].setdefault('options', [])
# Copy the option to the Comments section
comments_options = temp_dict[part]['options']
commented_option = self._gdict[self.subsection][part][
'options'][realpos]
comments_options.append(commented_option)
del temp_dict
#Remove the option from its section in _gdict
del self._gdict[self.subsection][elem]['options'][realpos]
modded += 1
def _merge_commented_options(self, temp_dict):
'''Put commented out options back into their sections or subsections'''
for sect in temp_dict[self.commentsection]:
section_options = None
for section_instance in temp_dict[self.commentsection][sect]:
section = temp_dict[self.commentsection][sect][
section_instance].get('section')
identifier = temp_dict[self.commentsection][sect][
section_instance].get('identifier')
position = temp_dict[self.commentsection][sect][
section_instance].get('position')
options = temp_dict[self.commentsection][sect][
section_instance]['options']
if section == self.subsection:
for sub in temp_dict[sect]:
subsection = temp_dict[sect][sub]
if (subsection['identifier'] == identifier
and subsection['position'] == position
and subsection['section'] == section):
section_options = temp_dict[sect][sub]['options']
break
else:
section_options = temp_dict[sect].get(position)
if section_options:
for option in options:
option = '\t%s\n' % (option.strip())
if sect == self.subsection:
section_options.setdefault('options',
[]).append(option)
else:
section_options.append(option)
return temp_dict
Mini Shell