From 43c2b0fd59e8794e9139b0885b22624bcff5a4dd Mon Sep 17 00:00:00 2001 From: Elliott Sales de Andrade Date: Mon, 9 Sep 2024 02:44:31 -0400 Subject: [PATCH] Use standard decorator form of defining properties ... for properties that are defined with private methods. --- gramps/gen/plug/_pluginreg.py | 620 ++++++++++++++++++---------------- gramps/gui/glade.py | 30 +- gramps/gui/plug/_windows.py | 2 +- gramps/plugins/lib/libhtml.py | 61 ++-- 4 files changed, 363 insertions(+), 350 deletions(-) diff --git a/gramps/gen/plug/_pluginreg.py b/gramps/gen/plug/_pluginreg.py index b943b4fceb2..e275c5bb0a1 100644 --- a/gramps/gen/plug/_pluginreg.py +++ b/gramps/gen/plug/_pluginreg.py @@ -535,73 +535,98 @@ def __init__(self): # THUMBNAILER attr self._thumbnailer = None - def _set_id(self, plugin_id): - self._id = plugin_id - - def _get_id(self): + @property + def id(self): return self._id - def _set_name(self, name): - self._name = name + @id.setter + def id(self, plugin_id): + self._id = plugin_id - def _get_name(self): + @property + def name(self): return self._name - def _set_name_accell(self, name): - self._name_accell = name + @name.setter + def name(self, name): + self._name = name - def _get_name_accell(self): + @property + def name_accell(self): if self._name_accell is None: return self._name return self._name_accell - def _set_description(self, description): - self._description = description + @name_accell.setter + def name_accell(self, name): + self._name_accell = name - def _get_description(self): + @property + def description(self): return self._description - def _set_version(self, plugin_version): - self._version = plugin_version + @description.setter + def description(self, description): + self._description = description - def _get_version(self): + @property + def version(self): return self._version - def _set_gramps_target_version(self, target_version): - self._gramps_target_version = target_version + @version.setter + def version(self, plugin_version): + self._version = plugin_version - def _get_gramps_target_version(self): + @property + def gramps_target_version(self): return self._gramps_target_version - def _set_status(self, status): + @gramps_target_version.setter + def gramps_target_version(self, target_version): + self._gramps_target_version = target_version + + @property + def status(self): + return self._status + + @status.setter + def status(self, status): if status not in STATUS: raise ValueError(f"plugin status cannot be {status}") self._status = status - def _get_status(self): - return self._status + @property + def audience(self): + return self._audience - def _set_audience(self, audience): + @audience.setter + def audience(self, audience): if audience not in AUDIENCE: raise ValueError(f"plugin audience cannot be {audience}") self._audience = audience - def _get_audience(self): - return self._audience + @property + def fname(self): + return self._fname - def _set_fname(self, fname): + @fname.setter + def fname(self, fname): self._fname = fname - def _get_fname(self): - return self._fname + @property + def fpath(self): + return self._fpath - def _set_fpath(self, fpath): + @fpath.setter + def fpath(self, fpath): self._fpath = fpath - def _get_fpath(self): - return self._fpath + @property + def ptype(self): + return self._ptype - def _set_ptype(self, ptype): + @ptype.setter + def ptype(self, ptype): if ptype not in PTYPE: raise ValueError(f"Plugin type cannot be {ptype}") if self._ptype is not None: @@ -618,144 +643,141 @@ def _set_ptype(self, ptype): # if self._ptype == DOCGEN: # self._load_on_reg = True - def _get_ptype(self): - return self._ptype + @property + def authors(self): + return self._authors - def _set_authors(self, authors): + @authors.setter + def authors(self, authors): if not authors or not isinstance(authors, list): return self._authors = authors - def _get_authors(self): - return self._authors + @property + def authors_email(self): + return self._authors_email - def _set_authors_email(self, authors_email): + @authors_email.setter + def authors_email(self, authors_email): if not authors_email or not isinstance(authors_email, list): return self._authors_email = authors_email - def _get_authors_email(self): - return self._authors_email + @property + def maintainers(self): + return self._maintainers - def _set_maintainers(self, maintainers): + @maintainers.setter + def maintainers(self, maintainers): if not maintainers or not isinstance(maintainers, list): return self._maintainers = maintainers - def _get_maintainers(self): - return self._maintainers + @property + def maintainers_email(self): + return self._maintainers_email - def _set_maintainers_email(self, maintainers_email): + @maintainers_email.setter + def maintainers_email(self, maintainers_email): if not maintainers_email or not isinstance(maintainers_email, list): return self._maintainers_email = maintainers_email - def _get_maintainers_email(self): - return self._maintainers_email + @property + def supported(self): + return self._supported - def _set_supported(self, supported): + @supported.setter + def supported(self, supported): if not isinstance(supported, bool): raise ValueError("Plugin must have supported=True or False") self._supported = supported - def _get_supported(self): - return self._supported + @property + def load_on_reg(self): + return self._load_on_reg - def _set_load_on_reg(self, load_on_reg): + @load_on_reg.setter + def load_on_reg(self, load_on_reg): if not isinstance(load_on_reg, bool): raise ValueError("Plugin must have load_on_reg=True or False") self._load_on_reg = load_on_reg - def _get_load_on_reg(self): - return self._load_on_reg - - def _get_icons(self): + @property + def icons(self): return self._icons - def _set_icons(self, icons): + @icons.setter + def icons(self, icons): if not isinstance(icons, list): raise ValueError("Plugin must have icons as a list") self._icons = icons - def _get_icondir(self): + @property + def icondir(self): return self._icondir - def _set_icondir(self, icondir): + @icondir.setter + def icondir(self, icondir): self._icondir = icondir - def _get_depends_on(self): + @property + def depends_on(self): return self._depends_on - def _set_depends_on(self, depends): + @depends_on.setter + def depends_on(self, depends): if not isinstance(depends, list): raise ValueError("Plugin must have depends_on as a list") self._depends_on = depends - def _get_requires_mod(self): + @property + def requires_mod(self): return self._requires_mod - def _set_requires_mod(self, requires): + @requires_mod.setter + def requires_mod(self, requires): if not isinstance(requires, list): raise ValueError("Plugin must have requires_mod as a list") self._requires_mod = requires - def _get_requires_gi(self): + @property + def requires_gi(self): return self._requires_gi - def _set_requires_gi(self, requires): + @requires_gi.setter + def requires_gi(self, requires): if not isinstance(requires, list): raise ValueError("Plugin must have requires_gi as a list") self._requires_gi = requires - def _get_requires_exe(self): + @property + def requires_exe(self): return self._requires_exe - def _set_requires_exe(self, requires): + @requires_exe.setter + def requires_exe(self, requires): if not isinstance(requires, list): raise ValueError("Plugin must have requires_exe as a list") self._requires_exe = requires - def _get_include_in_listing(self): + @property + def include_in_listing(self): return self._include_in_listing - def _set_include_in_listing(self, include): + @include_in_listing.setter + def include_in_listing(self, include): if not isinstance(include, bool): raise ValueError("Plugin must have include_in_listing as a bool") self._include_in_listing = include - def _set_help_url(self, help_url): - self._help_url = help_url - - def _get_help_url(self): + @property + def help_url(self): return self._help_url - id = property(_get_id, _set_id) - name = property(_get_name, _set_name) - name_accell = property(_get_name_accell, _set_name_accell) - description = property(_get_description, _set_description) - version = property(_get_version, _set_version) - gramps_target_version = property( - _get_gramps_target_version, _set_gramps_target_version - ) - status = property(_get_status, _set_status) - audience = property(_get_audience, _set_audience) - fname = property(_get_fname, _set_fname) - fpath = property(_get_fpath, _set_fpath) - ptype = property(_get_ptype, _set_ptype) - authors = property(_get_authors, _set_authors) - authors_email = property(_get_authors_email, _set_authors_email) - maintainers = property(_get_maintainers, _set_maintainers) - maintainers_email = property(_get_maintainers_email, _set_maintainers_email) - supported = property(_get_supported, _set_supported) - load_on_reg = property(_get_load_on_reg, _set_load_on_reg) - icons = property(_get_icons, _set_icons) - icondir = property(_get_icondir, _set_icondir) - depends_on = property(_get_depends_on, _set_depends_on) - requires_mod = property(_get_requires_mod, _set_requires_mod) - requires_gi = property(_get_requires_gi, _set_requires_gi) - requires_exe = property(_get_requires_exe, _set_requires_exe) - include_in_listing = property(_get_include_in_listing, _set_include_in_listing) - help_url = property(_get_help_url, _set_help_url) + @help_url.setter + def help_url(self, help_url): + self._help_url = help_url def statustext(self): """ @@ -766,45 +788,55 @@ def statustext(self): # type specific plugin attributes # RELCALC attributes - def _set_relcalcclass(self, relcalcclass): + @property + def relcalcclass(self): + return self._relcalcclass + + @relcalcclass.setter + def relcalcclass(self, relcalcclass): if self._ptype != RELCALC: raise ValueError("relcalcclass may only be set for RELCALC plugins") self._relcalcclass = relcalcclass - def _get_relcalcclass(self): - return self._relcalcclass + @property + def lang_list(self): + return self._lang_list - def _set_lang_list(self, lang_list): + @lang_list.setter + def lang_list(self, lang_list): if self._ptype != RELCALC: raise ValueError("relcalcclass may only be set for RELCALC plugins") self._lang_list = lang_list - def _get_lang_list(self): - return self._lang_list - - relcalcclass = property(_get_relcalcclass, _set_relcalcclass) - lang_list = property(_get_lang_list, _set_lang_list) - # REPORT attributes - def _set_require_active(self, require_active): + @property + def require_active(self): + return self._require_active + + @require_active.setter + def require_active(self, require_active): if self._ptype != REPORT: raise ValueError("require_active may only be set for REPORT plugins") if not isinstance(require_active, bool): raise ValueError("Report must have require_active=True or False") self._require_active = require_active - def _get_require_active(self): - return self._require_active + @property + def reportclass(self): + return self._reportclass - def _set_reportclass(self, reportclass): + @reportclass.setter + def reportclass(self, reportclass): if self._ptype != REPORT: raise ValueError("reportclass may only be set for REPORT plugins") self._reportclass = reportclass - def _get_reportclass(self): - return self._reportclass + @property + def report_modes(self): + return self._report_modes - def _set_report_modes(self, report_modes): + @report_modes.setter + def report_modes(self, report_modes): if self._ptype != REPORT: raise ValueError("report_modes may only be set for REPORT plugins") if not isinstance(report_modes, list): @@ -813,11 +845,13 @@ def _set_report_modes(self, report_modes): if not self._report_modes: raise ValueError("report_modes not a valid list of modes") - def _get_report_modes(self): - return self._report_modes - # REPORT or TOOL or QUICKREPORT or GENERAL attributes - def _set_category(self, category): + @property + def category(self): + return self._category + + @category.setter + def category(self, category): if self._ptype not in [REPORT, TOOL, QUICKREPORT, VIEW, GENERAL]: raise ValueError( "category may only be set for " @@ -825,30 +859,36 @@ def _set_category(self, category): ) self._category = category - def _get_category(self): - return self._category - # REPORT OR TOOL attributes - def _set_optionclass(self, optionclass): + @property + def optionclass(self): + return self._optionclass + + @optionclass.setter + def optionclass(self, optionclass): if self._ptype not in [REPORT, TOOL, DOCGEN]: raise ValueError( "optionclass may only be set for REPORT/TOOL/DOCGEN plugins" ) self._optionclass = optionclass - def _get_optionclass(self): - return self._optionclass - # TOOL attributes - def _set_toolclass(self, toolclass): + @property + def toolclass(self): + return self._toolclass + + @toolclass.setter + def toolclass(self, toolclass): if self._ptype != TOOL: raise ValueError("toolclass may only be set for TOOL plugins") self._toolclass = toolclass - def _get_toolclass(self): - return self._toolclass + @property + def tool_modes(self): + return self._tool_modes - def _set_tool_modes(self, tool_modes): + @tool_modes.setter + def tool_modes(self, tool_modes): if self._ptype != TOOL: raise ValueError("tool_modes may only be set for TOOL plugins") if not isinstance(tool_modes, list): @@ -857,166 +897,172 @@ def _set_tool_modes(self, tool_modes): if not self._tool_modes: raise ValueError("tool_modes not a valid list of modes") - def _get_tool_modes(self): - return self._tool_modes - - require_active = property(_get_require_active, _set_require_active) - reportclass = property(_get_reportclass, _set_reportclass) - report_modes = property(_get_report_modes, _set_report_modes) - category = property(_get_category, _set_category) - optionclass = property(_get_optionclass, _set_optionclass) - toolclass = property(_get_toolclass, _set_toolclass) - tool_modes = property(_get_tool_modes, _set_tool_modes) - # DOCGEN attributes - def _set_paper(self, paper): + @property + def paper(self): + return self._paper + + @paper.setter + def paper(self, paper): if self._ptype != DOCGEN: raise ValueError("paper may only be set for DOCGEN plugins") if not isinstance(paper, bool): raise ValueError("Plugin must have paper=True or False") self._paper = paper - def _get_paper(self): - return self._paper + @property + def style(self): + return self._style - def _set_style(self, style): + @style.setter + def style(self, style): if self._ptype != DOCGEN: raise ValueError("style may only be set for DOCGEN plugins") if not isinstance(style, bool): raise ValueError("Plugin must have style=True or False") self._style = style - def _get_style(self): - return self._style + @property + def extension(self): + return self._extension - def _set_extension(self, extension): + @extension.setter + def extension(self, extension): if self._ptype not in [DOCGEN, EXPORT, IMPORT]: raise ValueError( "extension may only be set for DOCGEN/EXPORT/IMPORT plugins" ) self._extension = extension - def _get_extension(self): - return self._extension - - paper = property(_get_paper, _set_paper) - style = property(_get_style, _set_style) - extension = property(_get_extension, _set_extension) - # QUICKREPORT attributes - def _set_runfunc(self, runfunc): + @property + def runfunc(self): + return self._runfunc + + @runfunc.setter + def runfunc(self, runfunc): if self._ptype != QUICKREPORT: raise ValueError("runfunc may only be set for QUICKREPORT plugins") self._runfunc = runfunc - def _get_runfunc(self): - return self._runfunc - - runfunc = property(_get_runfunc, _set_runfunc) - # MAPSERVICE attributes - def _set_mapservice(self, mapservice): + @property + def mapservice(self): + return self._mapservice + + @mapservice.setter + def mapservice(self, mapservice): if self._ptype != MAPSERVICE: raise ValueError("mapservice may only be set for MAPSERVICE plugins") self._mapservice = mapservice - def _get_mapservice(self): - return self._mapservice - - mapservice = property(_get_mapservice, _set_mapservice) - # EXPORT attributes - def _set_export_function(self, export_function): + @property + def export_function(self): + return self._export_function + + @export_function.setter + def export_function(self, export_function): if self._ptype != EXPORT: raise ValueError("export_function may only be set for EXPORT plugins") self._export_function = export_function - def _get_export_function(self): - return self._export_function + @property + def export_options(self): + return self._export_options - def _set_export_options(self, export_options): + @export_options.setter + def export_options(self, export_options): if self._ptype != EXPORT: raise ValueError("export_options may only be set for EXPORT plugins") self._export_options = export_options - def _get_export_options(self): - return self._export_options + @property + def export_options_title(self): + return self._export_options_title - def _set_export_options_title(self, export_options_title): + @export_options_title.setter + def export_options_title(self, export_options_title): if self._ptype != EXPORT: raise ValueError("export_options_title may only be set for EXPORT plugins") self._export_options_title = export_options_title - def _get_export_options_title(self): - return self._export_options_title - - export_function = property(_get_export_function, _set_export_function) - export_options = property(_get_export_options, _set_export_options) - export_options_title = property( - _get_export_options_title, _set_export_options_title - ) - # IMPORT attributes - def _set_import_function(self, import_function): + @property + def import_function(self): + return self._import_function + + @import_function.setter + def import_function(self, import_function): if self._ptype != IMPORT: raise ValueError("import_function may only be set for IMPORT plugins") self._import_function = import_function - def _get_import_function(self): - return self._import_function - - import_function = property(_get_import_function, _set_import_function) - # GRAMPLET attributes - def _set_gramplet(self, gramplet): + @property + def gramplet(self): + return self._gramplet + + @gramplet.setter + def gramplet(self, gramplet): if self._ptype != GRAMPLET: raise ValueError("gramplet may only be set for GRAMPLET plugins") self._gramplet = gramplet - def _get_gramplet(self): - return self._gramplet + @property + def height(self): + return self._height - def _set_height(self, height): + @height.setter + def height(self, height): if self._ptype != GRAMPLET: raise ValueError("height may only be set for GRAMPLET plugins") if not isinstance(height, int): raise ValueError("Plugin must have height an integer") self._height = height - def _get_height(self): - return self._height + @property + def detached_height(self): + return self._detached_height - def _set_detached_height(self, detached_height): + @detached_height.setter + def detached_height(self, detached_height): if self._ptype != GRAMPLET: raise ValueError("detached_height may only be set for GRAMPLET plugins") if not isinstance(detached_height, int): raise ValueError("Plugin must have detached_height an integer") self._detached_height = detached_height - def _get_detached_height(self): - return self._detached_height + @property + def detached_width(self): + return self._detached_width - def _set_detached_width(self, detached_width): + @detached_width.setter + def detached_width(self, detached_width): if self._ptype != GRAMPLET: raise ValueError("detached_width may only be set for GRAMPLET plugins") if not isinstance(detached_width, int): raise ValueError("Plugin must have detached_width an integer") self._detached_width = detached_width - def _get_detached_width(self): - return self._detached_width + @property + def expand(self): + return self._expand - def _set_expand(self, expand): + @expand.setter + def expand(self, expand): if self._ptype != GRAMPLET: raise ValueError("expand may only be set for GRAMPLET plugins") if not isinstance(expand, bool): raise ValueError("Plugin must have expand as a bool") self._expand = expand - def _get_expand(self): - return self._expand + @property + def gramplet_title(self): + return self._gramplet_title - def _set_gramplet_title(self, gramplet_title): + @gramplet_title.setter + def gramplet_title(self, gramplet_title): if self._ptype != GRAMPLET: raise ValueError("gramplet_title may only be set for GRAMPLET plugins") if not isinstance(gramplet_title, str): @@ -1026,166 +1072,164 @@ def _set_gramplet_title(self, gramplet_title): ) self._gramplet_title = gramplet_title - def _get_gramplet_title(self): - return self._gramplet_title + @property + def navtypes(self): + return self._navtypes - def _set_navtypes(self, navtypes): + @navtypes.setter + def navtypes(self, navtypes): if self._ptype != GRAMPLET: raise ValueError("navtypes may only be set for GRAMPLET plugins") self._navtypes = navtypes - def _get_navtypes(self): - return self._navtypes + @property + def orientation(self): + return self._orientation - def _set_orientation(self, orientation): + @orientation.setter + def orientation(self, orientation): if self._ptype != GRAMPLET: raise ValueError("orientation may only be set for GRAMPLET plugins") self._orientation = orientation - def _get_orientation(self): - return self._orientation - - gramplet = property(_get_gramplet, _set_gramplet) - height = property(_get_height, _set_height) - detached_height = property(_get_detached_height, _set_detached_height) - detached_width = property(_get_detached_width, _set_detached_width) - expand = property(_get_expand, _set_expand) - gramplet_title = property(_get_gramplet_title, _set_gramplet_title) - navtypes = property(_get_navtypes, _set_navtypes) - orientation = property(_get_orientation, _set_orientation) + @property + def viewclass(self): + return self._viewclass - def _set_viewclass(self, viewclass): + @viewclass.setter + def viewclass(self, viewclass): if self._ptype != VIEW: raise ValueError("viewclass may only be set for VIEW plugins") self._viewclass = viewclass - def _get_viewclass(self): - return self._viewclass + @property + def stock_category_icon(self): + return self._stock_category_icon - def _set_stock_category_icon(self, stock_category_icon): + @stock_category_icon.setter + def stock_category_icon(self, stock_category_icon): if self._ptype != VIEW: raise ValueError("stock_category_icon may only be set for VIEW plugins") self._stock_category_icon = stock_category_icon - def _get_stock_category_icon(self): - return self._stock_category_icon + @property + def stock_icon(self): + return self._stock_icon - def _set_stock_icon(self, stock_icon): + @stock_icon.setter + def stock_icon(self, stock_icon): if self._ptype != VIEW: raise ValueError("stock_icon may only be set for VIEW plugins") self._stock_icon = stock_icon - def _get_stock_icon(self): - return self._stock_icon - - viewclass = property(_get_viewclass, _set_viewclass) - stock_category_icon = property(_get_stock_category_icon, _set_stock_category_icon) - stock_icon = property(_get_stock_icon, _set_stock_icon) - # SIDEBAR attributes - def _set_sidebarclass(self, sidebarclass): + @property + def sidebarclass(self): + return self._sidebarclass + + @sidebarclass.setter + def sidebarclass(self, sidebarclass): if self._ptype != SIDEBAR: raise ValueError("sidebarclass may only be set for SIDEBAR plugins") self._sidebarclass = sidebarclass - def _get_sidebarclass(self): - return self._sidebarclass + @property + def menu_label(self): + return self._menu_label - def _set_menu_label(self, menu_label): + @menu_label.setter + def menu_label(self, menu_label): if self._ptype != SIDEBAR: raise ValueError("menu_label may only be set for SIDEBAR plugins") self._menu_label = menu_label - def _get_menu_label(self): - return self._menu_label - - sidebarclass = property(_get_sidebarclass, _set_sidebarclass) - menu_label = property(_get_menu_label, _set_menu_label) - # VIEW, SIDEBAR and THUMBNAILER attributes - def _set_order(self, order): + @property + def order(self): + return self._order + + @order.setter + def order(self, order): if self._ptype not in [VIEW, SIDEBAR, THUMBNAILER]: raise ValueError( "order may only be set for VIEW/SIDEBAR/THUMBNAILER plugins" ) self._order = order - def _get_order(self): - return self._order - - order = property(_get_order, _set_order) - # DATABASE attributes - def _set_databaseclass(self, databaseclass): + @property + def databaseclass(self): + return self._databaseclass + + @databaseclass.setter + def databaseclass(self, databaseclass): if self._ptype != DATABASE: raise ValueError("databaseclass may only be set for DATABASE plugins") self._databaseclass = databaseclass - def _get_databaseclass(self): - return self._databaseclass + @property + def reset_system(self): + return self._reset_system - def _set_reset_system(self, reset_system): + @reset_system.setter + def reset_system(self, reset_system): if self._ptype != DATABASE: raise ValueError("reset_system may only be set for DATABASE plugins") self._reset_system = reset_system - def _get_reset_system(self): - return self._reset_system - - databaseclass = property(_get_databaseclass, _set_databaseclass) - reset_system = property(_get_reset_system, _set_reset_system) - # GENERAL attr - def _set_data(self, data): + @property + def data(self): + return self._data + + @data.setter + def data(self, data): if self._ptype != GENERAL: raise ValueError("data may only be set for GENERAL plugins") self._data = data - def _get_data(self): - return self._data + @property + def process(self): + return self._process - def _set_process(self, process): + @process.setter + def process(self, process): if self._ptype != GENERAL: raise ValueError("process may only be set for GENERAL plugins") self._process = process - def _get_process(self): - return self._process - - data = property(_get_data, _set_data) - process = property(_get_process, _set_process) - # RULE attr - def _set_ruleclass(self, data): + @property + def ruleclass(self): + return self._ruleclass + + @ruleclass.setter + def ruleclass(self, data): if self._ptype != RULE: raise ValueError("ruleclass may only be set for RULE plugins") self._ruleclass = data - def _get_ruleclass(self): - return self._ruleclass + @property + def namespace(self): + return self._namespace - def _set_namespace(self, data): + @namespace.setter + def namespace(self, data): if self._ptype != RULE: raise ValueError("namespace may only be set for RULE plugins") self._namespace = data - def _get_namespace(self): - return self._namespace - - ruleclass = property(_get_ruleclass, _set_ruleclass) - namespace = property(_get_namespace, _set_namespace) - # THUMBNAILER attr - def _set_thumbnailer(self, data): + @property + def thumbnailer(self): + return self._thumbnailer + + @thumbnailer.setter + def thumbnailer(self, data): if self._ptype != THUMBNAILER: raise ValueError("thumbnailer may only be set for THUMBNAILER plugins") self._thumbnailer = data - def _get_thumbnailer(self): - return self._thumbnailer - - thumbnailer = property(_get_thumbnailer, _set_thumbnailer) - def newplugin(): """ diff --git a/gramps/gui/glade.py b/gramps/gui/glade.py index f5e0988c080..2bf7d125d11 100644 --- a/gramps/gui/glade.py +++ b/gramps/gui/glade.py @@ -173,45 +173,37 @@ def __init__(self, filename=None, dirname=None, toplevel=None, also_load=[]): else: self.__toplevel = None - def __get_filename(self): + @property + def filename(self): """ - __get_filename: return filename of glade file + filename: return filename of glade file :rtype: string :returns: filename of glade file """ return self.__filename - filename = property(__get_filename) - - def __get_dirname(self): + @property + def dirname(self): """ - __get_dirname: return directory where glade file found + dirname: return directory where glade file found :rtype: string :returns: directory where glade file found """ return self.__dirname - dirname = property(__get_dirname) - - def __get_toplevel(self): + @property + def toplevel(self): """ - __get_toplevel: return toplevel object + toplevel: return toplevel object :rtype: object :returns: toplevel object """ return self.__toplevel - def __set_toplevel(self, toplevel): - """ - __set_toplevel: set toplevel object - - :type toplevel: string - :param toplevel: The name of the toplevel object to use - """ + @toplevel.setter + def toplevel(self, toplevel): self.__toplevel = self.get_object(toplevel) - toplevel = property(__get_toplevel, __set_toplevel) - def get_child_object(self, value, toplevel=None): """ get_child_object: search for a child object, by name, within a given diff --git a/gramps/gui/plug/_windows.py b/gramps/gui/plug/_windows.py index 5b88b6a671e..7bf8e00cd2c 100644 --- a/gramps/gui/plug/_windows.py +++ b/gramps/gui/plug/_windows.py @@ -1512,7 +1512,7 @@ def __populate_load_list(self): ) success_list = sorted( - self.__pmgr.get_success_list(), key=lambda x: (x[0], x[2]._get_name()) + self.__pmgr.get_success_list(), key=lambda x: (x[0], x[2].name) ) for i in success_list: # i = (filename, module, pdata) diff --git a/gramps/plugins/lib/libhtml.py b/gramps/plugins/lib/libhtml.py index 47cc6478202..ec798e5aecd 100644 --- a/gramps/plugins/lib/libhtml.py +++ b/gramps/plugins/lib/libhtml.py @@ -520,9 +520,10 @@ def addDOCTYPE(self, name="html", public="PUBLIC", external_id=_HTML5, *args): self[0:0] = [doctype] # - def __gettag(self): + @property + def tag(self): """ - Returns HTML tag for this object + The HTML tag for this object. :rtype: string :returns: HTML tag @@ -530,13 +531,8 @@ def __gettag(self): return self[0].split()[0].strip("< >") # - def __settag(self, newtag): - """ - Sets a new HTML tag for this object - - :type name: string - :param name: new HTML tag - """ + @tag.setter + def tag(self, newtag): curtag = self.tag # Replace closing tag, if any @@ -548,12 +544,11 @@ def __settag(self, newtag): self[0] = self[0].replace("<" + curtag, "<" + newtag) - tag = property(__gettag, __settag) - # - def __getattr(self): + @property + def attr(self): """ - Returns HTML attributes for this object + The HTML attributes for this object. :rtype: string :returns: HTML attributes @@ -562,13 +557,8 @@ def __getattr(self): return attr[1] if len(attr) > 1 else "" # - def __setattr(self, value): - """ - Sets new HTML attributes for this object - - :type name: string - :param name: new HTML attributes - """ + @attr.setter + def attr(self, value): beg = len(self.tag) + 1 # See if self-closed or normal @@ -577,10 +567,8 @@ def __setattr(self, value): self[0] = self[0][:beg] + " " + value + self[0][end:] # - def __delattr(self): - """ - Removes HTML attributes for this object - """ + @attr.deleter + def attr(self): self[0] = ( "<" + self.tag @@ -590,12 +578,10 @@ def __delattr(self): ) # - attr = property(__getattr, __setattr, __delattr) - - # - def __getinside(self): + @property + def inside(self): """ - Returns list of items between opening and closing tags + The list of items between opening and closing tags. :rtype: list :returns: list of items between opening and closing HTML tags @@ -603,13 +589,8 @@ def __getinside(self): return self[1:-1] # - def __setinside(self, value): - """ - Sets new contents between opening and closing tags - - :type name: list - :param name: new HTML contents - """ + @inside.setter + def inside(self, value): if len(self) < 2: raise AttributeError("No closing tag. Cannot set inside value") if ( @@ -621,15 +602,11 @@ def __setinside(self, value): self[1:-1] = value # - def __delinside(self): - """ - Removes contents between opening and closing tag - """ + @inside.deleter + def inside(self): if len(self) > 2: self[:] = self[:1] + self[-1:] - inside = property(__getinside, __setinside, __delinside) - # def __enter__(self): return self