pywinauto

Enhancements

• Add allow_magic_lookup flag for Application and Desktop object. Thanks @pakal!
• Don't duplicate already pressed key in internal list in win32_hooks.py. Thanks @TomRobo237!
• Allow finding an edit box by title (its editable text).
• Add option to send keyboard input for an application which doesn't handle VK_PACKET properly.
  Use vk_packet=False in method type_keys, default value is vk_packet=True. Thanks @philmbailey!

Bug Fixes

• Fix ctypes.windll usage conflicts with other libraries.
• Minor fixes in top-level __init__.py. Thanks @pakal!
• Fix logging issues in remote_memory_block.py. Thanks @TomRobo237!
• Minor docs improvements. Thanks @olesteban, @caoyaxing221 and @nuno-andre!

Enhancements

• Reuse ctypes.wintypes more to avoid redundant definitions for Win32 API.
• Add method EditWrapper.is_editable() for "uia" backend.

Bug Fixes

• Fix corner case with int/long conversion crash while getting text.
• Fix UIA crash: handle InvalidControlType properly.
• Fix menu_select() for one level main menu in WinForms apps.
• Make Application object non-iterable (iterating was hang).
• Fix type conversion crash in GetWindowRect (method .rectangle()).
• Fix combo box fluttering/blinking in dump_tree() / print_control_identifiers().

Enhancements

• Improve support for WinForms and Qt5: ComboBox, ListBox, DataGrid/Table.
• Add an ability to use MFC toolbar buttons by text. Thanks @Nebyt !
• Make method kill() hard (and fast) by default (can be used with param soft=True optionally).
• Make visible_only=False a default option for method connect() (useful for minimized apps).
• Add an ability to hold or release a key with params down and up for .type_keys() method. See the improved docs for keyboard module for more details. Thanks @badari412 !
• Add method windows() to class Desktop.
• Add Remote Execution Guide with all known RDP/VNC/psexec/etc tricks.

Bug Fixes

• Fix UnicodeDecodeError/UnicodeEncodeError in several cases
  while printing wrapper object representation.
• Add static text to a list of best match names for backend="uia".
• Fix COMError for runtime_id property.
• Fix method click() for some radio buttons.
• Improve error message when screen is locked.
• Use utf-8 encoding while writing dump_tree() output to file.
• Remove few incorrect warnings for backend="win32".
• Fix crash in GetWindowRect call.
• Fix black screenshot issue with second monitor. Thanks @Nebyt !

Enhancements:

• Check admin privileges for both target app and Python process. This
  allows detecting cases when window messages won't work.
• Add automation_id and control_type properties
  for "win32" backend (the most useful for WinForms). Correct
  child_window() keywords are auto_id and control_type.
• Switch pypiwin32 dependency to pywin32 which became official again.
• New generators iter_children() and iter_descendants().
• Add method is_checked() to "win32" check box.

Bug Fixes:

• Method Application().connect(...) works better with timeout
  argument.
• Fix .set_focus() for "uia" backend including minimized window case
  (issue #443).
• maximize()/minimize() methods can be chained now.
• Fix passing keyword arguments to a function for decorators
  @always_wait_until_passes and @always_wait_until.
• Use correct types conversion for WaitGuiThreadIdle (issue #497).
• Fix reporting code coverage on Linux.
• Use .format() for logging BaseWrapper actions (issue #471).
• Print warning in case binary type is not determined (issue #387).

Bug Fixes

• Final fix for ValueError: NULL COM pointer access (UIA backend).

Enhancements

• Multi-threading mode (MTA) for comtypes is enabled by default, if it's not initialized
  by another library before importing pywinauto.

• Method get_value() has been added to EditWrapper in UIA backend.

• Method scroll() has been added for all UIA controls which have ScrollPattern implemented.

• Added methods is_minimized/is_maximized/is_normal/get_show_state for UIAWrapper.

• Added handling in-place controls inside ListView control and (row, column) indexing
  in a grid-like table mode. Examples:

      auto_detected_ctrl = list_view.get_item(0).inplace_control()
  
      combo = list_view.get_item(1,1).inplace_control("ComboBox")
      combo.select("Item name")
  
      edit = list_view.get_item(3,4).inplace_control("Edit")
      edit.type_keys("some text{ENTER}", set_foreground=False)
  
      dt_picker = list_view.get_item(2,0).inplace_control("DateTimePicker")
  

• Improved string representation for all wrapper objects. Thanks @airelil!
• Fixed several sporadic crashes for backend="uia".
• Fixed several bugs in wait/wait_not methods:
  • Method wait('exists') doesn't work for backend="uia". Thanks @maollm!
  • Methods wait/wait_not take ~ default time (5 sec.) instead of customized timeout like 1 sec.
• depth param can used in a WindowSpecification now. depth=1 means this control,
  depth=2 means immediate children only and so on (aligned with print_control_identifiers method). Thanks @dmitrykazanbaev!
• Significantly improved sending keys to an inactive window silently. Special thanks for @antonlarin! Now 2 methods are available:
  • send_chars is supposed to send character input (this includes {Enter}, {Tab}, {Backspace}) without Alt/Shift/Ctrl modifiers.
  • send_keystrokes is for key input (including key combinations with Alt/Shift/Ctrl modifiers).
• Method Application().connect(path='your.exe') uses default timeout Timings.app_connect_timeout.
  It can accept timeout and retry_interval keyword arguments. Thanks @daniil-kukushkin!
• Method print_control_identifiers is more consistent and minimum 2x faster now! Thanks @cetygamer!
• Fixed subclassing Application with your own methods. Thanks @efremovd!
• Param work_dir can be used in Application().start(...). Thanks @efremovd!
• Class Application has been enriched with methods is_process_running() and wait_for_process_exit(). Thanks @efremovd!
• Module timings uses time.clock() for Python 2.x and time.perf_counter() for Python 3.x
  so that accident system time change can't affect on your script behavior. Thanks @airelil!
• Added WireShark example. Thanks @ViktorRoy94!
• Now print_control_identifiers() can dump UI elements tree to a file. Thanks @sovrasov!
• Improved logging actions for backend="uia", extended example for MS Paint. Thanks @ArtemSkrebkov!
• Extended CalendarWrapper for backend="win32" with these methods: get_month_delta,
  set_month_delta and get_month_range. Thanks @Nikita-K!
• Added method legacy_properties() to UIAWrapper. Thanks @AsyaPronina!
• Improved VB6 ListView detection for backend="win32". Thanks @KirillMoizik!
• Fixed 64-bit specific bug in TreeViewWrapper for backend="win32"
  (argument 4: <type 'exceptions.OverflowError'>: long int too long to convert).

• Several bugs were fixed:
  • Maximized window is always resized (restored) when calling set_focus().
  • AttributeError: type object '_CustomLogger' has no attribute 'disable'.
  • print_control_identifiers() gets bytes string on Python 3.x.
  • Importing pywinauto causes debug messages to appear twice.
• Improved click methods behaviour for Win32 ListView and TreeView:
  ensure_visible() is called inside before the click.
• Made taskbar.SystemTrayIcons localization friendly.

• win32_hooks module is well tested and more reliable now. See detailed example.
• Fixed several bugs and crashes here and there.
  • Crash when ctrl.window_text() becomes None at the right moment. Thanks @mborus!
  • HwndWrapper.set_focus() fails when used via interpreter. Thanks @mtkennerly!
  • Fix LoadLibrary call error on just released Python 2.7.13. Thanks @KirillMoizik!
  • AttributeError: WindowSpecification class has no 'CPUUsage' method.
  • comtypes prints a lot of warnings at import pywinauto.
  • Methods is_dialog() and restore() are missed for UIA backend.
  • Method print_control_identifiers() crashes on some applications with Unicode symbols.
  • Installation by python setup.py install may fail if pyWin32 dependency was installed manually.
  • Bug in resolving attributes: 'UIAWrapper' object has no attribute 'Menu' for dlg = app.Custom.Menu.
  • Method send_chars() can now send {ENTER} to some applications. Thanks @batterseapower!
• Searching UI elements is faster now especially if you use control_type or auto_id in
  a WindowSpecification. Method Application.kill() is also optimized in many cases.
• Added an example for Win10 Calculator.

• This big release introduces MS UI Automation (UIA) support (beta). Feedback is very welcome!
  • Just start from app = Application(backend='uia').start('your_app.exe').
  • Default backend is still 'win32' if nothing is specified.
  • Supported WPF controls: Menu, Button/CheckBox/RadioButton, ComboBox, Edit,
    Tab control, List (ListView), DataGrid, Tree, Toolbar, Tooltip, Slider.
  • It uses native UIAutomationCore.dll through comtypes (like UiaComWrapper for .NET but in CPython).
  • Despite code coverage is ~95% consider it as beta quality. Performance is slower than for "win32".
• Documentation is built continuously now on ReadTheDocs. See also improved
  Getting Started Guide.
• Modules keyboard and mouse can be used out of any window context now. And they work on Linux as well!
• New multi-backend architecture makes implementation of new platforms support
  easier in the future. The minimal set for new backend includes its name and
  two classes inherited from ElementInfo and from BaseWrapper. New backend
  must be registered by function backend.register(). Linux AT SPI and Apple Accessibility API are in the long term plans.
• Code style is much closer to PEP8: i.e. click_input should be used
  instead of ClickInput.
• Initial implementation of the win32_hooks module. Keyboard and mouse event
  handlers can be registered in the system. It was inspired by pyHook, pyhk,
  pyhooked and similar modules, but re-written from scratch. Thanks for
  Max Samokhvalov! The fork (at some moment) of the win32_hooks module is
  used in pyhooked 0.8 by Ethan Smith.
• A lot of small improvements are not counted here.

• Fix bugs and inconsistencies:
  • Add where="check" possible value to the ListViewWrapper.Click/ClickInput` methods.
  • Add CheckByClickInput and UncheckByClickInput methods for a plain check box.
  • Fix crash while waiting for the window start.
• Add partial MFC Menu Bar support. The menu bar can be interpreted as a toolbar. Items are clickable by index through experimental MenuBarClickInput method of the ToolbarWrapper.
• Python 3.5 is supported.

• Better backward compatibility with pywinauto 0.4.2:
  • support Unicode symbols in the TypeKeys method again;
  • allow SetEditText/TypeKeys methods to take non-string arguments;
  • fix taking Unicode parameters in SetEditText/TypeKeys.
• Fix bug in Wait("active"), raise a SyntaxError when waiting for an incorrect state.
• Re-consider some timings, update docs for the default values etc.
• Fix several issues with an owner-drawn menu.
• MenuItem method Click is renamed to ClickInput while Click = Select now.
• New SetTransparency method can make a window transparent in a specified degree (from 0 to 255).
• New window search criteria found_index is useful to choose the control in the list of similar ones with same texts.

• New Application methods: CPUUsage returns CPU usage as a percent (float number),
  WaitCPUUsageLower waits until the connected process' CPU usage is lower than
  specified value (2.5% by default).
• ListViewWrapper interface is aligned with TreeViewWrapper. GetItem() returns a _listview_item object that looks like a _treeview_element now.
• Add DPI awareness API support (Win8+). It allows correct work when all fonts
  are scaled at 125%, 150% etc (globally or per monitor).
• "Waiting for Long Operations" section in docs.
• Fix number of bugs:
  • TreeViewWrapper.Select doesn't work when the control is not in focus.
  • TabControlWrapper.Select doesn't work in case of TCS_BUTTONS style set.
  • ListViewWrapper methods Check/UnCheck are fixed.
  • Toolbar button: incorrect access by a tooltip text.
  • Warning "Cannot retrieve text length for handle" uses print() instead of actionlogger.
  • ClientToScreen method doesn't return a value (modifying mutable argument is not good practice).

• Resolve pip issues
• Warnings about mismatched Python/application bitness
• Add "TCheckBox" class name to ButtonWrapper detection list
• Fix DebugMessage method
• Disable logging (actionlogger.py) by default, provide shortcuts: actionlogger.enable() and actionlogger.disable().
  For those who are familiar with standard logging module there's method actionlogger.set_level(level).

• 64-bit Python and 64-bit apps support (but 32-bit Python is recommended for 32-bit apps)
• Python 2.x/3.x compatibility
• [!] Added pyWin32 dependency (silent install by pip for 2.7 and 3.1+)
• Improvements for Toolbar, TreeView, UpDown and DateTimePicker wrappers
• Improved best_match algorithm allows names like ToolbarFile
• Clicks can be performed with pressed Ctrl or Shift
• Drag-n-drop and scrolling methods (DragMouse, DragMouseInput, MouseWheelInput)
• Improved menu support: handling OWNERDRAW menu items; access by command_id (like $23453)
• Resolved issues with py2exe and cx_freeze
• RemoteMemoryBlock can now detect memory corruption by checking guard signature
• Upgraded taskbar module
• sysinfo module for checking 32-bit or 64-bit OS and Python
• set_foreground flag in TypeKeys method for typing into in-place controls
• flags create_new_console and wait_for_idle in Application.start method

• Change calculation of distance in findbestmatch.GetNonTextControlName()
  so that it does not need to square or get the square root to
  find the real distance - as we only need to compare values - not have
  the actual distance. (Thanks to Stefaan Himpe)
• Compiled regular expression patterns before doing the match to
  avoid compiling the regular expression for window that is being
  tested (Thanks to Stefaan Himpe)
• Made it easier to add your own control tests by adding a file
  extra_tests.py which needs to export a ModifyRegisteredTests() method.
  Also cleaned up the code a little.
• Updated notepad_fast.py to make it easier to profile (added a method)
• Changed WrapHandle to use a cache for classes it has matched - this is
  to avoid having to match against all classes constantly.
• Changed default timeout in SendMessageTimeout to .001 seconds from .4
  seconds this results in a significant speedup. Will need to make this
  value modifiable via the timing module/routine.
• WaitNot was raising an error if the control was not found - it should
  have returned (i.e. success - control is not in any particular state
  because it does not exist!).
• Added ListViewWrapper.Deselect() per Chistophe Keller's suggestion.
  While I was at it I added a check on the item value passed in and added
  a call to WaitGuiIdle(self) so that the control has a chance to process
  the message.
• Changed doc templates and moved dependencies into pywinauto
  subversion to ensure that all files were availabe at www.openqa.org and
  that they are not broken when viewed there.
• Moved all timing information into the timings.Timings class. There are
  some simple methods for changing the timings.

• Added automatic Application data collection which can be used when
  running the same test on a different spoken language version. Support
  is still preliminary and is expected to change. Please treat as early
  Alpha.

  If you have a different language version of Windows then you can try
  this out by running the notepad_fast.py example with the langauge
  argument e.g.

    examples\notepad_fast.py language

This will load the application data from the supplied file
notepad_fast.pkl and use it for finding the right menu items and
controls to select.

• Test implementation to make it easier to start using an application.
  Previously you needed to write code like

    app = Application().connect_(title = 'Find')
    app.Find.Close.Click()
    app.NotePad.MenuSelect("File->Exit")

1st change was to implement static methods start() and
connect(). These methods return a new Application instance
so the above code becomes

    app = Application.connect(title = 'Find')
    app.Find.Close.Click()
    app.NotePad.MenuSelect("File->Exit")

I also wanted to make it easier to start working with a simple
application - that may or may not have only one dialog. To make this
situation easier I made window_() not throw if the application has not
been start()ed or connect()ed first. This leads to simpler code
like

    app = Application()
    app.Find.Close.Click()
    app.NotePad.MenuSelect("File->Exit")

What happens here is that when you execute any of Application.window_(),
Application.__getattr__() or Application.__getitem__() when the
application hasn't been connected or started. It looks for the window
that best matches your specification and connects the application to
that process.

This is extra functionality - existing connect_() and
start_() methods still exist

• Fixed HwndWrapper.SetFocus() so that it would work even if the window
  was not in the foreground. (it now makes the window foreground as well
  as giving it focus). This overcomes a restriction in Windows where
  you can only change the foreground window if you own the foreground
  window.
• Changed some 2.4'isms that an anonymous commenter left on my blog :-)
  with these changes pywinauto should run on Python 2.3 (though I haven't
  done extensive testing).
• Commented out controls.common_controls.TabControlWrapper.GetTabState()
  and TabStates() as these did not seem to be returning valid values anyway.
• Fixed documentation issues were parts of the documentation were not
  getting generated to the HTML files.
• Fixed issue where MenuSelect would sometimes not work as expected.
  Some Menu actions require that the window that owns the menu be active.
  Added a call to SetFocus() before selecting a menu item to ensure that
  the window was active.
• Fixed Bug 1452832 where clipboard was not closed in clipboard.GetData()
• Added more unit tests now up to 248 from 207

• Added wrapper classes for Menus and MenuItems this enabled cleaner
  interaction with Menu's. It also gives more functionality - you can now
  programmatically Click() on menus, and query if a menu item is checked
  or not.
• Added application.WindowSpecification.Wait() and WaitNot() methods.
  These methods allow you to wait for a control to exist, be visible,
  be enabled, be ready (both enabled and visible!) or to wait for the
  control to not be in any of these states. WaitReady(),
  WaitNotEnabled(), WaitNotVisible() now use these methods. I was able to also
  add the missing methods WaitNotReady(), WaitEnabled(), WaitVisible(),
  WaitExists(), WaitNotExists(). Please use Wait() and WaitNot() as I have
  Deprecated these Wait* methods.
• Slightly modified timeout waits for control resolution so that a timed
  function more accurately follows the timeout value specified.
• Added application.Application.start() and connect() static methods. These
  methods are factory methods in that they will return an initialized Application
  instance. They work exactly the same as start_() and connect_() as they are
  implemented in terms of those.

    from pywinauto.application import Application
    notepad = Application.start("notepad")
    same_notepad = Application.connect(path = "notepad")

• Updated the examples to follow changes to the code - and to make them a little
  more robust.
• Added a new Controls Overview document page which lists all the actions on
  all controls.
• Added more unit tests now up to 207 from 134 (added 68 tests)

• Quick release to get many changes out there - but this release has
  been less tested then I would like for a .3 release.
• Allow access to non text controls using the closest Text control.
  This closest text control will normally be the static/label associated
  with the control. For example in Notepad, Format->Font dialog, the 1st
  combobox can be refered to as "FontComboBox" rather than "ComboBox1"
• Added a new control wrapper - PopupMenuWrapper for context menu's
  You can now work easily with context menu's
  e.g.

     app.Notepad.Edit.RightClick()
     # need to use MenuClick rather then MenuSelect
     app.PopupMenu.MenuClick("Select All")
     app.Notepad.Edit.RightClick()
     app.PopupMenu.MenuClick("Copy")

I could think of merging the RightClick() and MenuSelect() into one method
ContextMenuSelect() if that makes sense to most people.

• Added Support for Up-Down controls

• Not all top level windows now have a FriendlyClassName of "Dialog".
  I changed this because it made it hard to get windows of a particular
  class. For example the main Notepad window has a class name of "Notepad".

  This was primarily implemented due to work I did getting the System Tray.

• Renamed StatusBarWrapper.PartWidths() to PartRightEdges() as this
  is more correct for what it returns.

• Changed HwndWrapper.Text() and SetText() to WindowText() and
  SetWindowText() respectively to try and make it clearer that it is
  the text returned by GetWindowText and not the text that is visible
  on the control. This change also suggested that EditWrapper.SetText()
  be changed to SetEditText() (though this is not a hard requirement
  EditWrapper.SetText() still exists - but may be deprecated.

• Added ClickInput, DoubleClickInput, RightClickInput, PressMouseInput
  ReleaseMouseInput to HwndWrapper - these use SendInput rather then
  WM_LBUTTONDOWN, WM_RBUTTONUP, etc used by Click, DoubleClick etc.

  I also added a MenuClick method that allows you to click on menu
  items. This means you can now 'physically' drop menus down.

• Some further working with tooltips that need to be cleaned up.

• Fixed a bug where coordinates passed to any of the Click operations had
  the X and Y coordinates swapped.

• Added new MenuItem and Menu classes that are to the most part hidden
  but you can get a menu item by doing

    app.Notepad.MenuItem("View")
    app.Notepad.MenuItem("View->Status Bar")

MenuItems have various actions so for example you can use
MenuItem.IsChecked() to check if the menu item is checked.
Among other methods there are Click() and Enabled().

• Modified the 'best match' algorithm for finding controls.
  It now searches a couple of times, and tries to find the best
  fit for the text passed to it. The idea here is to make it more
  "Select what I want - not that other thing that looks a bit like
  what I want!". It is possible this change could mean you need to
  use new identifiers in scripts - but in general very little modification
  should be necessary.

  There was also a change to the algorithm that looked for the closest
  text control. It missed some obvious controls in the previous
  implementation. It also had a bug for controls above the control
  rather than to the left.

• Added a new example scripts SaveFromInternetExplorer.py and
  SaveFromFirefox.py which show automating downloading of a page
  from either of these browsers.

• Added yet more unit tests, there are now a total of 134 tests.

• Changed how windows are searched for (from application)
  This change should not be a significant change for users
• Started adding unit tests (and the have already uncovered bugs
  that been fixed). They also point to areas of missing functionality
  that will be added with future updates
• Changed from property access to Control attributes to function access
  If your code was accessing properties of controls then this might be a
  significant change! The main reasons for doing this were due to the
  inheritability of properties (or lack there-of!) and the additional
  scaffolding that was required to define them all.
• Updated the DialogWrapper.MenuSelect() method to notify the parent
  that it needs to initialize the menu's before it retrieves the items
• Added functionality to associate 'non-text' controls with the 'text'
  control closest to them. This allows controls to be referenced by

    app.dlg.<Nearby_text><Window_class>

e.g. to reference the "Footer" edit control in the Page Setup dialog
you could use

    app.PageSetup.FooterEdit

• Added a MoveWindow method to HwndWrapper
• Did some more cleanup (fixing pylint warnings) but still not finished
• Added some better support for .NET controls (not to be considered final)

• Wrote doc strings for all modules, classes and functions
• Ran pychecker and pylint and fixed some errors/warning
• changed

    _connect, _start, _window, _control, _write

respectively to

    connect_, start_, window_, connect_, write_

If you forget to change _window, _connect and _start then you will probably get the following error:

    TypeError: '_DynamicAttributes' object is not callable

• pywinauto is now a package name - you need to import it or its modules
• Changes to the code to deal with pywinauto package name
• Fixed searching for windows if a Parent is passed in
• Added Index to retrieved MenuItem dictionary
• Added a check to ensure that a windows Handle is a valid window
• Refactored some of the methods in common_controls
• Refactored how FriendlyClassName is discovered (and still not really happy!)