Exemplo n.º 1
0
def postproc_blueprints(netlist):
    for schematic in netlist.schematics:
        schematic.ports = {}

        for component in schematic.components:
            portname = component.get_attribute('portname', None)
            if portname is None:
                continue

            if component.refdes is not None:
                component.error(_("refdes= and portname= attributes "
                                  "are mutually exclusive"))
            if xorn.geda.attrib.search_all(component.ob, 'net'):
                component.error(_("portname= and net= attributes "
                                  "are mutually exclusive"))

            if not component.pins:
                component.error(_("I/O symbol doesn't have pins"))
            if len(component.pins) > 1:
                component.error(_("multiple pins on I/O symbol"))
            for pin in component.pins:
                if pin.number is not None or pin.ob.attached_objects():
                    pin.warn(_("pin attributes on I/O symbol are ignored"))

            try:
                ports = schematic.ports[portname]
            except KeyError:
                ports = schematic.ports[portname] = []
            ports.append(component)

            component.has_portname_attrib = True
Exemplo n.º 2
0
 def warning(self):
     # apturl minver matches
     if not self.pkg_state == PkgStates.INSTALLED:
         if self._app.request:
             minver_matches = re.findall(r'minver=[a-z,0-9,-,+,.,~]*',
                 self._app.request)
             if minver_matches and self.version:
                 minver = minver_matches[0][7:]
                 from softwarecenter.utils import version_compare
                 if version_compare(minver, self.version) > 0:
                     return _("Version %s or later not available.") % minver
     # can we enable a source
     if not self._pkg:
         source_to_enable = None
         if self.channelname and self._unavailable_channel():
             source_to_enable = self.channelname
         elif (self.component and
               self.component not in ("independent", "commercial")):
             source_to_enable = self.component
         if source_to_enable:
             sources = source_to_enable.split('&')
             sources_length = len(sources)
             if sources_length == 1:
                 warning = (_("Available from the \"%s\" source.") %
                     sources[0])
             elif sources_length > 1:
                 # Translators: the visible string is constructed
                 # concatenating the following 3 strings like this:
                 # Available from the following sources: %s, ... %s, %s.
                 warning = _("Available from the following sources: ")
                 # Cycle through all, but the last
                 for source in sources[:-1]:
                     warning += _("\"%s\", ") % source
                 warning += _("\"%s\".") % sources[sources_length - 1]
             return warning
Exemplo n.º 3
0
    def setup_command(self, session):
        # FIXME: Implement and add more potential sources of e-mails
        macmail_emails = self._testing_data(self._get_macmail_emails, ['1'])
        tbird_emails = self._testing_data(self._get_tbird_emails, ['1'])
        gnupg_emails = self._testing_data(self._get_gnupg_emails, [
            {
                'name': 'Innocent Adventurer',
                'address': '*****@*****.**',
                'source': 'The Youtubes'
            },
            {
                'name': 'Chelsea Manning',
                'address': '*****@*****.**',
                'source': 'Internal Tribute Store'
            },
            {
                'name': 'MUSCULAR',
                'address': '*****@*****.**',
                'source': 'Well funded adversaries'
            }
        ])

        emails = macmail_emails + tbird_emails + gnupg_emails
        if not emails:
            return self._error(_('No e-mail addresses found'))
        else:
            return self._success(_('Discovered e-mail addresses'), {
                'emails': emails
            })
Exemplo n.º 4
0
 def start (self):
     if len (self.errors) == 0:
         e = operations.FinishedEvent (self, operations.SUCCESSFUL)
         for l in self.listeners:
             l.on_finished (e)
         return
             
     elif len (self.errors) > 1:
         title = _("Unsupported file types")
     else:
         title = _("Unsupported file type")
         
     filenames = []
     for e in self.errors:
         filenames.append (gnomevfs.URI(e.hints['location']).short_name)
     del self.__errors
     
     if len (filenames) == 1:
         msg = _("The following files were not added:") + "\n"
     else:
         msg = _("The following files were not added:") + "\n"
     
     msg +=  " " + filenames[0]
     
     for f in filenames[1:]:
         msg += ", " + f
     gtkutil.dialog_error (title, msg, self.parent)
     
     e = operations.FinishedEvent (self, operations.SUCCESSFUL)
     for l in self.listeners:
         l.on_finished (e)
Exemplo n.º 5
0
    def __init__(self, *args, **kwargs):
        super(_StuckStrip, self).__init__(*args, **kwargs)

        self.orientation = Gtk.Orientation.HORIZONTAL

        spacer1 = Gtk.Label(label='')
        self.pack_start(spacer1, True, True, 0)

        spacer2 = Gtk.Label(label='')
        self.pack_end(spacer2, expand=True, fill=False, padding=0)

        self.set_spacing(10)

        self.set_border_width(10)

        label = Gtk.Label(label=_("Stuck?  You can still solve the puzzle."))
        self.pack_start(label, False, True, 0)

        icon = Icon()
        icon.set_from_icon_name('edit-undo', Gtk.IconSize.LARGE_TOOLBAR)
        self.button = Gtk.Button(stock=Gtk.STOCK_UNDO)
        self.button.set_image(icon)
        self.button.set_label(_("Undo some moves"))
        self.pack_end(self.button, expand=False, fill=False, padding=0)

        def callback(source):
            self.emit('undo-clicked')
        self.button.connect('clicked', callback)
Exemplo n.º 6
0
 def render_web(self, cfg, tpl_names, data):
     """Render data as HTML"""
     alldata = default_dict(self.html_variables)
     alldata["config"] = cfg
     alldata.update(data)
     try:
         template = self._web_template(cfg, tpl_names)
         if template:
             return template.render(alldata)
         else:
             emsg = _("<h1>Template not found</h1>\n<p>%s</p><p>"
                      "<b>DATA:</b> %s</p>")
             tpl_esc_names = [escape_html(tn) for tn in tpl_names]
             return emsg % (' or '.join(tpl_esc_names),
                            escape_html('%s' % alldata))
     except (UndefinedError, ):
         emsg = _("<h1>Template error</h1>\n"
                  "<pre>%s</pre>\n<p>%s</p><p><b>DATA:</b> %s</p>")
         return emsg % (escape_html(traceback.format_exc()),
                        ' or '.join([escape_html(tn) for tn in tpl_names]),
                        escape_html('%.4096s' % alldata))
     except (TemplateNotFound, TemplatesNotFound), e:
         emsg = _("<h1>Template not found in %s</h1>\n"
                  "<b>%s</b><br/>"
                  "<div><hr><p><b>DATA:</b> %s</p></div>")
         return emsg % tuple([escape_html(unicode(v))
                              for v in (e.name, e.message,
                                        '%.4096s' % alldata)])
Exemplo n.º 7
0
    def __accept_clicked_cb(self, widget):
        if self._section_view.needs_restart:
            self._section_toolbar.accept_button.set_sensitive(False)
            self._section_toolbar.cancel_button.set_sensitive(False)
            alert = Alert()
            alert.props.title = _('Warning')
            alert.props.msg = _('Changes require restart')

            icon = Icon(icon_name='dialog-cancel')
            alert.add_button(Gtk.ResponseType.CANCEL,
                             _('Cancel changes'), icon)
            icon.show()

            if self._current_option != 'aboutme':
                icon = Icon(icon_name='dialog-ok')
                alert.add_button(Gtk.ResponseType.ACCEPT, _('Later'), icon)
                icon.show()

            icon = Icon(icon_name='system-restart')
            alert.add_button(Gtk.ResponseType.APPLY, _('Restart now'), icon)
            icon.show()

            self._vbox.pack_start(alert, False, False, 0)
            self._vbox.reorder_child(alert, 2)
            alert.connect('response', self.__response_cb)
            alert.show()
        else:
            self._show_main_view()
Exemplo n.º 8
0
 def command(self):
     session, config = self.session, self.session.config
     handle, lines = self.args[0], self.args[1:]
     vcard = config.vcards.get_vcard(handle)
     if not vcard:
         return self._error('%s not found: %s' % (self.VCARD, handle))
     config.vcards.deindex_vcard(vcard)
     try:
         for l in lines:
             if '=' in l[:5]:
                 ln, l = l.split('=', 1)
                 vcard.set_line(int(ln.strip()), VCardLine(l.strip()))
             else:
                 vcard.add(VCardLine(l))
         vcard.save()
         return self._success(_("Added %d lines") % len(lines),
             result=self._vcard_list([vcard], simplify=True, info={
                 'updated': handle,
                 'added': len(lines)
             }))
     except KeyboardInterrupt:
         raise
     except:
         config.vcards.index_vcard(vcard)
         self._ignore_exception()
         return self._error(_('Error adding lines to %s') % handle)
     finally:
         config.vcards.index_vcard(vcard)
Exemplo n.º 9
0
    def command(self, format, terms=None, **kwargs):
        session, config = self.session, self.session.config

        if not format in PluginManager.CONTACT_IMPORTERS.keys():
            session.ui.error("No such import format")
            return False

        importer = PluginManager.CONTACT_IMPORTERS[format]

        if not all([x in kwargs.keys() for x in importer.required_parameters]):
            session.ui.error(
                _("Required paramter missing. Required parameters "
                  "are: %s") % ", ".join(importer.required_parameters))
            return False

        allparams = importer.required_parameters + importer.optional_parameters

        if not all([x in allparams for x in kwargs.keys()]):
            session.ui.error(
                _("Unknown parameter passed to importer. "
                  "Provided %s; but known parameters are: %s"
                  ) % (", ".join(kwargs), ", ".join(allparams)))
            return False

        imp = importer(kwargs)
        if terms:
            contacts = imp.filter_contacts(terms)
        else:
            contacts = imp.get_contacts()

        for importedcontact in contacts:
            # Check if contact exists. If yes, then update. Else create.
            pass
Exemplo n.º 10
0
    def _getFilesizeEstimate(self):
        """Estimates the final file size.

        Estimates in megabytes (over 30 MB) are rounded to the nearest 10 MB
        to smooth out small variations. You'd be surprised how imprecision can
        improve perceived accuracy.

        Returns:
            str: A human-readable (ex: "14 MB") estimate for the file size.
        """
        if not self.current_position or self.current_position == 0:
            return None

        current_filesize = os.stat(path_from_uri(self.outfile)).st_size
        length = self.project.ges_timeline.props.duration
        estimated_size = float(
            current_filesize * float(length) / self.current_position)
        # Now let's make it human-readable (instead of octets).
        # If it's in the giga range (10⁹) instead of mega (10⁶), use 2 decimals
        if estimated_size > 10e8:
            gigabytes = estimated_size / (10 ** 9)
            return _("%.2f GB" % gigabytes)
        else:
            megabytes = int(estimated_size / (10 ** 6))
            if megabytes > 30:
                megabytes = int(round(megabytes, -1))  # -1 means round to 10
            return _("%d MB" % megabytes)
Exemplo n.º 11
0
def _apply_changes(request, old_status, new_status):
    """Apply the changes"""
    modified = False

    if old_status['enabled'] != new_status['enabled']:
        sub_command = 'enable' if new_status['enabled'] else 'disable'
        actions.superuser_run('transmission', [sub_command])
        transmission.service.notify_enabled(None, new_status['enabled'])
        modified = True

    if old_status['download_dir'] != new_status['download_dir'] or \
       old_status['rpc_username'] != new_status['rpc_username'] or \
       old_status['rpc_password'] != new_status['rpc_password']:
        new_configuration = {
            'download-dir': new_status['download_dir'],
            'rpc-username': new_status['rpc_username'],
            'rpc-password': new_status['rpc_password'],
        }

        actions.superuser_run('transmission', ['merge-configuration',
                                               json.dumps(new_configuration)])
        modified = True

    if modified:
        messages.success(request, _('Configuration updated'))
    else:
        messages.info(request, _('Setting unchanged'))
Exemplo n.º 12
0
 def setup_parser(self):
     self.parser.add_option('--org', dest='org',
                    help=_("organization name (required)"))
     self.parser.add_option('--name', dest='name',
                  help=_("filter name (required)"))
     self.parser.add_option('--package', dest='package_id',
                    help=_("package id (required)"))
Exemplo n.º 13
0
    def _download_manifest(self):
        """
        Download the manifest file, and process it to return an ISOManifest.

        :return: manifest of available ISOs
        :rtype:  pulp_rpm.plugins.db.models.ISOManifest
        """
        manifest_url = urljoin(self._repo_url, models.ISOManifest.FILENAME)
        # I probably should have called this manifest destination, but I couldn't help myself
        manifest_destiny = StringIO()
        manifest_request = request.DownloadRequest(manifest_url, manifest_destiny)
        self.downloader.download([manifest_request])
        # We can inspect the report status to see if we had an error when retrieving the manifest.
        if self.progress_report.state == self.progress_report.STATE_MANIFEST_FAILED:
            raise IOError(_("Could not retrieve %(url)s") % {'url': manifest_url})

        manifest_destiny.seek(0)
        try:
            manifest = models.ISOManifest(manifest_destiny, self._repo_url)
        except ValueError:
            self.progress_report.error_message = _('The PULP_MANIFEST file was not in the ' +
                                                   'expected format.')
            self.progress_report.state = self.progress_report.STATE_MANIFEST_FAILED
            raise ValueError(self.progress_report.error_message)

        return manifest
Exemplo n.º 14
0
    def __init__(self):
        # load glade-file
        glade_file = os.path.join(os.path.dirname(__file__),"accelmap.glade")
        self.__xml = gtk.glade.XML(glade_file, "AccelDialog")
        
        # and get some widgets
        self.__dialog = self.__xml.get_widget("AccelDialog")
        self.__tree = self.__xml.get_widget("ActionTree")

        # add colums to treeview
        self.__tree.append_column(gtk.TreeViewColumn(_("Action"), gtk.CellRendererText(), markup=0))
        self.__tree.append_column(gtk.TreeViewColumn(_("Shortcut"), gtk.CellRendererText(), text=1))

        # create and fill treemodel
        self.__model_iters = dict()
        self.__model = gtk.TreeStore(str, str, str)
        self.__my_accel_map = dict()
        gtk.accel_map_foreach(self.populate_tree)
        self.__model.set_sort_column_id(0, gtk.SORT_ASCENDING)
        self.__tree.set_model(self.__model)

        # connect event-handler
        self.__tree.connect("row-activated", self.on_double_click)
        self.__xml.get_widget("cancel").connect('clicked', self.on_cancel_clicked)
        self.__xml.get_widget("apply").connect('clicked', self.on_apply_clicked)
Exemplo n.º 15
0
    def run(self):
        org = self.get_option('org')
        name = self.get_option('name')

        self.api.delete(org, name)
        print _("Successfully deleted filter [ %s ]") % name
        return os.EX_OK
Exemplo n.º 16
0
    def build_widget(self):
        v=gtk.VBox()

        self.label={}

        self.label['title']=gtk.Label()
        v.pack_start(self.label['title'], expand=False)

        exp=gtk.Expander()
        exp.set_expanded(False)
        exp.set_label(_("Contents"))
        c=self.label['contents']=gtk.Label()
        c.set_line_wrap(True)
        c.set_selectable(True)
        c.set_single_line_mode(False)
        c.set_alignment(0.0, 0.0)
        exp.add(c)
        v.pack_start(exp, expand=False)

        f=gtk.Frame(_("Members"))
        #  Display members
        self.members_widget=gtk.VBox()
        f.add(self.members_widget)

        v.add(f)
        return v
Exemplo n.º 17
0
def _check_for_relative_path_conflicts(repo, config, config_conduit, error_messages):
    relative_path = get_repo_relative_path(repo, config)
    conflicting_distributors = config_conduit.get_repo_distributors_by_relative_url(relative_path, repo.repo_id)
    # in all honesty, this loop should execute at most once
    # but it may be interesting/useful for erroneous situations
    for distributor in conflicting_distributors:
        conflicting_repo_id = distributor["repo_id"]
        conflicting_relative_url = None
        if "relative_url" in distributor["config"]:
            conflicting_relative_url = distributor["config"]["relative_url"]
            msg = _(
                "Relative URL [{relative_path}] for repository [{repo_id}] conflicts with "
                "existing relative URL [{conflict_url}] for repository [{conflict_repo}]"
            )
        else:
            msg = _(
                "Relative URL [{relative_path}] for repository [{repo_id}] conflicts with "
                "repo id for existing repository [{conflict_repo}]"
            )
        error_messages.append(
            msg.format(
                relative_path=relative_path,
                repo_id=repo.repo_id,
                conflict_url=conflicting_relative_url,
                conflict_repo=conflicting_repo_id,
            )
        )
Exemplo n.º 18
0
 def __operation_finished_cb(self, backend):
     self._progress_bar.set_fraction(1.0)
     if self._operation == OPERATION_BACKUP:
         self._message_label.set_text(_('Backup finished successfully'))
     if self._operation == OPERATION_RESTORE:
         self._message_label.set_text(_('Restore realized successfully.'))
     self._view.props.is_valid = True
Exemplo n.º 19
0
    def run(self, **kwargs):
        consumer_id = self.get_consumer_id(kwargs)
        options = self.get_update_options(kwargs)
        units = self.get_content_units(kwargs)

        if not units:
            msg = _('No content units specified')
            self.context.prompt.render_failure_message(msg)
            return

        try:
            response = self.api.update(consumer_id, units=units, options=options)

        except NotFoundException:
            msg = _('Consumer [ %(c)s ] not found') % {'c': consumer_id}
            self.context.prompt.render_failure_message(msg, tag='not-found')
            return os.EX_DATAERR

        else:
            task = response.response_body
            for task_id in [t.task_id for t in task.spawned_tasks]:
                msg = _('Update task created with id [ %(t)s ]') % {'t': task_id}
                self.context.prompt.render_success_message(msg)

            self.poll([task], kwargs)
Exemplo n.º 20
0
    def modInit(self):
        """ Initialize the module """
        self.lvls      = prefs.get(__name__, 'levels', [0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
        self.preset    = prefs.get(__name__, 'preset', _('Flat'))
        self.cfgWindow = None

        modules.addMenuItem(_('Equalizer'), self.configure, '<Control>E')
Exemplo n.º 21
0
    def __init__(self, view):
        Gtk.VBox.__init__(self)

        self._view = view
        hbox = Gtk.HBox()

        self.backup_btn = _BackupButton(
            icon_name='backup-backup',
            title=_('Save the contents of your Journal'),
            pixel_size=style.GRID_CELL_SIZE)
        self.backup_btn.connect('button_press_event',
                                self.__backup_button_press_cb)
        hbox.pack_start(self.backup_btn, False, False, style.DEFAULT_SPACING)

        self.restore_btn = _BackupButton(
            icon_name='backup-restore',
            title=_('Restore the contents of your Journal'),
            pixel_size=style.GRID_CELL_SIZE)
        self.restore_btn.connect('button_press_event',
                                 self.__restore_button_press_cb)
        hbox.pack_start(self.restore_btn, False, False, style.DEFAULT_SPACING)

        hbox.set_valign(Gtk.Align.CENTER)
        hbox.set_halign(Gtk.Align.CENTER)
        self.add(hbox)
        self.show_all()
Exemplo n.º 22
0
    def _setup_toolbars(self):
        ''' Setup the toolbars.. '''

        tools_toolbar = Gtk.Toolbar()
        numbers_toolbar = Gtk.Toolbar()
        toolbox = ToolbarBox()

        self.activity_toolbar_button = ActivityToolbarButton(self)

        toolbox.toolbar.insert(self.activity_toolbar_button, 0)
        self.activity_toolbar_button.show()

        self.numbers_toolbar_button = ToolbarButton(
            page=numbers_toolbar,
            icon_name='number-tools')
        if MODE == 'number':
            numbers_toolbar.show()
            toolbox.toolbar.insert(self.numbers_toolbar_button, -1)
            self.numbers_toolbar_button.show()

        self.tools_toolbar_button = ToolbarButton(
            page=tools_toolbar,
            icon_name='view-source')

        self.button_pattern = button_factory(
            'new-pattern-game', toolbox.toolbar, self._select_game_cb,
            cb_arg='pattern', tooltip=_('New game'))

        self._set_extras(toolbox.toolbar)

        self._sep.append(separator_factory(toolbox.toolbar, True, False))

        stop_button = StopButton(self)
        stop_button.props.accelerator = '<Ctrl>q'
        toolbox.toolbar.insert(stop_button, -1)
        stop_button.show()

        button_factory('score-copy', self.activity_toolbar_button,
                       self._write_scores_to_clipboard,
                       tooltip=_('Export scores to clipboard'))

        self.set_toolbar_box(toolbox)
        toolbox.show()

        if MODE == 'word':
            self.words_tool_button = button_factory(
                'word-tools', tools_toolbar, self._edit_words_cb,
                tooltip=_('Edit word lists.'))

        self.import_button = button_factory(
            'image-tools', tools_toolbar, self.image_import_cb,
            tooltip=_('Import custom cards'))

        self.button_custom = button_factory(
            'new-custom-game', tools_toolbar, self._select_game_cb,
            cb_arg='custom', tooltip=_('New custom game'))
        self.button_custom.set_sensitive(False)

        if MODE == 'number':
            self._setup_number_buttons(numbers_toolbar)
Exemplo n.º 23
0
    def __init__(self, context, name='list', description=DESC_LIST, method=None,
                 repos_title=None, other_repos_title=None, include_all_flag=True):
        self.context = context
        self.prompt = context.prompt

        if method is None:
            method = self.run

        self.repos_title = repos_title
        if self.repos_title is None:
            self.repos_title = _('Repositories')

        self.other_repos_title = other_repos_title
        if self.other_repos_title is None:
            self.other_repos_title = _('Other Pulp Repositories')

        super(ListRepositoriesCommand, self).__init__(name, description, method)

        d = _('if specified, detailed configuration information is displayed for each repository')
        self.add_option(PulpCliFlag('--details', d))

        d = _('comma-separated list of repository fields; if specified, only the given fields will displayed')
        self.add_option(PulpCliOption('--fields', d, required=False))

        self.supports_all = include_all_flag
        if self.supports_all:
            d = _('if specified, information on all Pulp repositories, regardless of type, will be displayed')
            self.add_option(PulpCliFlag('--all', d, aliases=['-a']))
 def read (self):
     self.emit('progress',0,_('Logging into %s')%'www.cooksillustrated.com')
     global driver
     if driver:
         # Don't log in twice :)
         self.d = driver
     else:
         #self.d = webdriver.Chrome()
         self.d = webdriver.Firefox()
         print 'Logging in...'
         driver = self.d
         self.d.get('https://www.cooksillustrated.com/sign_in/')
         username,pw = self.get_username_and_pw()
         #un=self.d.find_element_by_xpath('//*[@name="user[email]"]')
         un=self.d.find_element_by_xpath('//*[@id="email"]')
         print 'Got email element',un
         un.send_keys(username)
         #pw_el = self.d.find_element_by_xpath('//*[@name="user[password]"]')
         pw_el = self.d.find_element_by_xpath('//*[@id="password"]')
         print 'Got password element',pw_el
         pw_el.send_keys(pw+'\n')
     # Now get URL
     # First log in...
     self.emit('progress',0.5,_('Logging into %s')%'www.cooksillustrated.com')
     self.emit('progress',0.6,_('Retrieving %s')%self.url)
     self.d.get(self.url)
     self.emit('progress',1,_('Retrieving %s')%self.url)
     self.content_type = 'text/html'
     self.data = self.d.page_source
Exemplo n.º 25
0
    def _create_technical(self):
        vbox = Gtk.VBox()
        vbox.props.spacing = style.DEFAULT_SPACING

        if 'filesize' in self._metadata:
            filesize = self._metadata['filesize']
        else:
            filesize = model.get_file_size(self._metadata['uid'])

        lines = [
            _('Kind: %s') % (self._metadata.get('mime_type') or _('Unknown'),),
            _('Date: %s') % (self._format_date(),),
            _('Size: %s') % (format_size(int(filesize)))
        ]

        for line in lines:
            linebox = Gtk.HBox()
            vbox.pack_start(linebox, False, False, 0)

            text = Gtk.Label()
            text.set_markup('<span foreground="%s">%s</span>' % (
                style.COLOR_BUTTON_GREY.get_html(), line))
            linebox.pack_start(text, False, False, 0)

        return vbox
Exemplo n.º 26
0
    def __init__(self, parent):
        BaseDialog.__init__(self, parent)

        self.main_ui = parent
        self.header_label = QtGui.QLabel()
        self.header_label.setAlignment(QtCore.Qt.AlignCenter)
        self.pcde_le = UpperCaseLineEdit()
        self.pcde_le.setText(self.main_ui.pt.pcde)
        self.simd_label = QtGui.QLabel()
        self.simd_label.setAlignment(QtCore.Qt.AlignCenter)

        self.tbi_checkbox = QtGui.QCheckBox(
            _("ToothBrushing Instruction Given"))
        self.tbi_checkbox.setChecked(True)

        self.di_checkbox = QtGui.QCheckBox(_("Dietary Advice Given"))
        self.di_checkbox.setChecked(True)

        self.fl_checkbox = QtGui.QCheckBox(_("Fluoride Varnish Applied"))
        self.fl_checkbox.setToolTip(
            _("Fee claimable for patients betwen 2 and 5"))
        self.fl_checkbox.setChecked(2 <= self.main_ui.pt.ageYears <= 5)

        self.insertWidget(self.header_label)
        self.insertWidget(self.pcde_le)
        self.insertWidget(self.simd_label)
        self.insertWidget(self.tbi_checkbox)
        self.insertWidget(self.di_checkbox)
        self.insertWidget(self.fl_checkbox)

        self.pcde_le.textEdited.connect(self.check_pcde)

        self._simd = None
Exemplo n.º 27
0
    def _file_part_receiver(self, target, filename, part, numparts,
                            bytes, title=None, color=None, sender=None):
        # ignore my own signal
        if sender == self._tube.get_unique_name():
            return
        
        if not (target == 'all' or target == self._tube.get_unique_name()):
            return
        
        # first chunk
        if part == 1:
            tmp_root = join(environ['SUGAR_ACTIVITY_ROOT'], 'instance')
            temp_dir = tempfile.mkdtemp(dir=tmp_root)
            chmod(temp_dir, 0777)
            self.temp_file = join(temp_dir, 'game.zip')
            self.files[filename] = self.temp_file
            self.f = open(self.temp_file, 'a+b')
        
        self.f.write(bytes)
        
        percentage = int(float(part) / float(numparts) * 100.0)
        self.game.set_load_mode(_('Receiving game') + ': '
                                + str(percentage) + '% ' + _('done') + '.')

        # last chunk
        if part == numparts:
            self.f.close()   
            #file = self.files[filename]
            # Saves the zip in datastore
            gameObject = datastore.create()
            gameObject.metadata['title'] = title
            gameObject.metadata['mime_type'] = 'application/x-memorize-project'
            gameObject.metadata['icon-color'] = color
            gameObject.file_path = self.temp_file
            datastore.write(gameObject)
Exemplo n.º 28
0
    def on_save(self):
        self.bookmarks_win.save()
        if find_duplicates(self.new_bookmarks):
            self.core.information(_('Duplicate bookmarks in list (saving aborted)'), 'Error')
            return
        for bm in self.new_bookmarks:
            if safeJID(bm.jid):
                if not self.bookmarks[bm.jid]:
                    self.bookmarks.append(bm)
            else:
                self.core.information(_('Invalid JID for bookmark: %s/%s') % (bm.jid, bm.nick), 'Error')
                return

        for bm in self.removed_bookmarks:
            if bm in self.bookmarks:
                self.bookmarks.remove(bm)

        def send_cb(success):
            if success:
                self.core.information(_('Bookmarks saved.'), 'Info')
            else:
                self.core.information(_('Remote bookmarks not saved.'), 'Error')
        log.debug('alerte %s', str(stanza_storage(self.bookmarks.bookmarks)))
        self.bookmarks.save(self.core.xmpp, callback=send_cb)
        self.core.close_tab()
        return True
Exemplo n.º 29
0
    def update_disc_usage (self):
        if not self.update:
            return
        if self.source.total_duration > self.disc_size:
            self.__capacity_exceeded.show ()
            
        else:
            self.__capacity_exceeded.hide ()

        # Flush events so progressbar redrawing gets done
        while gtk.events_pending():
            gtk.main_iteration(True)
        
        if self.source.total_duration > 0:
            duration = self.__disc_size - self.source.total_duration
            if duration > 0:
                dur = _("%s remaining")  % self.__hig_duration (duration)
            else:
                dur = _("%s overlaping") % self.__hig_duration (abs (duration))
        else:
            dur = _("Empty")
        
        self.__usage_label.set_text (dur)
            
        e = operations.Event(self)
        for l in self.listeners:
            l.on_contents_changed (e)
    def on_added(self):
        actions = {}
	def configure_dnie():
            os.system('%s --install-dnie' % CERTMANAGER_CMD)

        def configure_ceres():
            os.system('%s --install-ceres' % CERTMANAGER_CMD)

        if os.path.exists(CERTMANAGER_CMD):
            actions[_("Configure DNIe")] = configure_dnie
            actions[_("Configure FNMT-Ceres card")] = configure_ceres

        def add_user_to_scard():
            import pwd
	    # The os.getlogin() raises OSError: [Errno 25]
            # Moved to getpwuid
	    user = pwd.getpwuid(os.geteuid())[0]
            # get root access
            if get_sudo():
                cmd = '/usr/bin/gksudo /usr/sbin/adduser %s scard' % user
                status, output = commands.getstatusoutput(cmd)
                self.msg_render.show_info(_('Session restart needed'),
                                          _('You must restart your session to apply the changes'))

        status, output = commands.getstatusoutput('/usr/bin/groups')
        if 'scard' not in output:
            actions[_("Add user to scard group")] = add_user_to_scard

        self.msg_render.show(self.__device_title__, 
                             self.__device_conn_description__,
                             self.__icon_path__, actions=actions)
Exemplo n.º 31
0
 def __init__(self, *args, **kwargs):
     super(SaveMetadataStep, self).__init__(*args, **kwargs)
     self.description = _('Save metadata')
Exemplo n.º 32
0
    def _setup_page(self):
        for child in self.get_children():
            self.remove(child)

        def _setup_name_page(self):
            self._current_page = self._name_page

        def _setup_color_page(self):
            self._current_page = self._color_page

        def _setup_gender_page(self):
            if self._color_page.get_color() is not None:
                self._gender_page.update_color(self._color_page.get_color())
            self._current_page = self._gender_page

        def _setup_age_page(self):
            if self._gender_page.get_gender() is not None:
                self._age_page.update_gender(self._gender_page.get_gender())
            if self._color_page.get_color() is not None:
                self._age_page.update_color(self._color_page.get_color())
            self._current_page = self._age_page

        setup_methods = [
            _setup_name_page, _setup_color_page, _setup_gender_page,
            _setup_age_page
        ]

        setup_methods[self._page](self)
        self.pack_start(self._current_page, True, True, 0)
        self._current_page.show()

        button_box = Gtk.HButtonBox()
        if self._page == self.PAGE_FIRST:
            button_box.set_layout(Gtk.ButtonBoxStyle.END)
        else:
            button_box.set_layout(Gtk.ButtonBoxStyle.EDGE)
            back_button = Gtk.Button(_('Back'))
            image = Icon(icon_name='go-left')
            back_button.set_image(image)
            back_button.connect('clicked', self._back_activated_cb)
            button_box.pack_start(back_button, True, True, 0)
            back_button.show()

        self._next_button = Gtk.Button()
        image = Icon(icon_name='go-right')
        self._next_button.set_image(image)

        if self._page == self.PAGE_LAST:
            self._next_button.set_label(_('Done'))
            self._next_button.connect('clicked', self._done_activated_cb)
        else:
            self._next_button.set_label(_('Next'))
            self._next_button.connect('clicked', self._next_activated_cb)

        self._current_page.activate()

        self._update_next_button()
        button_box.pack_start(self._next_button, True, True, 0)
        self._next_button.show()

        self._current_page.connect('notify::valid',
                                   self._page_valid_changed_cb)

        self.pack_start(button_box, False, True, 0)
        button_box.show()

        if not self.PAGES[self._page]:
            next(self)
Exemplo n.º 33
0
 def __init__(self):
     super().__init__(name="IDE", description=_("Generic IDEs"),
                      logo_path=None)
Exemplo n.º 34
0
	def __init_attributes(self, editor):
		self.__editor = editor
		self.__manager = None
#		name, shortcut, description, category = (
#			"zencoding-toggle-comment",
#			"<alt>c",
#			_("Add or remove comments in most web languages"),
#			_("Markup Operations")
#		)
#		self.__trigger1 = self.create_trigger(name, shortcut, description, category)
#		self.__trigger1.zen_action = "toggle_comment"
		name, shortcut, description, category = (
			"zencoding-expand-abbreviation",
			"<ctrl>comma",
			_("Expand markup abbreviations"),
			_("Markup Operations")
		)
		self.__trigger2 = self.create_trigger(name, shortcut, description, category)
		self.__trigger2.zen_action = "expand_abbreviation"
		name, shortcut, description, category = (
			"zencoding-next-edit-point",
			"<super><alt>Right",
			_("Move cursor to next edit point"),
			_("Markup Operations")
		)
		self.__trigger3 = self.create_trigger(name, shortcut, description, category)
		self.__trigger3.zen_action = "next_edit_point"
		name, shortcut, description, category = (
			"zencoding-previous-edit-point",
			"<super><alt>Left",
			_("Move cursor to previous edit point"),
			_("Markup Operations")
		)
		self.__trigger4 = self.create_trigger(name, shortcut, description, category)
		self.__trigger4.zen_action = "prev_edit_point"
		name, shortcut, description, category = (
			"zencoding-remove-tag",
			"<super>r",
			_("Remove a tag"),
			_("Markup Operations")
		)
		self.__trigger5 = self.create_trigger(name, shortcut, description, category)
		self.__trigger5.zen_action = "remove_tag"
		name, shortcut, description, category = (
			"zencoding-select-in-tag",
			"<super>i",
			_("Select inner tag's content"),
			_("Markup Operations")
		)
		self.__trigger6 = self.create_trigger(name, shortcut, description, category)
		self.__trigger6.zen_action = "match_pair_inward"
		name, shortcut, description, category = (
			"zencoding-select-out-tag",
			"<super>o",
			_("Select outer tag's content"),
			_("Markup Operations")
		)
		self.__trigger7 = self.create_trigger(name, shortcut, description, category)
		self.__trigger7.zen_action = "match_pair_outward"
		name, shortcut, description, category = (
			"zencoding-split",
			"<super>j",
			_("Toggle between single and double tag"),
			_("Markup Operations")
		)
		self.__trigger8 = self.create_trigger(name, shortcut, description, category)
		self.__trigger8.zen_action = "split_join_tag"
		name, shortcut, description, category = (
			"zencoding-merge",
			"<super>m",
			_("Merge lines"),
			_("Markup Operations")
		)
		self.__trigger9 = self.create_trigger(name, shortcut, description, category)
		self.__trigger9.zen_action = "merge_lines"
		name, shortcut, description, category = (
			"zencoding-wrap-with-abbreviation",
			"<ctrl>less",
			_("Wrap with abbreviation"),
			_("Markup Operations")
		)
		self.__trigger10 = self.create_trigger(name, shortcut, description, category)
		self.__trigger10.zen_action = "wrap_with_abbreviation"
		return
Exemplo n.º 35
0
from gettext import gettext as _
import hashlib
import os
import sys

import rpm
from pulp.client.commands.options import OPTION_REPO_ID
from pulp.client.commands.repo.upload import UploadCommand, MetadataException
from pulp.client.extensions.extensions import PulpCliFlag

from pulp_rpm.common.ids import TYPE_ID_RPM, TYPE_ID_SRPM
from pulp_rpm.extensions.admin.repo_options import OPT_CHECKSUM_TYPE


NAME_RPM = 'rpm'
DESC_RPM = _('uploads one or more RPMs into a repository')
SUFFIX_RPM = '.rpm'

NAME_SRPM = 'srpm'
DESC_SRPM = _('uploads one or more SRPMs into a repository')
SUFFIX_SRPM = '.src.rpm'

DESC_SKIP_EXISTING = _('if specified, RPMs that already exist on the server will not be uploaded')
FLAG_SKIP_EXISTING = PulpCliFlag('--skip-existing', DESC_SKIP_EXISTING)

RPMTAG_NOSOURCE = 1051
CHECKSUM_READ_BUFFER_SIZE = 65536


class _CreatePackageCommand(UploadCommand):
    """
Exemplo n.º 36
0
# -*- coding: utf-8 -*-

# Resolving gettext as _ for module loading.
from gettext import gettext as _

SKILL_NAME = "Bangalore Guide"

WELCOME = _("Welcome to Bangalore Guide!")
HELP = _("Say about, to hear more about the city, or say coffee, breakfast, lunch, or dinner, to hear local restaurant suggestions, or say recommend an attraction, or say, go outside. ")
ABOUT = _("Bangalore, Karnataka is a city in South India. A popular city for anything tech related, Bangalore is known for its tech scene and diverse urban population.")
STOP = _("Okay, see you next time!")
FALLBACK = _("The {} can't help you with that. It can help you learn about Bangalore if you say tell me about this place. What can I help you with?")
GENERIC_REPROMPT = _("What can I help you with?")

CITY_DATA = {
    "city": "Bangalore",
    "state": "Karnataka",
    "postcode": "560025",
    "restaurants": [
        {
            "name": "A Whole Lotta Love",
            "address": 'Koramangala',
            "phone": '978-283-0474',
            "meals": 'Breakfast',
            "description": 'A cozy and popular spot for breakfast.  Try the omlettes!',
        },
        {
            "name": 'Cafe Coffee Day',
            "address": 'Richmond Road',
            "phone": '978-281-1851',
            "meals": 'coffee, snacks',
Exemplo n.º 37
0
    def __init__(self, repo, conduit, config):
        """
        :param repo:        repository to sync
        :type  repo:        pulp.plugins.model.Repository
        :param conduit:     sync conduit to use
        :type  conduit:     pulp.plugins.conduits.repo_sync.RepoSyncConduit
        :param config:      config object for the sync
        :type  config:      pulp.plugins.config.PluginCallConfiguration
        """
        super(RepoSync, self).__init__(step_type=constants.SYNC_STEP,
                                       repo=repo,
                                       conduit=conduit,
                                       config=config)
        self.description = _('Syncing Repository')

        self.feed_url = self.get_config().get('feed').strip('/')
        self.releases = self.get_config().get('releases', 'stable').split(',')
        self.architectures = split_or_none(self.get_config().get('architectures'))
        self.components = split_or_none(self.get_config().get('components'))

        self.unit_relative_urls = {}
        self.available_units = None
        # dicts with release names as keys to multiplex variables
        self.apt_repo_meta = {}
        self.release_units = {}
        self.release_files = {
            release: os.path.join(self.get_working_dir(), release, 'Release')
            for release in self.releases}
        self.feed_urls = {
            release: urlparse.urljoin(self.feed_url + '/', '/'.join(['dists', release]))
            for release in self.releases}
        self.release_urls = {
            release: urlparse.urljoin(self.feed_urls[release] + '/', 'Release')
            for release in self.releases}
        self.packages_urls = {}
        # double dicts with release/component as keys
        self.component_units = defaultdict(dict)
        self.component_packages = defaultdict(dict)

        for release in self.releases:
            misc.mkdir(os.path.dirname(self.release_files[release]))
            _logger.info("Downloading %s", self.release_urls[release])

        # defining lifecycle
        #  metadata
        self.add_child(publish_step.DownloadStep(
            constants.SYNC_STEP_RELEASE_DOWNLOAD,
            plugin_type=ids.TYPE_ID_IMPORTER,
            description=_('Retrieving metadata: release file(s)'),
            downloads=[
                DownloadRequest(self.release_urls[release], self.release_files[release])
                for release in self.releases]))

        self.add_child(ParseReleaseStep(constants.SYNC_STEP_RELEASE_PARSE))

        self.step_download_Packages = publish_step.DownloadStep(
            constants.SYNC_STEP_PACKAGES_DOWNLOAD,
            plugin_type=ids.TYPE_ID_IMPORTER,
            description=_('Retrieving metadata: Packages files'))
        self.add_child(self.step_download_Packages)

        self.add_child(ParsePackagesStep(constants.SYNC_STEP_PACKAGES_PARSE))

        #  packages
        self.step_local_units = publish_step.GetLocalUnitsStep(
            importer_type=ids.TYPE_ID_IMPORTER)
        self.add_child(self.step_local_units)

        self.add_child(CreateRequestsUnitsToDownload(
            constants.SYNC_STEP_UNITS_DOWNLOAD_REQUESTS))

        self.step_download_units = publish_step.DownloadStep(
            constants.SYNC_STEP_UNITS_DOWNLOAD,
            plugin_type=ids.TYPE_ID_IMPORTER,
            description=_('Retrieving units'))
        self.add_child(self.step_download_units)

        self.add_child(SaveDownloadedUnits(constants.SYNC_STEP_SAVE))

        #  metadata
        self.add_child(SaveMetadataStep(constants.SYNC_STEP_SAVE_META))
Exemplo n.º 38
0
 def __init__(self, *args, **kwargs):
     super(CreateRequestsUnitsToDownload, self).__init__(*args, **kwargs)
     self.description = _('Prepare Package Download')
Exemplo n.º 39
0
 def __init__(self, *args, **kwargs):
     super(ParseReleaseStep, self).__init__(*args, **kwargs)
     self.description = _('Parse Release Files')
Exemplo n.º 40
0
 def __init__(self, *args, **kwargs):
     super(SaveDownloadedUnits, self).__init__(*args, **kwargs)
     self.description = _('Save and associate downloaded units')
Exemplo n.º 41
0
 def __str__(self):
     return _('RepoSyncConduit for repository [%(r)s]') % {
         'r': self.repo_id
     }
Exemplo n.º 42
0
 def __init__(self, *args, **kwargs):
     super(ParsePackagesStep, self).__init__(*args, **kwargs)
     self.description = _('Parse Packages Files')
Exemplo n.º 43
0
    def run(self, **kwargs):
        arg_utils.convert_removed_options(kwargs)

        importer_config = self.parse_user_input(kwargs)

        name = kwargs.pop(OPT_UPSTREAM_NAME.keyword, None)
        if name is not None:
            importer_config[constants.CONFIG_KEY_UPSTREAM_NAME] = name

        if importer_config:
            kwargs['importer_config'] = importer_config

        # Update distributor configuration
        web_config = {}
        export_config = {}
        value = kwargs.pop(OPT_PROTECTED.keyword, None)
        if value is not None:
            web_config[constants.CONFIG_KEY_PROTECTED] = value

        value = kwargs.pop(OPT_REDIRECT_URL.keyword, None)
        if value is not None:
            web_config[constants.CONFIG_KEY_REDIRECT_URL] = value
            export_config[constants.CONFIG_KEY_REDIRECT_URL] = value

        value = kwargs.pop(OPT_REPO_REGISTRY_ID.keyword, None)
        if value is not None:
            web_config[constants.CONFIG_KEY_REPO_REGISTRY_ID] = value
            export_config[constants.CONFIG_KEY_REPO_REGISTRY_ID] = value

        value = kwargs.pop(OPT_AUTO_PUBLISH.keyword, None)
        if value is not None:
            web_config['auto_publish'] = value

        if web_config or export_config:
            kwargs['distributor_configs'] = {}

        if web_config:
            kwargs['distributor_configs'][
                constants.CLI_WEB_DISTRIBUTOR_ID] = web_config

        if export_config:
            kwargs['distributor_configs'][
                constants.CLI_EXPORT_DISTRIBUTOR_ID] = export_config

        # Update Tags
        repo_id = kwargs.get(OPTION_REPO_ID.keyword)
        response = self.context.server.repo.repository(repo_id).response_body
        scratchpad = response.get(u'scratchpad', {})
        image_tags = scratchpad.get(u'tags', [])

        user_tags = kwargs.get(OPTION_TAG.keyword)
        if user_tags:
            user_tags = kwargs.pop(OPTION_TAG.keyword)
            for tag, image_id in user_tags:
                if len(image_id) < 6:
                    msg = _(
                        'The image id, (%s), must be at least 6 characters.')
                    self.prompt.render_failure_message(msg % image_id)
                    return

            # Ensure the specified images exist in the repo
            images_requested = set([image_id for tag, image_id in user_tags])
            images = ['^%s' % image_id for image_id in images_requested]
            image_regex = '|'.join(images)
            search_criteria = {
                'type_ids': constants.IMAGE_TYPE_ID,
                'match': [['image_id', image_regex]],
                'fields': ['image_id']
            }

            response = self.context.server.repo_unit.search(repo_id, **search_criteria).\
                response_body
            if len(response) != len(images):
                images_found = set(
                    [x[u'metadata'][u'image_id'] for x in response])
                missing_images = images_requested.difference(images_found)
                msg = _(
                    'Unable to create tag in repository. The following image(s) do not '
                    'exist in the repository: %s.')
                self.prompt.render_failure_message(msg %
                                                   ', '.join(missing_images))
                return

            # Get the full image id from the returned values and save in tags_to_update dictionary
            tags_to_update = {}
            for image in response:
                found_image_id = image[u'metadata'][u'image_id']
                for tag, image_id in user_tags:
                    if found_image_id.startswith(image_id):
                        tags_to_update[tag] = found_image_id

            # Create a list of tag dictionaries that can be saved on the repo scratchpad
            # using the original tags and new tags specified by the user
            image_tags = tags.generate_updated_tags(scratchpad, tags_to_update)
            scratchpad[u'tags'] = image_tags
            kwargs[u'scratchpad'] = scratchpad

        remove_tags = kwargs.get(OPTION_REMOVE_TAG.keyword)
        if remove_tags:
            kwargs.pop(OPTION_REMOVE_TAG.keyword)
            for tag in remove_tags:
                # For each tag in remove_tags, remove the respective tag dictionary
                # for matching tag.
                for image_tag in image_tags[:]:
                    if tag == image_tag[constants.IMAGE_TAG_KEY]:
                        image_tags.remove(image_tag)

            scratchpad[u'tags'] = image_tags
            kwargs[u'scratchpad'] = scratchpad

        super(UpdateDockerRepositoryCommand, self).run(**kwargs)
from gettext import gettext as _

SKILL_NAME = _("Sauce Boss")
HEADER_TITLE = _("Welcome to {}")
RECIPE_HEADER_TITLE = _("HOW TO MAKE {} SAUCE")
HELP_HEADER_TITLE = _("HELP")
HELP_HEADER_SUBTITLE = _("Select the sauce you want to prepare")
WELCOME_MESSAGE = _(
    "Welcome to {}. You can ask a question like, what's the recipe for {} sauce? ... Now, which sauce would you like to prepare?"
)
WELCOME_REPROMPT = _(
    "For instructions on what you can say, please say help me. Which sauce would you like to prepare?"
)
DISPLAY_CARD_TITLE = _("{} - Recipe for {}")
HELP_MESSAGE = _(
    "You can ask questions such as, what's the recipe for {}, or, you can say exit ... Now, which sauce would you like to prepare?"
)
HELP_REPROMPT = _(
    "You can say things like, what's the recipe for {}, or you can say ... Now, which sauce would you like to prepare?"
)
STOP_MESSAGE = _("Goodbye!")
RECIPE_REPEAT_MESSAGE = _("Try saying repeat")
RECIPE_NOT_FOUND_WITH_ITEM_NAME = _(
    "I'm sorry, I currently do not know the recipe for {}. Which sauce would you like to prepare?"
)
RECIPE_NOT_FOUND_WITHOUT_ITEM_NAME = _(
    "I'm sorry, I currently do not know that recipe. Which sauce would you like to prepare?"
)
RECIPE_NOT_FOUND_REPROMPT = _("Which sauce would you like to prepare?")
ERROR_MESSAGE = _("I'm sorry I didn't catch that. Can you reformulate please?")
HINT_TEMPLATE = _("How do I make {} sauce?")
Exemplo n.º 45
0
 def on_setup_new(self):
     launch("blueman-assistant", None, False, "blueman",
            _("Bluetooth Assistant"))
Exemplo n.º 46
0
    def load_plugin(self,
                    name: Optional[str] = None,
                    user_action: bool = False) -> None:
        if name:
            try:
                self.__load_plugin(self.__classes[name])
            except LoadException:
                pass
            except Exception:
                if user_action:
                    d = ErrorDialog(_(
                        "<b>An error has occured while loading "
                        "a plugin. Please notify the developers "
                        "with the content of this message to our </b>\n"
                        "<a href=\"http://github.com/blueman-project/blueman/issues\">website.</a>"
                    ),
                                    excp=traceback.format_exc())
                    d.run()
                    d.destroy()
                    raise

            return

        path = os.path.dirname(self.module_path.__file__)
        plugins = []
        for root, dirs, files in os.walk(path):
            for f in files:
                if f.endswith(".py") and not (f.endswith(".pyc")
                                              or f.endswith("_.py")):
                    plugins.append(f[0:-3])

        logging.info(plugins)
        for plugin in plugins:
            try:
                importlib.import_module(self.module_path.__name__ +
                                        f".{plugin}")
            except ImportError:
                logging.error(f"Unable to load plugin module {plugin}",
                              exc_info=True)
            except PluginException as err:
                logging.warning(f"Failed to start plugin {plugin}: {err}")

        for cls in self.plugin_class.__subclasses__():
            self.__classes[cls.__name__] = cls
            if cls.__name__ not in self.__deps:
                self.__deps[cls.__name__] = []

            if cls.__name__ not in self.__cfls:
                self.__cfls[cls.__name__] = []

            for c in cls.__depends__:
                if c not in self.__deps:
                    self.__deps[c] = []
                self.__deps[c].append(cls.__name__)

            for c in cls.__conflicts__:
                if c not in self.__cfls:
                    self.__cfls[c] = []
                self.__cfls[c].append(cls.__name__)
                if c not in self.__cfls[cls.__name__]:
                    self.__cfls[cls.__name__].append(c)

        cl = self.config_list
        for name, cls in self.__classes.items():
            for dep in self.__deps[name]:
                # plugins that are required by not unloadable plugins are not unloadable too
                if not self.__classes[dep].__unloadable__:
                    cls.__unloadable__ = False

            if (cls.__autoload__ or (cl and cls.__name__ in cl)) and \
                    not (cls.__unloadable__ and cl and "!" + cls.__name__ in cl):
                self.__load_plugin(cls)
Exemplo n.º 47
0
 def on_local_services(self):
     launch("blueman-services", None, False, "blueman",
            _("Service Preferences"))
Exemplo n.º 48
0
from gettext import gettext as _

from pulp.client import arg_utils, parsers
from pulp.client.commands.options import OPTION_REPO_ID
from pulp.client.commands.repo.cudl import CreateAndConfigureRepositoryCommand
from pulp.client.commands.repo.cudl import UpdateRepositoryCommand
from pulp.client.commands.repo.importer_config import ImporterConfigMixin
from pulp.common.constants import REPO_NOTE_TYPE_KEY
from pulp.client.extensions.extensions import PulpCliOption

from pulp_docker.common import constants, tags
from pulp_docker.extensions.admin import parsers as docker_parsers

d = _(
    'if "true", on each successful sync the repository will automatically be '
    'published; if "false" content will only be available after manually publishing '
    'the repository; defaults to "true"')
OPT_AUTO_PUBLISH = PulpCliOption('--auto-publish',
                                 d,
                                 required=False,
                                 parse_func=parsers.parse_boolean)

d = _(
    'The URL that will be used when generating the redirect map for connecting the docker '
    'API to the location the content is stored. '
    'The value defaults to https://<server_name_from_pulp_server.conf>/pulp/docker/<repo_name>.'
)
OPT_REDIRECT_URL = PulpCliOption('--redirect-url', d, required=False)

d = _(
    'the name that will be used for this repository in the Docker registry. If not specified, '
Exemplo n.º 49
0
 def on_devices(self):
     lockfile = get_lockfile('blueman-manager')
     pid = get_pid(lockfile)
     if not lockfile or not kill(pid, 'blueman-manager'):
         launch("blueman-manager", None, False, "blueman",
                _("Device Manager"))
Exemplo n.º 50
0
class StandardItems(AppletPlugin):
    __depends__ = ["StatusIcon", "Menu"]
    __unloadable__ = False
    __description__ = _("Adds standard menu items to the status icon menu")
    __author__ = "walmis"

    def on_load(self):
        self._plugin_window = None

        self.parent.Plugins.Menu.add(self, 21)

        self.new_dev = self.parent.Plugins.Menu.add(
            self,
            30,
            text=_("_Set Up New Device") + "…",
            icon_name="document-new",
            callback=self.on_setup_new)

        self.parent.Plugins.Menu.add(self, 31)

        self.send = self.parent.Plugins.Menu.add(
            self,
            40,
            text=_("Send _Files to Device") + "…",
            icon_name="blueman-send-file",
            callback=self.on_send)

        self.parent.Plugins.Menu.add(self, 51)

        self.devices = self.parent.Plugins.Menu.add(self,
                                                    60,
                                                    text=_("_Devices") + "…",
                                                    icon_name="blueman",
                                                    callback=self.on_devices)

        self.adapters = self.parent.Plugins.Menu.add(
            self,
            70,
            text=_("Adap_ters") + "…",
            icon_name="blueman-device",
            callback=self.on_adapters)

        self.parent.Plugins.Menu.add(self,
                                     80,
                                     text=_("_Local Services") + "…",
                                     icon_name="preferences-desktop",
                                     callback=self.on_local_services)

        self.parent.Plugins.Menu.add(self, 81)

        self.parent.Plugins.Menu.add(self,
                                     90,
                                     text="_Help",
                                     icon_name='help-about',
                                     callback=self.on_about)

        self.parent.Plugins.Menu.add(self,
                                     85,
                                     text=_("_Plugins"),
                                     icon_name="blueman-plugin",
                                     callback=self.on_plugins)

        self.parent.Plugins.StatusIcon.connect(
            "activate", lambda _status_icon: self.on_devices())

    def change_sensitivity(self, sensitive):
        if 'PowerManager' in self.parent.Plugins.get_loaded():
            power = self.parent.Plugins.PowerManager.get_bluetooth_status()
        else:
            power = True

        sensitive = sensitive and self.parent.Manager and power
        self.new_dev.set_sensitive(sensitive)
        self.send.set_sensitive(sensitive)
        self.devices.set_sensitive(sensitive)
        self.adapters.set_sensitive(sensitive)

    def on_manager_state_changed(self, state):
        self.change_sensitivity(state)

    def on_power_state_changed(self, manager, state):
        self.change_sensitivity(state)

    def on_setup_new(self):
        launch("blueman-assistant", None, False, "blueman",
               _("Bluetooth Assistant"))

    def on_send(self):
        launch("blueman-sendto", None, False, "blueman", _("File Sender"))

    def on_devices(self):
        lockfile = get_lockfile('blueman-manager')
        pid = get_pid(lockfile)
        if not lockfile or not kill(pid, 'blueman-manager'):
            launch("blueman-manager", None, False, "blueman",
                   _("Device Manager"))

    def on_adapters(self):
        launch("blueman-adapters", None, False, "blueman",
               _("Adapter Preferences"))

    def on_local_services(self):
        launch("blueman-services", None, False, "blueman",
               _("Service Preferences"))

    def on_about(self):
        about = show_about_dialog("Blueman " + _("applet"), run=False)

        im = Gtk.Image(icon_name="blueman-plugin", pixel_size=16)
        button = Gtk.Button(label=_("Plugins"), visible=True, image=im)

        button.connect("clicked", lambda _button: self.on_plugins())

        about.action_area.pack_start(button, True, True, 0)
        about.action_area.reorder_child(button, 0)

        about.run()
        about.destroy()

    def on_plugins(self):
        def on_close(win, event):
            win.destroy()
            self._plugin_window = None

        if self._plugin_window:
            self._plugin_window.present()
        else:
            self._plugin_window = PluginDialog(self.parent)
            self._plugin_window.connect("delete-event", on_close)
            self._plugin_window.show()
Exemplo n.º 51
0
 def create_palette():
     palette = Palette(_('Show my keyboard'))
     palette.set_group_id('frame')
     return palette
Exemplo n.º 52
0
 def on_adapters(self):
     launch("blueman-adapters", None, False, "blueman",
            _("Adapter Preferences"))
Exemplo n.º 53
0
 def get_page_title(self):
     return _('HSV Square')
Exemplo n.º 54
0
 def on_send(self):
     launch("blueman-sendto", None, False, "blueman", _("File Sender"))
Exemplo n.º 55
0
class StaticInterface(BaseAddressRecord, BasePTR, ExpirableMixin):
    # Keep in mind that BaseAddressRecord will have it's methods called before
    # BasePTR
    """The StaticInterface Class.

        >>> s = StaticInterface(label=label, domain=domain, ip_str=ip_str,
        ... ip_type=ip_type, dhcp_enabled=True, dns_enabled=True)
        >>> s.save()

    This class is the main interface to DNS and DHCP. A static
    interface consists of three key pieces of information: IP address, MAC
    address, and hostname (the hostname is comprised of a label and a domain).
    From these three pieces of information, three things are ensured: An A or
    AAAA DNS record, a PTR record, and a `host` statement in the DHCP builds
    that grants the MAC address of the interface the correct IP address and
    hostname.

    If you want an A/AAAA, PTR, and a DHCP lease, create one of these objects.

    In terms of DNS, a static interface represents a PTR and A record and must
    adhere to the requirements of those classes. The interface inherits from
    BaseAddressRecord.
    """

    pretty_type = 'static interface'

    id = models.AutoField(primary_key=True)
    mac = MacAddrField(dhcp_enabled='dhcp_enabled',
                       verbose_name='MAC address',
                       help_text='(required if DHCP is enabled)')
    reverse_domain = models.ForeignKey(Domain,
                                       null=True,
                                       blank=True,
                                       related_name='reverse_staticintr_set')
    system = models.ForeignKey(
        System, help_text='System to associate the interface with')

    workgroup = models.ForeignKey(Workgroup, null=True, blank=True)

    dhcp_enabled = models.BooleanField(verbose_name='Enable DHCP?',
                                       default=True)
    dns_enabled = models.BooleanField(verbose_name='Enable DNS?', default=True)

    last_seen = models.DateTimeField(null=True, blank=True)

    search_fields = ('mac', 'ip_str', 'fqdn')

    class Meta:
        app_label = 'cyder'
        db_table = 'static_interface'
        unique_together = (('ip_upper', 'ip_lower'), ('label', 'domain'))

    @staticmethod
    def filter_by_ctnr(ctnr, objects=None):
        objects = objects or StaticInterface.objects
        return objects.filter(ctnr=ctnr)

    def __unicode__(self):
        return self.fqdn

    @property
    def range(self):
        if self.ip_str:
            return find_range(self.ip_str)

    def details(self):
        data = super(StaticInterface, self).details()
        data['data'] = (
            ('Name', 'fqdn', self),
            ('System', 'system', self.system),
            ('IP', 'ip_str', str(self.ip_str)),
            ('MAC', 'mac', self.mac),
            ('Workgroup', 'workgroup', self.workgroup),
            ('DHCP', 'dhcp_enabled', 'True' if self.dhcp_enabled else 'False'),
            ('DNS', 'dns_enabled', 'True' if self.dns_enabled else 'False'),
            ('Last seen', 'last_seen', self.last_seen),
        )
        return data

    @staticmethod
    def eg_metadata():
        """EditableGrid metadata."""
        return {
            'metadata': [
                {
                    'name': 'fqdn',
                    'datatype': 'string',
                    'editable': False
                },
            ]
        }

    @property
    def rdtype(self):
        return 'INTR'

    def get_related_systems(self):
        related_interfaces = StaticInterface.objects.filter(mac=self.mac)
        related_interfaces = related_interfaces.select_related('system')
        related_systems = set()
        for interface in related_interfaces:
            related_systems.update([interface.system])
        return related_systems

    @transaction_atomic
    def save(self, *args, **kwargs):
        self.full_clean()

        update_range_usage = kwargs.pop('update_range_usage', True)
        old_range = None
        if self.id is not None:
            old_range = StaticInterface.objects.get(id=self.id).range

        super(StaticInterface, self).save(*args, **kwargs)
        self.schedule_zone_rebuild()
        if update_range_usage:
            new_range = self.range
            if new_range:
                new_range.save(commit=False)
            if old_range:
                old_range.save(commit=False)

    @transaction_atomic
    def delete(self, *args, **kwargs):
        rng = self.range
        update_range_usage = kwargs.pop('update_range_usage', True)
        delete_system = kwargs.pop('delete_system', True)

        if delete_system:
            if (not self.system.staticinterface_set.exclude(
                    id=self.id).exists()
                    and not self.system.dynamicinterface_set.exists()):
                self.system.delete(commit=False)

        super(StaticInterface, self).delete(*args, **kwargs)
        if rng and update_range_usage:
            rng.save(commit=False)

    def schedule_zone_rebuild(self):
        if self.domain.soa is not None:
            self.domain.soa.schedule_rebuild()
        if self.reverse_domain.soa is not None:
            self.reverse_domain.soa.schedule_rebuild()

    def check_A_PTR_collision(self):
        if PTR.objects.filter(ip_str=self.ip_str).exists():
            raise ValidationError("A PTR already uses '%s'" % self.ip_str)
        if AddressRecord.objects.filter(ip_str=self.ip_str,
                                        fqdn=self.fqdn).exists():
            raise ValidationError("An A record already uses '%s' and '%s'" %
                                  (self.fqdn, self.ip_str))

    def format_host_option(self, option):
        s = str(option)
        s = s.replace('%h', self.label)
        s = s.replace('%i', self.ip_str)
        s = s.replace('%m', self.mac.replace(':', ''))
        s = s.replace('%6m', self.mac.replace(':', '')[0:6])
        return s

    def build_host(self, options=None):
        build_str = '\thost {0} {{\n'.format(self.fqdn)
        build_str += '\t\thardware ethernet {0};\n'.format(self.mac)
        if self.ip_type == IP_TYPE_6:
            build_str += '\t\tfixed-address6 {0};\n'.format(self.ip_str)
        else:
            build_str += '\t\tfixed-address {0};\n'.format(self.ip_str)
        build_str += join_dhcp_args(map(self.format_host_option, options),
                                    depth=2)
        options = self.staticinterfaceav_set.filter(
            attribute__attribute_type=ATTRIBUTE_OPTION)
        statements = self.staticinterfaceav_set.filter(
            attribute__attribute_type=ATTRIBUTE_STATEMENT)
        if options:
            build_str += '\t\t# Host Options\n'
            build_str += join_dhcp_args(options, depth=2)
        if statements:
            build_str += '\t\t# Host Statements\n'
            build_str += join_dhcp_args(statements, depth=2)
        build_str += '\t}\n'
        return build_str

    def build_subclass(self, classname):
        return 'subclass "{0}" 1:{1};\n'.format(classname, self.mac)

    def clean(self, *args, **kwargs):
        validate_glue = kwargs.pop('validate_glue', True)

        super(StaticInterface, self).clean(validate_glue=False,
                                           ignore_intr=True)

        from cyder.cydns.ptr.models import PTR
        if PTR.objects.filter(ip_str=self.ip_str, fqdn=self.fqdn).exists():
            raise ValidationError("A PTR already uses '%s' and '%s'" %
                                  (self.fqdn, self.ip_str))
        if AddressRecord.objects.filter(ip_str=self.ip_str,
                                        fqdn=self.fqdn).exists():
            raise ValidationError("An A record already uses '%s' and '%s'" %
                                  (self.fqdn, self.ip_str))

        if validate_glue:
            self.check_glue_status()

        if self.dhcp_enabled:
            if not (self.range and self.range.range_type == STATIC):
                raise ValidationError('DHCP is enabled for this interface, so '
                                      'its IP must be in a static range.')

    def check_glue_status(self):
        """If this interface is a 'glue' record for a Nameserver instance,
        do not allow modifications to this record. The Nameserver will
        need to point to a different record before this record can
        be updated.
        """
        if self.pk is None:
            return
        # First get this object from the database and compare it to the
        # Nameserver object about to be saved.
        db_self = StaticInterface.objects.get(pk=self.pk)
        if db_self.label == self.label and db_self.domain == self.domain:
            return
        # The label of the domain changed. Make sure it's not a glue record.
        from cyder.cydns.nameserver.models import Nameserver
        if Nameserver.objects.filter(intr_glue=self).exists():
            raise ValidationError(
                "This Interface represents a glue record for a "
                "Nameserver. Change the Nameserver to edit this record.")

    a_template = _("{bind_name:$lhs_just} {ttl:$ttl_just}  "
                   "{rdclass:$rdclass_just}"
                   " {rdtype_clob:$rdtype_just} {ip_str:$rhs_just}")
    ptr_template = _("{dns_ip:$lhs_just} {ttl:$ttl_just}  "
                     "{rdclass:$rdclass_just}"
                     " {rdtype_clob:$rdtype_just} {fqdn:1}.")

    def bind_render_record(self, pk=False, **kwargs):
        self.rdtype_clob = kwargs.pop('rdtype', 'INTR')
        if kwargs.pop('reverse', False):
            self.template = self.ptr_template
            self.dns_ip = ip_to_reverse_name(self.ip_str) + '.'
        else:
            self.template = self.a_template
        return super(StaticInterface, self).bind_render_record(pk=pk, **kwargs)
Exemplo n.º 56
0
 def get_page_description(self):
     return _("An HSV Square which can be rotated to show different hues.")
Exemplo n.º 57
0
 def get_name(cls):
     return _(u"Freehand Drawing")
Exemplo n.º 58
0
 def _update_tooltips(self):
     self.__ring.set_tooltip_text(_("HSV Hue"))
     self.__square.set_tooltip_text(_("HSV Saturation and Value"))
Exemplo n.º 59
0
 def convert_to_unit(self, px, unit):
     if unit == _('px'):
         return px
     return px * UnitAdjustment.CONVERT_UNITS[unit][0] / self.dpi
Exemplo n.º 60
0
 def get_usage(self):
     return _(u"Paint free-form brush strokes")