Query memory information from the address space of the process. Returns a L{win32.MemoryBasicInformation} object. @see: U{ht

Retrieves the execution context (i.e. the registers values) for this thread. @type ContextFlags: int @param Context

@see: L{get_tid} @rtype: L{Thread} @return: Thread where the event occured.

@see: L{get_thread} @rtype: int @return: Thread global ID where the event occured.

@rtype: bool @return: C{True} if the breakpoint is in L{DISABLED} state.

RaiseUnexpectedTypeError */

Given the frame.f_lasti, return the related `Variant`. :note: if the offset is found before any variant available or no variants are

Should only be called if `self.is_files_filter_enabled == True` or `force_check_project_scope == True`. Note that it covers both the

Closes all open connections to the remote Registry. No exceptions are raised, even if an error occurs. This method has no e

ParseKeywords */

:param str expression: The expression to be evaluated. Note that if the expression is indented it's automatically dedented (base

based on a filter name, only return those tests that have the test case names that match

@rtype: bool @return: C{True} if the thread if currently running. @raise WindowsError: The debugger doesn't have

@see: L{iter_thread_ids} @rtype: dictionary-valueiterator @return: Iterator of L{Thread} objects in this snapshot.

Writes to the memory of the process. @note: Page permissions may be changed temporarily while writing. @see: L{poke}

Clear input hook. Parameters ---------- app : optional, ignored This parameter is allowed only so that clear_inputh

@rtype: int or None @return: Base address of the module. Returns C{None} if unknown.

Note: the difference from get_current_thread_id to get_thread_id is that for the current thread we can get the thread id while the thread.ide

@see: L{iter_process_ids} @rtype: dictionary-valueiterator @return: Iterator of L{Process} objects in this snapshot.

Returns an iterator that crawls the entire Windows Registry.

Returns a handle to the thread with I{at least} the access rights requested. @note: If a handle was previously o

Creates a label from the given memory address. If the address belongs to the module, the label is made relative to it's base

Subclasses should override. @return: dict with namespace.

CIntFromPy */

CIntToPy */

UnicodeEquals (used by fastcall) */

RaiseNeedMoreValuesToUnpack */

Enables tracing. If in regular mode (tracing), will set the tracing function to the tracing function for this thread -- by d

@rtype: str or None @return: Module filename. Returns C{None} if unknown.

@type dwProcessId: int @param dwProcessId: Global ID of the process to look for. @rtype: bool @return: C{True} if

Reads the memory of the process. @see: L{read} @type lpBaseAddress: int @param lpBaseAddress: Memory address to be

Adds a buffer watch identifier. @type bw: L{BufferWatch} @param bw: Buffer watch identifier.

A simple disassemble of bytecode. It does not attempt to provide the full Python source code, rather, it provides a low-level representa

@rtype: bool @return: C{True} if the breakpoint is in L{RUNNING} state.

Set inputhook to callback.

Convert arguments to the LPARAM type. Used automatically by SendMessage, PostMessage, etc. You shouldn't need to call this function.

Convert arguments to the WPARAM type. Used automatically by SendMessage, PostMessage, etc. You shouldn't need to call this function.

check version string found_version >= expected_min_or_eq_to_version If dev/prerelease tags result in TypeError for string-number comparison,

@rtype: int @return: Value of the program counter register.

@rtype: bool @return: C{True} if the memory in this region has any data in it.

Note: don't call directly. Use PyDb.in_project_scope (there's no caching here and it doesn't handle all possibilities for knowing whe

Determine if the debugger is debugging the given process. @see: L{is_debugee_attached}, L{is_debugee_started} @type dwProc

this function should return the information gathered on a function @param func: this is the function we want to get info on @return a tuple w

Convert something as 'file1.py' at line 10 to '<ipython-cell-xxx>' at line 2. Note that the name should be already normalized at thi

Determine if the given memory address lies within the watched buffer. @rtype: bool @return: C{True} if the given memory addr

if thread_id is *, post to the '*' queue

Runs a function as a pydevd daemon thread (without any tracing in place).

:param ide_os: 'WINDOWS' or 'UNIX'