Releases: pywinauto/pywinauto
Better Unicode support for SetEditText/TypeKeys and menu items
- 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
.
- support Unicode symbols in the
- 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
methodClick
is renamed toClickInput
whileClick = 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.
Improve ListView, new methods for CPU usage, DPI awareness
- 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 withTreeViewWrapper
.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
methodsCheck/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).
Several fixes, more tests
- 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()
andactionlogger.disable()
.
For those who are familiar with standardlogging
module there's methodactionlogger.set_level(level)
.
64-bit Py2/Py3 compatibility
- 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 likeToolbarFile
- 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 inTypeKeys
method for typing into in-place controls - flags
create_new_console
andwait_for_idle
inApplication.start
method
Performance tune-ups
- 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 aModifyRegisteredTests()
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 toWaitGuiIdle(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 Application data - now useful for localization testing
-
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 thenotepad_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()
andTabStates()
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 toSetFocus()
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
More refactoring, more tests
- 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()
andWaitNot()
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 methodsWaitNotReady()
,WaitEnabled()
,WaitVisible()
,
WaitExists()
,WaitNotExists()
. Please useWait()
andWaitNot()
as I have
Deprecated theseWait*
methods. - Slightly modified timeout waits for control resolution so that a timed
function more accurately follows the timeout value specified. - Added
application.Application.start()
andconnect()
static methods. These
methods are factory methods in that they will return an initialized Application
instance. They work exactly the same asstart_()
andconnect_()
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)
Small Release number - big changes
- 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()
toPartRightEdges()
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.
Significant refactoring
- 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 toHwndWrapper
- Did some more cleanup (fixing pylint warnings) but still not finished
- Added some better support for .NET controls (not to be considered final)
Many changes, few visible
- 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!)