_id
stringlengths
2
7
title
stringlengths
1
88
partition
stringclasses
3 values
text
stringlengths
75
19.8k
language
stringclasses
1 value
meta_information
dict
q280200
QtAnsiCodeProcessor.get_format
test
def get_format(self): """ Returns a QTextCharFormat that encodes the current style attributes. """ format = QtGui.QTextCharFormat() # Set foreground color qcolor = self.get_color(self.foreground_color, self.intensity) if qcolor is not None: format.setForeground(qcolor) # Set background color qcolor = self.get_color(self.background_color, self.intensity) if qcolor is not None: format.setBackground(qcolor) # Set font weight/style options if self.bold: format.setFontWeight(QtGui.QFont.Bold) else: format.setFontWeight(QtGui.QFont.Normal) format.setFontItalic(self.italic) format.setFontUnderline(self.underline) return format
python
{ "resource": "" }
q280201
generate
test
def generate(secret, age, **payload): """Generate a one-time jwt with an age in seconds""" jti = str(uuid.uuid1()) # random id if not payload: payload = {} payload['exp'] = int(time.time() + age) payload['jti'] = jti return jwt.encode(payload, decode_secret(secret))
python
{ "resource": "" }
q280202
mutex
test
def mutex(func): """use a thread lock on current method, if self.lock is defined""" def wrapper(*args, **kwargs): """Decorator Wrapper""" lock = args[0].lock lock.acquire(True) try: return func(*args, **kwargs) except: raise finally: lock.release() return wrapper
python
{ "resource": "" }
q280203
Manager._clean
test
def _clean(self): """Run by housekeeper thread""" now = time.time() for jwt in self.jwts.keys(): if (now - self.jwts[jwt]) > (self.age * 2): del self.jwts[jwt]
python
{ "resource": "" }
q280204
Manager.already_used
test
def already_used(self, tok): """has this jwt been used?""" if tok in self.jwts: return True self.jwts[tok] = time.time() return False
python
{ "resource": "" }
q280205
Manager.valid
test
def valid(self, token): """is this token valid?""" now = time.time() if 'Bearer ' in token: token = token[7:] data = None for secret in self.secrets: try: data = jwt.decode(token, secret) break except jwt.DecodeError: continue except jwt.ExpiredSignatureError: raise JwtFailed("Jwt expired") if not data: raise JwtFailed("Jwt cannot be decoded") exp = data.get('exp') if not exp: raise JwtFailed("Jwt missing expiration (exp)") if now - exp > self.age: raise JwtFailed("Jwt bad expiration - greater than I want to accept") jti = data.get('jti') if not jti: raise JwtFailed("Jwt missing one-time id (jti)") if self.already_used(jti): raise JwtFailed("Jwt re-use disallowed (jti={})".format(jti)) return data
python
{ "resource": "" }
q280206
semaphore
test
def semaphore(count: int, bounded: bool=False): ''' use `Semaphore` to keep func access thread-safety. example: ``` py @semaphore(3) def func(): pass ``` ''' lock_type = threading.BoundedSemaphore if bounded else threading.Semaphore lock_obj = lock_type(value=count) return with_it(lock_obj)
python
{ "resource": "" }
q280207
commonprefix
test
def commonprefix(items): """Get common prefix for completions Return the longest common prefix of a list of strings, but with special treatment of escape characters that might precede commands in IPython, such as %magic functions. Used in tab completion. For a more general function, see os.path.commonprefix """ # the last item will always have the least leading % symbol # min / max are first/last in alphabetical order first_match = ESCAPE_RE.match(min(items)) last_match = ESCAPE_RE.match(max(items)) # common suffix is (common prefix of reversed items) reversed if first_match and last_match: prefix = os.path.commonprefix((first_match.group(0)[::-1], last_match.group(0)[::-1]))[::-1] else: prefix = '' items = [s.lstrip(ESCAPE_CHARS) for s in items] return prefix+os.path.commonprefix(items)
python
{ "resource": "" }
q280208
ConsoleWidget.eventFilter
test
def eventFilter(self, obj, event): """ Reimplemented to ensure a console-like behavior in the underlying text widgets. """ etype = event.type() if etype == QtCore.QEvent.KeyPress: # Re-map keys for all filtered widgets. key = event.key() if self._control_key_down(event.modifiers()) and \ key in self._ctrl_down_remap: new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, self._ctrl_down_remap[key], QtCore.Qt.NoModifier) QtGui.qApp.sendEvent(obj, new_event) return True elif obj == self._control: return self._event_filter_console_keypress(event) elif obj == self._page_control: return self._event_filter_page_keypress(event) # Make middle-click paste safe. elif etype == QtCore.QEvent.MouseButtonRelease and \ event.button() == QtCore.Qt.MidButton and \ obj == self._control.viewport(): cursor = self._control.cursorForPosition(event.pos()) self._control.setTextCursor(cursor) self.paste(QtGui.QClipboard.Selection) return True # Manually adjust the scrollbars *after* a resize event is dispatched. elif etype == QtCore.QEvent.Resize and not self._filter_resize: self._filter_resize = True QtGui.qApp.sendEvent(obj, event) self._adjust_scrollbars() self._filter_resize = False return True # Override shortcuts for all filtered widgets. elif etype == QtCore.QEvent.ShortcutOverride and \ self.override_shortcuts and \ self._control_key_down(event.modifiers()) and \ event.key() in self._shortcuts: event.accept() # Ensure that drags are safe. The problem is that the drag starting # logic, which determines whether the drag is a Copy or Move, is locked # down in QTextControl. If the widget is editable, which it must be if # we're not executing, the drag will be a Move. The following hack # prevents QTextControl from deleting the text by clearing the selection # when a drag leave event originating from this widget is dispatched. # The fact that we have to clear the user's selection is unfortunate, # but the alternative--trying to prevent Qt from using its hardwired # drag logic and writing our own--is worse. elif etype == QtCore.QEvent.DragEnter and \ obj == self._control.viewport() and \ event.source() == self._control.viewport(): self._filter_drag = True elif etype == QtCore.QEvent.DragLeave and \ obj == self._control.viewport() and \ self._filter_drag: cursor = self._control.textCursor() cursor.clearSelection() self._control.setTextCursor(cursor) self._filter_drag = False # Ensure that drops are safe. elif etype == QtCore.QEvent.Drop and obj == self._control.viewport(): cursor = self._control.cursorForPosition(event.pos()) if self._in_buffer(cursor.position()): text = event.mimeData().text() self._insert_plain_text_into_buffer(cursor, text) # Qt is expecting to get something here--drag and drop occurs in its # own event loop. Send a DragLeave event to end it. QtGui.qApp.sendEvent(obj, QtGui.QDragLeaveEvent()) return True # Handle scrolling of the vsplit pager. This hack attempts to solve # problems with tearing of the help text inside the pager window. This # happens only on Mac OS X with both PySide and PyQt. This fix isn't # perfect but makes the pager more usable. elif etype in self._pager_scroll_events and \ obj == self._page_control: self._page_control.repaint() return True return super(ConsoleWidget, self).eventFilter(obj, event)
python
{ "resource": "" }
q280209
ConsoleWidget.sizeHint
test
def sizeHint(self): """ Reimplemented to suggest a size that is 80 characters wide and 25 lines high. """ font_metrics = QtGui.QFontMetrics(self.font) margin = (self._control.frameWidth() + self._control.document().documentMargin()) * 2 style = self.style() splitwidth = style.pixelMetric(QtGui.QStyle.PM_SplitterWidth) # Note 1: Despite my best efforts to take the various margins into # account, the width is still coming out a bit too small, so we include # a fudge factor of one character here. # Note 2: QFontMetrics.maxWidth is not used here or anywhere else due # to a Qt bug on certain Mac OS systems where it returns 0. width = font_metrics.width(' ') * 81 + margin width += style.pixelMetric(QtGui.QStyle.PM_ScrollBarExtent) if self.paging == 'hsplit': width = width * 2 + splitwidth height = font_metrics.height() * 25 + margin if self.paging == 'vsplit': height = height * 2 + splitwidth return QtCore.QSize(width, height)
python
{ "resource": "" }
q280210
ConsoleWidget.can_cut
test
def can_cut(self): """ Returns whether text can be cut to the clipboard. """ cursor = self._control.textCursor() return (cursor.hasSelection() and self._in_buffer(cursor.anchor()) and self._in_buffer(cursor.position()))
python
{ "resource": "" }
q280211
ConsoleWidget.can_paste
test
def can_paste(self): """ Returns whether text can be pasted from the clipboard. """ if self._control.textInteractionFlags() & QtCore.Qt.TextEditable: return bool(QtGui.QApplication.clipboard().text()) return False
python
{ "resource": "" }
q280212
ConsoleWidget.clear
test
def clear(self, keep_input=True): """ Clear the console. Parameters: ----------- keep_input : bool, optional (default True) If set, restores the old input buffer if a new prompt is written. """ if self._executing: self._control.clear() else: if keep_input: input_buffer = self.input_buffer self._control.clear() self._show_prompt() if keep_input: self.input_buffer = input_buffer
python
{ "resource": "" }
q280213
ConsoleWidget.cut
test
def cut(self): """ Copy the currently selected text to the clipboard and delete it if it's inside the input buffer. """ self.copy() if self.can_cut(): self._control.textCursor().removeSelectedText()
python
{ "resource": "" }
q280214
ConsoleWidget.execute
test
def execute(self, source=None, hidden=False, interactive=False): """ Executes source or the input buffer, possibly prompting for more input. Parameters: ----------- source : str, optional The source to execute. If not specified, the input buffer will be used. If specified and 'hidden' is False, the input buffer will be replaced with the source before execution. hidden : bool, optional (default False) If set, no output will be shown and the prompt will not be modified. In other words, it will be completely invisible to the user that an execution has occurred. interactive : bool, optional (default False) Whether the console is to treat the source as having been manually entered by the user. The effect of this parameter depends on the subclass implementation. Raises: ------- RuntimeError If incomplete input is given and 'hidden' is True. In this case, it is not possible to prompt for more input. Returns: -------- A boolean indicating whether the source was executed. """ # WARNING: The order in which things happen here is very particular, in # large part because our syntax highlighting is fragile. If you change # something, test carefully! # Decide what to execute. if source is None: source = self.input_buffer if not hidden: # A newline is appended later, but it should be considered part # of the input buffer. source += '\n' elif not hidden: self.input_buffer = source # Execute the source or show a continuation prompt if it is incomplete. complete = self._is_complete(source, interactive) if hidden: if complete: self._execute(source, hidden) else: error = 'Incomplete noninteractive input: "%s"' raise RuntimeError(error % source) else: if complete: self._append_plain_text('\n') self._input_buffer_executing = self.input_buffer self._executing = True self._prompt_finished() # The maximum block count is only in effect during execution. # This ensures that _prompt_pos does not become invalid due to # text truncation. self._control.document().setMaximumBlockCount(self.buffer_size) # Setting a positive maximum block count will automatically # disable the undo/redo history, but just to be safe: self._control.setUndoRedoEnabled(False) # Perform actual execution. self._execute(source, hidden) else: # Do this inside an edit block so continuation prompts are # removed seamlessly via undo/redo. cursor = self._get_end_cursor() cursor.beginEditBlock() cursor.insertText('\n') self._insert_continuation_prompt(cursor) cursor.endEditBlock() # Do not do this inside the edit block. It works as expected # when using a QPlainTextEdit control, but does not have an # effect when using a QTextEdit. I believe this is a Qt bug. self._control.moveCursor(QtGui.QTextCursor.End) return complete
python
{ "resource": "" }
q280215
ConsoleWidget._get_input_buffer
test
def _get_input_buffer(self, force=False): """ The text that the user has entered entered at the current prompt. If the console is currently executing, the text that is executing will always be returned. """ # If we're executing, the input buffer may not even exist anymore due to # the limit imposed by 'buffer_size'. Therefore, we store it. if self._executing and not force: return self._input_buffer_executing cursor = self._get_end_cursor() cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor) input_buffer = cursor.selection().toPlainText() # Strip out continuation prompts. return input_buffer.replace('\n' + self._continuation_prompt, '\n')
python
{ "resource": "" }
q280216
ConsoleWidget._set_input_buffer
test
def _set_input_buffer(self, string): """ Sets the text in the input buffer. If the console is currently executing, this call has no *immediate* effect. When the execution is finished, the input buffer will be updated appropriately. """ # If we're executing, store the text for later. if self._executing: self._input_buffer_pending = string return # Remove old text. cursor = self._get_end_cursor() cursor.beginEditBlock() cursor.setPosition(self._prompt_pos, QtGui.QTextCursor.KeepAnchor) cursor.removeSelectedText() # Insert new text with continuation prompts. self._insert_plain_text_into_buffer(self._get_prompt_cursor(), string) cursor.endEditBlock() self._control.moveCursor(QtGui.QTextCursor.End)
python
{ "resource": "" }
q280217
ConsoleWidget._set_font
test
def _set_font(self, font): """ Sets the base font for the ConsoleWidget to the specified QFont. """ font_metrics = QtGui.QFontMetrics(font) self._control.setTabStopWidth(self.tab_width * font_metrics.width(' ')) self._completion_widget.setFont(font) self._control.document().setDefaultFont(font) if self._page_control: self._page_control.document().setDefaultFont(font) self.font_changed.emit(font)
python
{ "resource": "" }
q280218
ConsoleWidget.paste
test
def paste(self, mode=QtGui.QClipboard.Clipboard): """ Paste the contents of the clipboard into the input region. Parameters: ----------- mode : QClipboard::Mode, optional [default QClipboard::Clipboard] Controls which part of the system clipboard is used. This can be used to access the selection clipboard in X11 and the Find buffer in Mac OS. By default, the regular clipboard is used. """ if self._control.textInteractionFlags() & QtCore.Qt.TextEditable: # Make sure the paste is safe. self._keep_cursor_in_buffer() cursor = self._control.textCursor() # Remove any trailing newline, which confuses the GUI and forces the # user to backspace. text = QtGui.QApplication.clipboard().text(mode).rstrip() self._insert_plain_text_into_buffer(cursor, dedent(text))
python
{ "resource": "" }
q280219
ConsoleWidget.print_
test
def print_(self, printer = None): """ Print the contents of the ConsoleWidget to the specified QPrinter. """ if (not printer): printer = QtGui.QPrinter() if(QtGui.QPrintDialog(printer).exec_() != QtGui.QDialog.Accepted): return self._control.print_(printer)
python
{ "resource": "" }
q280220
ConsoleWidget.prompt_to_top
test
def prompt_to_top(self): """ Moves the prompt to the top of the viewport. """ if not self._executing: prompt_cursor = self._get_prompt_cursor() if self._get_cursor().blockNumber() < prompt_cursor.blockNumber(): self._set_cursor(prompt_cursor) self._set_top_cursor(prompt_cursor)
python
{ "resource": "" }
q280221
ConsoleWidget.reset_font
test
def reset_font(self): """ Sets the font to the default fixed-width font for this platform. """ if sys.platform == 'win32': # Consolas ships with Vista/Win7, fallback to Courier if needed fallback = 'Courier' elif sys.platform == 'darwin': # OSX always has Monaco fallback = 'Monaco' else: # Monospace should always exist fallback = 'Monospace' font = get_font(self.font_family, fallback) if self.font_size: font.setPointSize(self.font_size) else: font.setPointSize(QtGui.qApp.font().pointSize()) font.setStyleHint(QtGui.QFont.TypeWriter) self._set_font(font)
python
{ "resource": "" }
q280222
ConsoleWidget._append_custom
test
def _append_custom(self, insert, input, before_prompt=False): """ A low-level method for appending content to the end of the buffer. If 'before_prompt' is enabled, the content will be inserted before the current prompt, if there is one. """ # Determine where to insert the content. cursor = self._control.textCursor() if before_prompt and (self._reading or not self._executing): cursor.setPosition(self._append_before_prompt_pos) else: cursor.movePosition(QtGui.QTextCursor.End) start_pos = cursor.position() # Perform the insertion. result = insert(cursor, input) # Adjust the prompt position if we have inserted before it. This is safe # because buffer truncation is disabled when not executing. if before_prompt and not self._executing: diff = cursor.position() - start_pos self._append_before_prompt_pos += diff self._prompt_pos += diff return result
python
{ "resource": "" }
q280223
ConsoleWidget._append_html
test
def _append_html(self, html, before_prompt=False): """ Appends HTML at the end of the console buffer. """ self._append_custom(self._insert_html, html, before_prompt)
python
{ "resource": "" }
q280224
ConsoleWidget._append_html_fetching_plain_text
test
def _append_html_fetching_plain_text(self, html, before_prompt=False): """ Appends HTML, then returns the plain text version of it. """ return self._append_custom(self._insert_html_fetching_plain_text, html, before_prompt)
python
{ "resource": "" }
q280225
ConsoleWidget._append_plain_text
test
def _append_plain_text(self, text, before_prompt=False): """ Appends plain text, processing ANSI codes if enabled. """ self._append_custom(self._insert_plain_text, text, before_prompt)
python
{ "resource": "" }
q280226
ConsoleWidget._clear_temporary_buffer
test
def _clear_temporary_buffer(self): """ Clears the "temporary text" buffer, i.e. all the text following the prompt region. """ # Select and remove all text below the input buffer. cursor = self._get_prompt_cursor() prompt = self._continuation_prompt.lstrip() if(self._temp_buffer_filled): self._temp_buffer_filled = False while cursor.movePosition(QtGui.QTextCursor.NextBlock): temp_cursor = QtGui.QTextCursor(cursor) temp_cursor.select(QtGui.QTextCursor.BlockUnderCursor) text = temp_cursor.selection().toPlainText().lstrip() if not text.startswith(prompt): break else: # We've reached the end of the input buffer and no text follows. return cursor.movePosition(QtGui.QTextCursor.Left) # Grab the newline. cursor.movePosition(QtGui.QTextCursor.End, QtGui.QTextCursor.KeepAnchor) cursor.removeSelectedText() # After doing this, we have no choice but to clear the undo/redo # history. Otherwise, the text is not "temporary" at all, because it # can be recalled with undo/redo. Unfortunately, Qt does not expose # fine-grained control to the undo/redo system. if self._control.isUndoRedoEnabled(): self._control.setUndoRedoEnabled(False) self._control.setUndoRedoEnabled(True)
python
{ "resource": "" }
q280227
ConsoleWidget._complete_with_items
test
def _complete_with_items(self, cursor, items): """ Performs completion with 'items' at the specified cursor location. """ self._cancel_completion() if len(items) == 1: cursor.setPosition(self._control.textCursor().position(), QtGui.QTextCursor.KeepAnchor) cursor.insertText(items[0]) elif len(items) > 1: current_pos = self._control.textCursor().position() prefix = commonprefix(items) if prefix: cursor.setPosition(current_pos, QtGui.QTextCursor.KeepAnchor) cursor.insertText(prefix) current_pos = cursor.position() cursor.movePosition(QtGui.QTextCursor.Left, n=len(prefix)) self._completion_widget.show_items(cursor, items)
python
{ "resource": "" }
q280228
ConsoleWidget._fill_temporary_buffer
test
def _fill_temporary_buffer(self, cursor, text, html=False): """fill the area below the active editting zone with text""" current_pos = self._control.textCursor().position() cursor.beginEditBlock() self._append_plain_text('\n') self._page(text, html=html) cursor.endEditBlock() cursor.setPosition(current_pos) self._control.moveCursor(QtGui.QTextCursor.End) self._control.setTextCursor(cursor) self._temp_buffer_filled = True
python
{ "resource": "" }
q280229
ConsoleWidget._control_key_down
test
def _control_key_down(self, modifiers, include_command=False): """ Given a KeyboardModifiers flags object, return whether the Control key is down. Parameters: ----------- include_command : bool, optional (default True) Whether to treat the Command key as a (mutually exclusive) synonym for Control when in Mac OS. """ # Note that on Mac OS, ControlModifier corresponds to the Command key # while MetaModifier corresponds to the Control key. if sys.platform == 'darwin': down = include_command and (modifiers & QtCore.Qt.ControlModifier) return bool(down) ^ bool(modifiers & QtCore.Qt.MetaModifier) else: return bool(modifiers & QtCore.Qt.ControlModifier)
python
{ "resource": "" }
q280230
ConsoleWidget._create_control
test
def _create_control(self): """ Creates and connects the underlying text widget. """ # Create the underlying control. if self.custom_control: control = self.custom_control() elif self.kind == 'plain': control = QtGui.QPlainTextEdit() elif self.kind == 'rich': control = QtGui.QTextEdit() control.setAcceptRichText(False) # Install event filters. The filter on the viewport is needed for # mouse events and drag events. control.installEventFilter(self) control.viewport().installEventFilter(self) # Connect signals. control.customContextMenuRequested.connect( self._custom_context_menu_requested) control.copyAvailable.connect(self.copy_available) control.redoAvailable.connect(self.redo_available) control.undoAvailable.connect(self.undo_available) # Hijack the document size change signal to prevent Qt from adjusting # the viewport's scrollbar. We are relying on an implementation detail # of Q(Plain)TextEdit here, which is potentially dangerous, but without # this functionality we cannot create a nice terminal interface. layout = control.document().documentLayout() layout.documentSizeChanged.disconnect() layout.documentSizeChanged.connect(self._adjust_scrollbars) # Configure the control. control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True) control.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) control.setReadOnly(True) control.setUndoRedoEnabled(False) control.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn) return control
python
{ "resource": "" }
q280231
ConsoleWidget._create_page_control
test
def _create_page_control(self): """ Creates and connects the underlying paging widget. """ if self.custom_page_control: control = self.custom_page_control() elif self.kind == 'plain': control = QtGui.QPlainTextEdit() elif self.kind == 'rich': control = QtGui.QTextEdit() control.installEventFilter(self) viewport = control.viewport() viewport.installEventFilter(self) control.setReadOnly(True) control.setUndoRedoEnabled(False) control.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn) return control
python
{ "resource": "" }
q280232
ConsoleWidget._event_filter_page_keypress
test
def _event_filter_page_keypress(self, event): """ Filter key events for the paging widget to create console-like interface. """ key = event.key() ctrl_down = self._control_key_down(event.modifiers()) alt_down = event.modifiers() & QtCore.Qt.AltModifier if ctrl_down: if key == QtCore.Qt.Key_O: self._control.setFocus() intercept = True elif alt_down: if key == QtCore.Qt.Key_Greater: self._page_control.moveCursor(QtGui.QTextCursor.End) intercepted = True elif key == QtCore.Qt.Key_Less: self._page_control.moveCursor(QtGui.QTextCursor.Start) intercepted = True elif key in (QtCore.Qt.Key_Q, QtCore.Qt.Key_Escape): if self._splitter: self._page_control.hide() self._control.setFocus() else: self.layout().setCurrentWidget(self._control) return True elif key in (QtCore.Qt.Key_Enter, QtCore.Qt.Key_Return, QtCore.Qt.Key_Tab): new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_PageDown, QtCore.Qt.NoModifier) QtGui.qApp.sendEvent(self._page_control, new_event) return True elif key == QtCore.Qt.Key_Backspace: new_event = QtGui.QKeyEvent(QtCore.QEvent.KeyPress, QtCore.Qt.Key_PageUp, QtCore.Qt.NoModifier) QtGui.qApp.sendEvent(self._page_control, new_event) return True return False
python
{ "resource": "" }
q280233
ConsoleWidget._get_block_plain_text
test
def _get_block_plain_text(self, block): """ Given a QTextBlock, return its unformatted text. """ cursor = QtGui.QTextCursor(block) cursor.movePosition(QtGui.QTextCursor.StartOfBlock) cursor.movePosition(QtGui.QTextCursor.EndOfBlock, QtGui.QTextCursor.KeepAnchor) return cursor.selection().toPlainText()
python
{ "resource": "" }
q280234
ConsoleWidget._get_end_cursor
test
def _get_end_cursor(self): """ Convenience method that returns a cursor for the last character. """ cursor = self._control.textCursor() cursor.movePosition(QtGui.QTextCursor.End) return cursor
python
{ "resource": "" }
q280235
ConsoleWidget._get_input_buffer_cursor_column
test
def _get_input_buffer_cursor_column(self): """ Returns the column of the cursor in the input buffer, excluding the contribution by the prompt, or -1 if there is no such column. """ prompt = self._get_input_buffer_cursor_prompt() if prompt is None: return -1 else: cursor = self._control.textCursor() return cursor.columnNumber() - len(prompt)
python
{ "resource": "" }
q280236
ConsoleWidget._get_input_buffer_cursor_line
test
def _get_input_buffer_cursor_line(self): """ Returns the text of the line of the input buffer that contains the cursor, or None if there is no such line. """ prompt = self._get_input_buffer_cursor_prompt() if prompt is None: return None else: cursor = self._control.textCursor() text = self._get_block_plain_text(cursor.block()) return text[len(prompt):]
python
{ "resource": "" }
q280237
ConsoleWidget._get_prompt_cursor
test
def _get_prompt_cursor(self): """ Convenience method that returns a cursor for the prompt position. """ cursor = self._control.textCursor() cursor.setPosition(self._prompt_pos) return cursor
python
{ "resource": "" }
q280238
ConsoleWidget._get_selection_cursor
test
def _get_selection_cursor(self, start, end): """ Convenience method that returns a cursor with text selected between the positions 'start' and 'end'. """ cursor = self._control.textCursor() cursor.setPosition(start) cursor.setPosition(end, QtGui.QTextCursor.KeepAnchor) return cursor
python
{ "resource": "" }
q280239
ConsoleWidget._insert_continuation_prompt
test
def _insert_continuation_prompt(self, cursor): """ Inserts new continuation prompt using the specified cursor. """ if self._continuation_prompt_html is None: self._insert_plain_text(cursor, self._continuation_prompt) else: self._continuation_prompt = self._insert_html_fetching_plain_text( cursor, self._continuation_prompt_html)
python
{ "resource": "" }
q280240
ConsoleWidget._insert_html
test
def _insert_html(self, cursor, html): """ Inserts HTML using the specified cursor in such a way that future formatting is unaffected. """ cursor.beginEditBlock() cursor.insertHtml(html) # After inserting HTML, the text document "remembers" it's in "html # mode", which means that subsequent calls adding plain text will result # in unwanted formatting, lost tab characters, etc. The following code # hacks around this behavior, which I consider to be a bug in Qt, by # (crudely) resetting the document's style state. cursor.movePosition(QtGui.QTextCursor.Left, QtGui.QTextCursor.KeepAnchor) if cursor.selection().toPlainText() == ' ': cursor.removeSelectedText() else: cursor.movePosition(QtGui.QTextCursor.Right) cursor.insertText(' ', QtGui.QTextCharFormat()) cursor.endEditBlock()
python
{ "resource": "" }
q280241
ConsoleWidget._insert_html_fetching_plain_text
test
def _insert_html_fetching_plain_text(self, cursor, html): """ Inserts HTML using the specified cursor, then returns its plain text version. """ cursor.beginEditBlock() cursor.removeSelectedText() start = cursor.position() self._insert_html(cursor, html) end = cursor.position() cursor.setPosition(start, QtGui.QTextCursor.KeepAnchor) text = cursor.selection().toPlainText() cursor.setPosition(end) cursor.endEditBlock() return text
python
{ "resource": "" }
q280242
ConsoleWidget._insert_plain_text
test
def _insert_plain_text(self, cursor, text): """ Inserts plain text using the specified cursor, processing ANSI codes if enabled. """ cursor.beginEditBlock() if self.ansi_codes: for substring in self._ansi_processor.split_string(text): for act in self._ansi_processor.actions: # Unlike real terminal emulators, we don't distinguish # between the screen and the scrollback buffer. A screen # erase request clears everything. if act.action == 'erase' and act.area == 'screen': cursor.select(QtGui.QTextCursor.Document) cursor.removeSelectedText() # Simulate a form feed by scrolling just past the last line. elif act.action == 'scroll' and act.unit == 'page': cursor.insertText('\n') cursor.endEditBlock() self._set_top_cursor(cursor) cursor.joinPreviousEditBlock() cursor.deletePreviousChar() elif act.action == 'carriage-return': cursor.movePosition( cursor.StartOfLine, cursor.KeepAnchor) elif act.action == 'beep': QtGui.qApp.beep() elif act.action == 'backspace': if not cursor.atBlockStart(): cursor.movePosition( cursor.PreviousCharacter, cursor.KeepAnchor) elif act.action == 'newline': cursor.movePosition(cursor.EndOfLine) format = self._ansi_processor.get_format() selection = cursor.selectedText() if len(selection) == 0: cursor.insertText(substring, format) elif substring is not None: # BS and CR are treated as a change in print # position, rather than a backwards character # deletion for output equivalence with (I)Python # terminal. if len(substring) >= len(selection): cursor.insertText(substring, format) else: old_text = selection[len(substring):] cursor.insertText(substring + old_text, format) cursor.movePosition(cursor.PreviousCharacter, cursor.KeepAnchor, len(old_text)) else: cursor.insertText(text) cursor.endEditBlock()
python
{ "resource": "" }
q280243
ConsoleWidget._keep_cursor_in_buffer
test
def _keep_cursor_in_buffer(self): """ Ensures that the cursor is inside the editing region. Returns whether the cursor was moved. """ moved = not self._in_buffer() if moved: cursor = self._control.textCursor() cursor.movePosition(QtGui.QTextCursor.End) self._control.setTextCursor(cursor) return moved
python
{ "resource": "" }
q280244
ConsoleWidget._keyboard_quit
test
def _keyboard_quit(self): """ Cancels the current editing task ala Ctrl-G in Emacs. """ if self._temp_buffer_filled : self._cancel_completion() self._clear_temporary_buffer() else: self.input_buffer = ''
python
{ "resource": "" }
q280245
ConsoleWidget._page
test
def _page(self, text, html=False): """ Displays text using the pager if it exceeds the height of the viewport. Parameters: ----------- html : bool, optional (default False) If set, the text will be interpreted as HTML instead of plain text. """ line_height = QtGui.QFontMetrics(self.font).height() minlines = self._control.viewport().height() / line_height if self.paging != 'none' and \ re.match("(?:[^\n]*\n){%i}" % minlines, text): if self.paging == 'custom': self.custom_page_requested.emit(text) else: self._page_control.clear() cursor = self._page_control.textCursor() if html: self._insert_html(cursor, text) else: self._insert_plain_text(cursor, text) self._page_control.moveCursor(QtGui.QTextCursor.Start) self._page_control.viewport().resize(self._control.size()) if self._splitter: self._page_control.show() self._page_control.setFocus() else: self.layout().setCurrentWidget(self._page_control) elif html: self._append_html(text) else: self._append_plain_text(text)
python
{ "resource": "" }
q280246
ConsoleWidget._prompt_started
test
def _prompt_started(self): """ Called immediately after a new prompt is displayed. """ # Temporarily disable the maximum block count to permit undo/redo and # to ensure that the prompt position does not change due to truncation. self._control.document().setMaximumBlockCount(0) self._control.setUndoRedoEnabled(True) # Work around bug in QPlainTextEdit: input method is not re-enabled # when read-only is disabled. self._control.setReadOnly(False) self._control.setAttribute(QtCore.Qt.WA_InputMethodEnabled, True) if not self._reading: self._executing = False self._prompt_started_hook() # If the input buffer has changed while executing, load it. if self._input_buffer_pending: self.input_buffer = self._input_buffer_pending self._input_buffer_pending = '' self._control.moveCursor(QtGui.QTextCursor.End)
python
{ "resource": "" }
q280247
ConsoleWidget._readline
test
def _readline(self, prompt='', callback=None): """ Reads one line of input from the user. Parameters ---------- prompt : str, optional The prompt to print before reading the line. callback : callable, optional A callback to execute with the read line. If not specified, input is read *synchronously* and this method does not return until it has been read. Returns ------- If a callback is specified, returns nothing. Otherwise, returns the input string with the trailing newline stripped. """ if self._reading: raise RuntimeError('Cannot read a line. Widget is already reading.') if not callback and not self.isVisible(): # If the user cannot see the widget, this function cannot return. raise RuntimeError('Cannot synchronously read a line if the widget ' 'is not visible!') self._reading = True self._show_prompt(prompt, newline=False) if callback is None: self._reading_callback = None while self._reading: QtCore.QCoreApplication.processEvents() return self._get_input_buffer(force=True).rstrip('\n') else: self._reading_callback = lambda: \ callback(self._get_input_buffer(force=True).rstrip('\n'))
python
{ "resource": "" }
q280248
ConsoleWidget._set_continuation_prompt
test
def _set_continuation_prompt(self, prompt, html=False): """ Sets the continuation prompt. Parameters ---------- prompt : str The prompt to show when more input is needed. html : bool, optional (default False) If set, the prompt will be inserted as formatted HTML. Otherwise, the prompt will be treated as plain text, though ANSI color codes will be handled. """ if html: self._continuation_prompt_html = prompt else: self._continuation_prompt = prompt self._continuation_prompt_html = None
python
{ "resource": "" }
q280249
ConsoleWidget._set_top_cursor
test
def _set_top_cursor(self, cursor): """ Scrolls the viewport so that the specified cursor is at the top. """ scrollbar = self._control.verticalScrollBar() scrollbar.setValue(scrollbar.maximum()) original_cursor = self._control.textCursor() self._control.setTextCursor(cursor) self._control.ensureCursorVisible() self._control.setTextCursor(original_cursor)
python
{ "resource": "" }
q280250
ConsoleWidget._show_prompt
test
def _show_prompt(self, prompt=None, html=False, newline=True): """ Writes a new prompt at the end of the buffer. Parameters ---------- prompt : str, optional The prompt to show. If not specified, the previous prompt is used. html : bool, optional (default False) Only relevant when a prompt is specified. If set, the prompt will be inserted as formatted HTML. Otherwise, the prompt will be treated as plain text, though ANSI color codes will be handled. newline : bool, optional (default True) If set, a new line will be written before showing the prompt if there is not already a newline at the end of the buffer. """ # Save the current end position to support _append*(before_prompt=True). cursor = self._get_end_cursor() self._append_before_prompt_pos = cursor.position() # Insert a preliminary newline, if necessary. if newline and cursor.position() > 0: cursor.movePosition(QtGui.QTextCursor.Left, QtGui.QTextCursor.KeepAnchor) if cursor.selection().toPlainText() != '\n': self._append_plain_text('\n') # Write the prompt. self._append_plain_text(self._prompt_sep) if prompt is None: if self._prompt_html is None: self._append_plain_text(self._prompt) else: self._append_html(self._prompt_html) else: if html: self._prompt = self._append_html_fetching_plain_text(prompt) self._prompt_html = prompt else: self._append_plain_text(prompt) self._prompt = prompt self._prompt_html = None self._prompt_pos = self._get_end_cursor().position() self._prompt_started()
python
{ "resource": "" }
q280251
ConsoleWidget._adjust_scrollbars
test
def _adjust_scrollbars(self): """ Expands the vertical scrollbar beyond the range set by Qt. """ # This code is adapted from _q_adjustScrollbars in qplaintextedit.cpp # and qtextedit.cpp. document = self._control.document() scrollbar = self._control.verticalScrollBar() viewport_height = self._control.viewport().height() if isinstance(self._control, QtGui.QPlainTextEdit): maximum = max(0, document.lineCount() - 1) step = viewport_height / self._control.fontMetrics().lineSpacing() else: # QTextEdit does not do line-based layout and blocks will not in # general have the same height. Therefore it does not make sense to # attempt to scroll in line height increments. maximum = document.size().height() step = viewport_height diff = maximum - scrollbar.maximum() scrollbar.setRange(0, maximum) scrollbar.setPageStep(step) # Compensate for undesirable scrolling that occurs automatically due to # maximumBlockCount() text truncation. if diff < 0 and document.blockCount() == document.maximumBlockCount(): scrollbar.setValue(scrollbar.value() + diff)
python
{ "resource": "" }
q280252
main
test
def main(args=None): """Entry point for pkginfo tool """ options, paths = _parse_options(args) format = getattr(options, 'output', 'simple') formatter = _FORMATTERS[format](options) for path in paths: meta = get_metadata(path, options.metadata_version) if meta is None: continue if options.download_url_prefix: if meta.download_url is None: filename = os.path.basename(path) meta.download_url = '%s/%s' % (options.download_url_prefix, filename) formatter(meta) formatter.finish()
python
{ "resource": "" }
q280253
ProfileDir.copy_config_file
test
def copy_config_file(self, config_file, path=None, overwrite=False): """Copy a default config file into the active profile directory. Default configuration files are kept in :mod:`IPython.config.default`. This function moves these from that location to the working profile directory. """ dst = os.path.join(self.location, config_file) if os.path.isfile(dst) and not overwrite: return False if path is None: path = os.path.join(get_ipython_package_dir(), u'config', u'profile', u'default') src = os.path.join(path, config_file) shutil.copy(src, dst) return True
python
{ "resource": "" }
q280254
ProfileDir.create_profile_dir_by_name
test
def create_profile_dir_by_name(cls, path, name=u'default', config=None): """Create a profile dir by profile name and path. Parameters ---------- path : unicode The path (directory) to put the profile directory in. name : unicode The name of the profile. The name of the profile directory will be "profile_<profile>". """ if not os.path.isdir(path): raise ProfileDirError('Directory not found: %s' % path) profile_dir = os.path.join(path, u'profile_' + name) return cls(location=profile_dir, config=config)
python
{ "resource": "" }
q280255
ProfileDir.find_profile_dir_by_name
test
def find_profile_dir_by_name(cls, ipython_dir, name=u'default', config=None): """Find an existing profile dir by profile name, return its ProfileDir. This searches through a sequence of paths for a profile dir. If it is not found, a :class:`ProfileDirError` exception will be raised. The search path algorithm is: 1. ``os.getcwdu()`` 2. ``ipython_dir`` Parameters ---------- ipython_dir : unicode or str The IPython directory to use. name : unicode or str The name of the profile. The name of the profile directory will be "profile_<profile>". """ dirname = u'profile_' + name paths = [os.getcwdu(), ipython_dir] for p in paths: profile_dir = os.path.join(p, dirname) if os.path.isdir(profile_dir): return cls(location=profile_dir, config=config) else: raise ProfileDirError('Profile directory not found in paths: %s' % dirname)
python
{ "resource": "" }
q280256
cmp_to_key
test
def cmp_to_key(mycmp): 'Convert a cmp= function into a key= function' class Key(object): def __init__(self, obj): self.obj = obj def __lt__(self, other): return mycmp(self.obj, other.obj) < 0 def __gt__(self, other): return mycmp(self.obj, other.obj) > 0 def __eq__(self, other): return mycmp(self.obj, other.obj) == 0 return Key
python
{ "resource": "" }
q280257
file_read
test
def file_read(filename): """Read a file and close it. Returns the file source.""" fobj = open(filename,'r'); source = fobj.read(); fobj.close() return source
python
{ "resource": "" }
q280258
raw_input_multi
test
def raw_input_multi(header='', ps1='==> ', ps2='..> ',terminate_str = '.'): """Take multiple lines of input. A list with each line of input as a separate element is returned when a termination string is entered (defaults to a single '.'). Input can also terminate via EOF (^D in Unix, ^Z-RET in Windows). Lines of input which end in \\ are joined into single entries (and a secondary continuation prompt is issued as long as the user terminates lines with \\). This allows entering very long strings which are still meant to be treated as single entities. """ try: if header: header += '\n' lines = [raw_input(header + ps1)] except EOFError: return [] terminate = [terminate_str] try: while lines[-1:] != terminate: new_line = raw_input(ps1) while new_line.endswith('\\'): new_line = new_line[:-1] + raw_input(ps2) lines.append(new_line) return lines[:-1] # don't return the termination command except EOFError: print() return lines
python
{ "resource": "" }
q280259
temp_pyfile
test
def temp_pyfile(src, ext='.py'): """Make a temporary python file, return filename and filehandle. Parameters ---------- src : string or list of strings (no need for ending newlines if list) Source code to be written to the file. ext : optional, string Extension for the generated file. Returns ------- (filename, open filehandle) It is the caller's responsibility to close the open file and unlink it. """ fname = tempfile.mkstemp(ext)[1] f = open(fname,'w') f.write(src) f.flush() return fname, f
python
{ "resource": "" }
q280260
Tee.close
test
def close(self): """Close the file and restore the channel.""" self.flush() setattr(sys, self.channel, self.ostream) self.file.close() self._closed = True
python
{ "resource": "" }
q280261
Tee.write
test
def write(self, data): """Write data to both channels.""" self.file.write(data) self.ostream.write(data) self.ostream.flush()
python
{ "resource": "" }
q280262
HeartMonitor.add_new_heart_handler
test
def add_new_heart_handler(self, handler): """add a new handler for new hearts""" self.log.debug("heartbeat::new_heart_handler: %s", handler) self._new_handlers.add(handler)
python
{ "resource": "" }
q280263
HeartMonitor.add_heart_failure_handler
test
def add_heart_failure_handler(self, handler): """add a new handler for heart failure""" self.log.debug("heartbeat::new heart failure handler: %s", handler) self._failure_handlers.add(handler)
python
{ "resource": "" }
q280264
HeartMonitor.handle_pong
test
def handle_pong(self, msg): "a heart just beat" current = str_to_bytes(str(self.lifetime)) last = str_to_bytes(str(self.last_ping)) if msg[1] == current: delta = time.time()-self.tic # self.log.debug("heartbeat::heart %r took %.2f ms to respond"%(msg[0], 1000*delta)) self.responses.add(msg[0]) elif msg[1] == last: delta = time.time()-self.tic + (self.lifetime-self.last_ping) self.log.warn("heartbeat::heart %r missed a beat, and took %.2f ms to respond", msg[0], 1000*delta) self.responses.add(msg[0]) else: self.log.warn("heartbeat::got bad heartbeat (possibly old?): %s (current=%.3f)", msg[1], self.lifetime)
python
{ "resource": "" }
q280265
batch_list
test
def batch_list(sequence, batch_size, mod = 0, randomize = False): ''' Converts a list into a list of lists with equal batch_size. Parameters ---------- sequence : list list of items to be placed in batches batch_size : int length of each sub list mod : int remainder of list length devided by batch_size mod = len(sequence) % batch_size randomize = bool should the initial sequence be randomized before being batched ''' if randomize: sequence = random.sample(sequence, len(sequence)) return [sequence[x:x + batch_size] for x in xrange(0, len(sequence)-mod, batch_size)]
python
{ "resource": "" }
q280266
path_to_filename
test
def path_to_filename(pathfile): ''' Takes a path filename string and returns the split between the path and the filename if filename is not given, filename = '' if path is not given, path = './' ''' path = pathfile[:pathfile.rfind('/') + 1] if path == '': path = './' filename = pathfile[pathfile.rfind('/') + 1:len(pathfile)] if '.' not in filename: path = pathfile filename = '' if (filename == '') and (path[len(path) - 1] != '/'): path += '/' return path, filename
python
{ "resource": "" }
q280267
Walk
test
def Walk(root='.', recurse=True, pattern='*'): ''' Generator for walking a directory tree. Starts at specified root folder, returning files that match our pattern. Optionally will also recurse through sub-folders. Parameters ---------- root : string (default is *'.'*) Path for the root folder to look in. recurse : bool (default is *True*) If *True*, will also look in the subfolders. pattern : string (default is :emphasis:`'*'`, which means all the files are concerned) The pattern to look for in the files' name. Returns ------- generator **Walk** yields a generator from the matching files paths. ''' for path, subdirs, files in os.walk(root): for name in files: if fnmatch.fnmatch(name, pattern): yield os.path.join(path, name) if not recurse: break
python
{ "resource": "" }
q280268
displayAll
test
def displayAll(elapsed, display_amt, est_end, nLoops, count, numPrints): '''Displays time if verbose is true and count is within the display amount''' if numPrints > nLoops: display_amt = 1 else: display_amt = round(nLoops / numPrints) if count % display_amt == 0: avg = elapsed / count est_end = round(avg * nLoops) (disp_elapsed, disp_avg, disp_est) = timeUnit(int(round(elapsed)), int(round(avg)), int(round(est_end))) print "%s%%" % str(round(count / float(nLoops) * 100)), "@" + str(count), totalTime = disp_est[0] unit = disp_est[1] if str(unit) == "secs": remain = totalTime - round(elapsed) remainUnit = "secs" elif str(unit) == "mins": remain = totalTime - round(elapsed) / 60 remainUnit = "mins" elif str(unit) == "hr": remain = totalTime - round(elapsed) / 3600 remainUnit = "hr" print "ETA: %s %s" % (str(remain), remainUnit) print return
python
{ "resource": "" }
q280269
timeUnit
test
def timeUnit(elapsed, avg, est_end): '''calculates unit of time to display''' minute = 60 hr = 3600 day = 86400 if elapsed <= 3 * minute: unit_elapsed = (elapsed, "secs") if elapsed > 3 * minute: unit_elapsed = ((elapsed / 60), "mins") if elapsed > 3 * hr: unit_elapsed = ((elapsed / 3600), "hr") if avg <= 3 * minute: unit_avg = (avg, "secs") if avg > 3 * minute: unit_avg = ((avg / 60), "mins") if avg > 3 * hr: unit_avg = ((avg / 3600), "hr") if est_end <= 3 * minute: unit_estEnd = (est_end, "secs") if est_end > 3 * minute: unit_estEnd = ((est_end / 60), "mins") if est_end > 3 * hr: unit_estEnd = ((est_end / 3600), "hr") return [unit_elapsed, unit_avg, unit_estEnd]
python
{ "resource": "" }
q280270
extract_wininst_cfg
test
def extract_wininst_cfg(dist_filename): """Extract configuration data from a bdist_wininst .exe Returns a ConfigParser.RawConfigParser, or None """ f = open(dist_filename,'rb') try: endrec = zipfile._EndRecData(f) if endrec is None: return None prepended = (endrec[9] - endrec[5]) - endrec[6] if prepended < 12: # no wininst data here return None f.seek(prepended-12) import struct, StringIO, ConfigParser tag, cfglen, bmlen = struct.unpack("<iii",f.read(12)) if tag not in (0x1234567A, 0x1234567B): return None # not a valid tag f.seek(prepended-(12+cfglen)) cfg = ConfigParser.RawConfigParser({'version':'','target_version':''}) try: part = f.read(cfglen) # part is in bytes, but we need to read up to the first null # byte. if sys.version_info >= (2,6): null_byte = bytes([0]) else: null_byte = chr(0) config = part.split(null_byte, 1)[0] # Now the config is in bytes, but on Python 3, it must be # unicode for the RawConfigParser, so decode it. Is this the # right encoding? config = config.decode('ascii') cfg.readfp(StringIO.StringIO(config)) except ConfigParser.Error: return None if not cfg.has_section('metadata') or not cfg.has_section('Setup'): return None return cfg finally: f.close()
python
{ "resource": "" }
q280271
uncache_zipdir
test
def uncache_zipdir(path): """Ensure that the importer caches dont have stale info for `path`""" from zipimport import _zip_directory_cache as zdc _uncache(path, zdc) _uncache(path, sys.path_importer_cache)
python
{ "resource": "" }
q280272
nt_quote_arg
test
def nt_quote_arg(arg): """Quote a command line argument according to Windows parsing rules""" result = [] needquote = False nb = 0 needquote = (" " in arg) or ("\t" in arg) if needquote: result.append('"') for c in arg: if c == '\\': nb += 1 elif c == '"': # double preceding backslashes, then add a \" result.append('\\' * (nb*2) + '\\"') nb = 0 else: if nb: result.append('\\' * nb) nb = 0 result.append(c) if nb: result.append('\\' * nb) if needquote: result.append('\\' * nb) # double the trailing backslashes result.append('"') return ''.join(result)
python
{ "resource": "" }
q280273
easy_install.check_conflicts
test
def check_conflicts(self, dist): """Verify that there are no conflicting "old-style" packages""" return dist # XXX temporarily disable until new strategy is stable from imp import find_module, get_suffixes from glob import glob blockers = [] names = dict.fromkeys(dist._get_metadata('top_level.txt')) # XXX private attr exts = {'.pyc':1, '.pyo':1} # get_suffixes() might leave one out for ext,mode,typ in get_suffixes(): exts[ext] = 1 for path,files in expand_paths([self.install_dir]+self.all_site_dirs): for filename in files: base,ext = os.path.splitext(filename) if base in names: if not ext: # no extension, check for package try: f, filename, descr = find_module(base, [path]) except ImportError: continue else: if f: f.close() if filename not in blockers: blockers.append(filename) elif ext in exts and base!='site': # XXX ugh blockers.append(os.path.join(path,filename)) if blockers: self.found_conflicts(dist, blockers) return dist
python
{ "resource": "" }
q280274
easy_install._set_fetcher_options
test
def _set_fetcher_options(self, base): """ When easy_install is about to run bdist_egg on a source dist, that source dist might have 'setup_requires' directives, requiring additional fetching. Ensure the fetcher options given to easy_install are available to that command as well. """ # find the fetch options from easy_install and write them out # to the setup.cfg file. ei_opts = self.distribution.get_option_dict('easy_install').copy() fetch_directives = ( 'find_links', 'site_dirs', 'index_url', 'optimize', 'site_dirs', 'allow_hosts', ) fetch_options = {} for key, val in ei_opts.iteritems(): if key not in fetch_directives: continue fetch_options[key.replace('_', '-')] = val[1] # create a settings dictionary suitable for `edit_config` settings = dict(easy_install=fetch_options) cfg_filename = os.path.join(base, 'setup.cfg') setopt.edit_config(cfg_filename, settings)
python
{ "resource": "" }
q280275
easy_install.create_home_path
test
def create_home_path(self): """Create directories under ~.""" if not self.user: return home = convert_path(os.path.expanduser("~")) for name, path in self.config_vars.iteritems(): if path.startswith(home) and not os.path.isdir(path): self.debug_print("os.makedirs('%s', 0700)" % path) os.makedirs(path, 0700)
python
{ "resource": "" }
q280276
is_archive_file
test
def is_archive_file(name): """Return True if `name` is a considered as an archive file.""" archives = ( '.zip', '.tar.gz', '.tar.bz2', '.tgz', '.tar', '.whl' ) ext = splitext(name)[1].lower() if ext in archives: return True return False
python
{ "resource": "" }
q280277
mutable
test
def mutable(obj): ''' return a mutable proxy for the `obj`. all modify on the proxy will not apply on origin object. ''' base_cls = type(obj) class Proxy(base_cls): def __getattribute__(self, name): try: return super().__getattribute__(name) except AttributeError: return getattr(obj, name) update_wrapper(Proxy, base_cls, updated = ()) return Proxy()
python
{ "resource": "" }
q280278
readonly
test
def readonly(obj, *, error_on_set = False): ''' return a readonly proxy for the `obj`. all modify on the proxy will not apply on origin object. ''' base_cls = type(obj) class ReadonlyProxy(base_cls): def __getattribute__(self, name): return getattr(obj, name) def __setattr__(self, name, value): if error_on_set: raise AttributeError('cannot set readonly object.') update_wrapper(ReadonlyProxy, base_cls, updated = ()) return ReadonlyProxy()
python
{ "resource": "" }
q280279
new_heading_cell
test
def new_heading_cell(source=None, rendered=None, level=1, metadata=None): """Create a new section cell with a given integer level.""" cell = NotebookNode() cell.cell_type = u'heading' if source is not None: cell.source = unicode(source) if rendered is not None: cell.rendered = unicode(rendered) cell.level = int(level) cell.metadata = NotebookNode(metadata or {}) return cell
python
{ "resource": "" }
q280280
new_metadata
test
def new_metadata(name=None, authors=None, license=None, created=None, modified=None, gistid=None): """Create a new metadata node.""" metadata = NotebookNode() if name is not None: metadata.name = unicode(name) if authors is not None: metadata.authors = list(authors) if created is not None: metadata.created = unicode(created) if modified is not None: metadata.modified = unicode(modified) if license is not None: metadata.license = unicode(license) if gistid is not None: metadata.gistid = unicode(gistid) return metadata
python
{ "resource": "" }
q280281
new_author
test
def new_author(name=None, email=None, affiliation=None, url=None): """Create a new author.""" author = NotebookNode() if name is not None: author.name = unicode(name) if email is not None: author.email = unicode(email) if affiliation is not None: author.affiliation = unicode(affiliation) if url is not None: author.url = unicode(url) return author
python
{ "resource": "" }
q280282
_writable_dir
test
def _writable_dir(path): """Whether `path` is a directory, to which the user has write access.""" return os.path.isdir(path) and os.access(path, os.W_OK)
python
{ "resource": "" }
q280283
unquote_filename
test
def unquote_filename(name, win32=(sys.platform=='win32')): """ On Windows, remove leading and trailing quotes from filenames. """ if win32: if name.startswith(("'", '"')) and name.endswith(("'", '"')): name = name[1:-1] return name
python
{ "resource": "" }
q280284
get_py_filename
test
def get_py_filename(name, force_win32=None): """Return a valid python filename in the current directory. If the given name is not a file, it adds '.py' and searches again. Raises IOError with an informative message if the file isn't found. On Windows, apply Windows semantics to the filename. In particular, remove any quoting that has been applied to it. This option can be forced for testing purposes. """ name = os.path.expanduser(name) if force_win32 is None: win32 = (sys.platform == 'win32') else: win32 = force_win32 name = unquote_filename(name, win32=win32) if not os.path.isfile(name) and not name.endswith('.py'): name += '.py' if os.path.isfile(name): return name else: raise IOError,'File `%r` not found.' % name
python
{ "resource": "" }
q280285
filefind
test
def filefind(filename, path_dirs=None): """Find a file by looking through a sequence of paths. This iterates through a sequence of paths looking for a file and returns the full, absolute path of the first occurence of the file. If no set of path dirs is given, the filename is tested as is, after running through :func:`expandvars` and :func:`expanduser`. Thus a simple call:: filefind('myfile.txt') will find the file in the current working dir, but:: filefind('~/myfile.txt') Will find the file in the users home directory. This function does not automatically try any paths, such as the cwd or the user's home directory. Parameters ---------- filename : str The filename to look for. path_dirs : str, None or sequence of str The sequence of paths to look for the file in. If None, the filename need to be absolute or be in the cwd. If a string, the string is put into a sequence and the searched. If a sequence, walk through each element and join with ``filename``, calling :func:`expandvars` and :func:`expanduser` before testing for existence. Returns ------- Raises :exc:`IOError` or returns absolute path to file. """ # If paths are quoted, abspath gets confused, strip them... filename = filename.strip('"').strip("'") # If the input is an absolute path, just check it exists if os.path.isabs(filename) and os.path.isfile(filename): return filename if path_dirs is None: path_dirs = ("",) elif isinstance(path_dirs, basestring): path_dirs = (path_dirs,) for path in path_dirs: if path == '.': path = os.getcwdu() testname = expand_path(os.path.join(path, filename)) if os.path.isfile(testname): return os.path.abspath(testname) raise IOError("File %r does not exist in any of the search paths: %r" % (filename, path_dirs) )
python
{ "resource": "" }
q280286
get_home_dir
test
def get_home_dir(require_writable=False): """Return the 'home' directory, as a unicode string. * First, check for frozen env in case of py2exe * Otherwise, defer to os.path.expanduser('~') See stdlib docs for how this is determined. $HOME is first priority on *ALL* platforms. Parameters ---------- require_writable : bool [default: False] if True: guarantees the return value is a writable directory, otherwise raises HomeDirError if False: The path is resolved, but it is not guaranteed to exist or be writable. """ # first, check py2exe distribution root directory for _ipython. # This overrides all. Normally does not exist. if hasattr(sys, "frozen"): #Is frozen by py2exe if '\\library.zip\\' in IPython.__file__.lower():#libraries compressed to zip-file root, rest = IPython.__file__.lower().split('library.zip') else: root=os.path.join(os.path.split(IPython.__file__)[0],"../../") root=os.path.abspath(root).rstrip('\\') if _writable_dir(os.path.join(root, '_ipython')): os.environ["IPYKITROOT"] = root return py3compat.cast_unicode(root, fs_encoding) homedir = os.path.expanduser('~') # Next line will make things work even when /home/ is a symlink to # /usr/home as it is on FreeBSD, for example homedir = os.path.realpath(homedir) if not _writable_dir(homedir) and os.name == 'nt': # expanduser failed, use the registry to get the 'My Documents' folder. try: import _winreg as wreg key = wreg.OpenKey( wreg.HKEY_CURRENT_USER, "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" ) homedir = wreg.QueryValueEx(key,'Personal')[0] key.Close() except: pass if (not require_writable) or _writable_dir(homedir): return py3compat.cast_unicode(homedir, fs_encoding) else: raise HomeDirError('%s is not a writable dir, ' 'set $HOME environment variable to override' % homedir)
python
{ "resource": "" }
q280287
get_xdg_dir
test
def get_xdg_dir(): """Return the XDG_CONFIG_HOME, if it is defined and exists, else None. This is only for non-OS X posix (Linux,Unix,etc.) systems. """ env = os.environ if os.name == 'posix' and sys.platform != 'darwin': # Linux, Unix, AIX, etc. # use ~/.config if empty OR not set xdg = env.get("XDG_CONFIG_HOME", None) or os.path.join(get_home_dir(), '.config') if xdg and _writable_dir(xdg): return py3compat.cast_unicode(xdg, fs_encoding) return None
python
{ "resource": "" }
q280288
get_ipython_dir
test
def get_ipython_dir(): """Get the IPython directory for this platform and user. This uses the logic in `get_home_dir` to find the home directory and then adds .ipython to the end of the path. """ env = os.environ pjoin = os.path.join ipdir_def = '.ipython' xdg_def = 'ipython' home_dir = get_home_dir() xdg_dir = get_xdg_dir() # import pdb; pdb.set_trace() # dbg if 'IPYTHON_DIR' in env: warnings.warn('The environment variable IPYTHON_DIR is deprecated. ' 'Please use IPYTHONDIR instead.') ipdir = env.get('IPYTHONDIR', env.get('IPYTHON_DIR', None)) if ipdir is None: # not set explicitly, use XDG_CONFIG_HOME or HOME home_ipdir = pjoin(home_dir, ipdir_def) if xdg_dir: # use XDG, as long as the user isn't already # using $HOME/.ipython and *not* XDG/ipython xdg_ipdir = pjoin(xdg_dir, xdg_def) if _writable_dir(xdg_ipdir) or not _writable_dir(home_ipdir): ipdir = xdg_ipdir if ipdir is None: # not using XDG ipdir = home_ipdir ipdir = os.path.normpath(os.path.expanduser(ipdir)) if os.path.exists(ipdir) and not _writable_dir(ipdir): # ipdir exists, but is not writable warnings.warn("IPython dir '%s' is not a writable location," " using a temp directory."%ipdir) ipdir = tempfile.mkdtemp() elif not os.path.exists(ipdir): parent = ipdir.rsplit(os.path.sep, 1)[0] if not _writable_dir(parent): # ipdir does not exist and parent isn't writable warnings.warn("IPython parent '%s' is not a writable location," " using a temp directory."%parent) ipdir = tempfile.mkdtemp() return py3compat.cast_unicode(ipdir, fs_encoding)
python
{ "resource": "" }
q280289
get_ipython_package_dir
test
def get_ipython_package_dir(): """Get the base directory where IPython itself is installed.""" ipdir = os.path.dirname(IPython.__file__) return py3compat.cast_unicode(ipdir, fs_encoding)
python
{ "resource": "" }
q280290
get_ipython_module_path
test
def get_ipython_module_path(module_str): """Find the path to an IPython module in this version of IPython. This will always find the version of the module that is in this importable IPython package. This will always return the path to the ``.py`` version of the module. """ if module_str == 'IPython': return os.path.join(get_ipython_package_dir(), '__init__.py') mod = import_item(module_str) the_path = mod.__file__.replace('.pyc', '.py') the_path = the_path.replace('.pyo', '.py') return py3compat.cast_unicode(the_path, fs_encoding)
python
{ "resource": "" }
q280291
target_outdated
test
def target_outdated(target,deps): """Determine whether a target is out of date. target_outdated(target,deps) -> 1/0 deps: list of filenames which MUST exist. target: single filename which may or may not exist. If target doesn't exist or is older than any file listed in deps, return true, otherwise return false. """ try: target_time = os.path.getmtime(target) except os.error: return 1 for dep in deps: dep_time = os.path.getmtime(dep) if dep_time > target_time: #print "For target",target,"Dep failed:",dep # dbg #print "times (dep,tar):",dep_time,target_time # dbg return 1 return 0
python
{ "resource": "" }
q280292
filehash
test
def filehash(path): """Make an MD5 hash of a file, ignoring any differences in line ending characters.""" with open(path, "rU") as f: return md5(py3compat.str_to_bytes(f.read())).hexdigest()
python
{ "resource": "" }
q280293
check_for_old_config
test
def check_for_old_config(ipython_dir=None): """Check for old config files, and present a warning if they exist. A link to the docs of the new config is included in the message. This should mitigate confusion with the transition to the new config system in 0.11. """ if ipython_dir is None: ipython_dir = get_ipython_dir() old_configs = ['ipy_user_conf.py', 'ipythonrc', 'ipython_config.py'] warned = False for cfg in old_configs: f = os.path.join(ipython_dir, cfg) if os.path.exists(f): if filehash(f) == old_config_md5.get(cfg, ''): os.unlink(f) else: warnings.warn("Found old IPython config file %r (modified by user)"%f) warned = True if warned: warnings.warn(""" The IPython configuration system has changed as of 0.11, and these files will be ignored. See http://ipython.github.com/ipython-doc/dev/config for details of the new config system. To start configuring IPython, do `ipython profile create`, and edit `ipython_config.py` in <ipython_dir>/profile_default. If you need to leave the old config files in place for an older version of IPython and want to suppress this warning message, set `c.InteractiveShellApp.ignore_old_config=True` in the new config.""")
python
{ "resource": "" }
q280294
update_suggestions_dictionary
test
def update_suggestions_dictionary(request, object): """ Updates the suggestions' dictionary for an object upon visiting its page """ if request.user.is_authenticated(): user = request.user content_type = ContentType.objects.get_for_model(type(object)) try: # Check if the user has visited this page before ObjectView.objects.get( user=user, object_id=object.id, content_type=content_type) except: ObjectView.objects.create(user=user, content_object=object) # Get a list of all the objects a user has visited viewed = ObjectView.objects.filter(user=user) else: update_dict_for_guests(request, object, content_type) return if viewed: for obj in viewed: if content_type == obj.content_type: if not exists_in_dictionary(request, object, content_type, obj, True): # Create an entry if it's non existent if object.id != obj.object_id: ObjectViewDictionary.objects.create( current_object=object, visited_before_object=obj.content_object) if not exists_in_dictionary(request, obj, obj.content_type, object, False): ObjectViewDictionary.objects.create( current_object=obj.content_object, visited_before_object=object) return
python
{ "resource": "" }
q280295
get_suggestions_with_size
test
def get_suggestions_with_size(object, size): """ Gets a list with a certain size of suggestions for an object """ content_type = ContentType.objects.get_for_model(type(object)) try: return ObjectViewDictionary.objects.filter( current_object_id=object.id, current_content_type=content_type).extra( order_by=['-visits'])[:size] except: return ObjectViewDictionary.objects.filter( current_object_id=object.id, current_content_type=content_type).extra(order_by=['-visits'])
python
{ "resource": "" }
q280296
get_suggestions
test
def get_suggestions(object): """ Gets a list of all suggestions for an object """ content_type = ContentType.objects.get_for_model(type(object)) return ObjectViewDictionary.objects.filter( current_object_id=object.id, current_content_type=content_type).extra(order_by=['-visits'])
python
{ "resource": "" }
q280297
path.relpath
test
def relpath(self): """ Return this path as a relative path, based from the current working directory. """ cwd = self.__class__(os.getcwdu()) return cwd.relpathto(self)
python
{ "resource": "" }
q280298
path.glob
test
def glob(self, pattern): """ Return a list of path objects that match the pattern. pattern - a path relative to this directory, with wildcards. For example, path('/users').glob('*/bin/*') returns a list of all the files users have in their bin directories. """ cls = self.__class__ return [cls(s) for s in glob.glob(unicode(self / pattern))]
python
{ "resource": "" }
q280299
path.lines
test
def lines(self, encoding=None, errors='strict', retain=True): r""" Open this file, read all lines, return them in a list. Optional arguments: encoding - The Unicode encoding (or character set) of the file. The default is None, meaning the content of the file is read as 8-bit characters and returned as a list of (non-Unicode) str objects. errors - How to handle Unicode errors; see help(str.decode) for the options. Default is 'strict' retain - If true, retain newline characters; but all newline character combinations ('\r', '\n', '\r\n') are translated to '\n'. If false, newline characters are stripped off. Default is True. This uses 'U' mode in Python 2.3 and later. """ if encoding is None and retain: f = self.open('U') try: return f.readlines() finally: f.close() else: return self.text(encoding, errors).splitlines(retain)
python
{ "resource": "" }