Python + pywinauto-ൽ ഡെസ്ക്ടോപ്പ് GUI ഓട്ടോമേറ്റ് ചെയ്യുന്നു: MS UI ഓട്ടോമേഷനുമായി എങ്ങനെ ചങ്ങാത്തം കൂടാം

പൈത്തൺ ലൈബ്രറി pywinauto വിൻഡോസിൽ ഡെസ്ക്ടോപ്പ് GUI ആപ്ലിക്കേഷനുകൾ ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു ഓപ്പൺ സോഴ്സ് പ്രോജക്റ്റാണ്. കഴിഞ്ഞ രണ്ട് വർഷമായി, അതിൽ പുതിയ പ്രധാന സവിശേഷതകൾ പ്രത്യക്ഷപ്പെട്ടു:

• MS UI ഓട്ടോമേഷൻ സാങ്കേതികവിദ്യയ്ക്കുള്ള പിന്തുണ. ഇന്റർഫേസ് ഒന്നുതന്നെയാണ്, ഇപ്പോൾ ഇത് പിന്തുണയ്ക്കുന്നു: WinForms, WPF, Qt5, Windows Store (UWP) അങ്ങനെ പലതും - Windows-ൽ ഉള്ള മിക്കവാറും എല്ലാം.
• ബാക്കെൻഡ്/പ്ലഗിനുകളുടെ സിസ്റ്റം (നിലവിൽ അവയിൽ രണ്ടെണ്ണം ഹുഡിന് കീഴിൽ ഉണ്ട്: സ്ഥിരസ്ഥിതി "win32" പുതിയതും "uia"). തുടർന്ന് ഞങ്ങൾ ക്രോസ്-പ്ലാറ്റ്ഫോമിലേക്ക് സുഗമമായി നീങ്ങുന്നു.
• മൗസിനും കീബോർഡിനുമുള്ള Win32 ഹുക്കുകൾ (പൈഹൂക്കിന്റെ സ്പിരിറ്റിലുള്ള ഹോട്ട് കീകൾ).

ഡെസ്‌ക്‌ടോപ്പ് ഓട്ടോമേഷനായി ഓപ്പൺ സോഴ്‌സിൽ എന്തെല്ലാം ലഭ്യമാണ് എന്നതിന്റെ ഒരു ചെറിയ അവലോകനവും ഞങ്ങൾ നൽകും (ഗുരുതരമായ ഒരു താരതമ്യമായി അഭിനയിക്കാതെ).

ഈ ലേഖനം മിൻസ്കിൽ നടന്ന SQA Days 20 കോൺഫറൻസിൽ നിന്നുള്ള ഒരു റിപ്പോർട്ടിന്റെ ഭാഗിക ട്രാൻസ്ക്രിപ്റ്റാണ് (വീഡിയോടേപ്പ് и സ്ലൈഡുകൾ), ഭാഗികമായി റഷ്യൻ പതിപ്പ് ഗൈഡ് ആരംഭിക്കുക pywinauto-യ്‌ക്ക്.

• അടിസ്ഥാന സമീപനങ്ങൾ
  • കോർഡിനേറ്റ് രീതി
  • റഫറൻസ് ഇമേജ് തിരിച്ചറിയൽ
  • പ്രവേശനക്ഷമത സാങ്കേതികവിദ്യ
• അടിസ്ഥാന ഡെസ്ക്ടോപ്പ് പ്രവേശനക്ഷമത സാങ്കേതികവിദ്യകൾ
  • നല്ല പഴയ Win32 API
  • മൈക്രോസോഫ്റ്റ് യുഐ ഓട്ടോമേഷൻ
  • AT-SPI (ലിനക്സ്)
  • Apple പ്രവേശനക്ഷമത API
• Pywinauto ഉപയോഗിച്ച് എങ്ങനെ ആരംഭിക്കാം
  • ഓട്ടോമേഷനുള്ള എൻട്രി പോയിന്റുകൾ
  • വിൻഡോ/എലമെന്റ് സ്പെസിഫിക്കേഷനുകൾ
  • ആട്രിബ്യൂട്ടും കീയും വഴിയുള്ള ആക്‌സസ്സിന്റെ മാന്ത്രികത
  • മാന്ത്രിക നാമങ്ങൾക്കുള്ള അഞ്ച് നിയമങ്ങൾ

ഈ മേഖലയിലെ ഓപ്പൺ സോഴ്‌സിന്റെ ഒരു ഹ്രസ്വ അവലോകനത്തോടെ നമുക്ക് ആരംഭിക്കാം. ഡെസ്‌ക്‌ടോപ്പ് GUI ആപ്ലിക്കേഷനുകൾക്കായി, സെലിനിയം ഉള്ള വെബിനേക്കാൾ എല്ലാം കുറച്ചുകൂടി സങ്കീർണ്ണമാണ്. പ്രധാന സമീപനങ്ങൾ ഇതാ:

കോർഡിനേറ്റ് രീതി

ക്ലിക്ക് പോയിന്റുകൾ ഹാർഡ്കോഡ് ചെയ്യുക, വിജയകരമായ ഹിറ്റുകൾ ഞങ്ങൾ പ്രതീക്ഷിക്കുന്നു.
[+] ക്രോസ്-പ്ലാറ്റ്ഫോം, നടപ്പിലാക്കാൻ എളുപ്പമാണ്.
[+] ടെസ്റ്റ് റെക്കോർഡിംഗുകൾ "റെക്കോർഡ്-റീപ്ലേ" ചെയ്യുന്നത് എളുപ്പമാണ്.
[-] സ്ക്രീൻ റെസല്യൂഷൻ, തീം, ഫോണ്ടുകൾ, വിൻഡോ വലുപ്പങ്ങൾ മുതലായവ മാറ്റുന്നതിൽ ഏറ്റവും അസ്ഥിരമാണ്.
[-] വലിയ പിന്തുണാ ശ്രമങ്ങൾ ആവശ്യമാണ്; സ്ക്രാച്ചിൽ നിന്ന് ടെസ്റ്റുകൾ പുനരുജ്ജീവിപ്പിക്കുന്നത് അല്ലെങ്കിൽ സ്വമേധയാ പരീക്ഷിക്കുന്നത് പലപ്പോഴും എളുപ്പമാണ്.
[-] പ്രവർത്തനങ്ങൾ മാത്രം ഓട്ടോമേറ്റ് ചെയ്യുന്നു; ഡാറ്റ പരിശോധിക്കുന്നതിനും വീണ്ടെടുക്കുന്നതിനും മറ്റ് രീതികളുണ്ട്.

ടൂളുകൾ (ക്രോസ്-പ്ലാറ്റ്ഫോം): ഓട്ടോപി, PyAutoGUI, PyUserInput കൂടാതെ മറ്റു പലതും. സാധാരണഗതിയിൽ, കൂടുതൽ സങ്കീർണ്ണമായ ടൂളുകളിൽ ഈ പ്രവർത്തനം ഉൾപ്പെടുന്നു (എല്ലായ്പ്പോഴും ക്രോസ്-പ്ലാറ്റ്ഫോം അല്ല).

കോർഡിനേറ്റ് രീതിക്ക് മറ്റ് സമീപനങ്ങളെ പൂർത്തീകരിക്കാൻ കഴിയുമെന്ന് പറയേണ്ടതാണ്. ഉദാഹരണത്തിന്, ഇഷ്‌ടാനുസൃത ഗ്രാഫിക്‌സിനായി, നിങ്ങൾക്ക് ആപേക്ഷിക കോർഡിനേറ്റുകളിൽ ക്ലിക്കുചെയ്യാം (വിൻഡോയുടെ / ഘടകത്തിന്റെ മുകളിൽ ഇടത് കോണിൽ നിന്ന്, മുഴുവൻ സ്‌ക്രീനിലും അല്ല) - ഇത് സാധാരണയായി തികച്ചും വിശ്വസനീയമാണ്, പ്രത്യേകിച്ചും നിങ്ങൾ അതിന്റെ നീളം / വീതി കണക്കിലെടുക്കുകയാണെങ്കിൽ. മുഴുവൻ ഘടകവും (അപ്പോൾ വ്യത്യസ്ത സ്‌ക്രീൻ റെസല്യൂഷനുകൾ ഉപദ്രവിക്കില്ല).

മറ്റൊരു ഓപ്ഷൻ: ടെസ്റ്റിംഗിനായി സ്ഥിരതയുള്ള ക്രമീകരണങ്ങളുള്ള ഒരു മെഷീൻ മാത്രം അനുവദിക്കുക (ക്രോസ്-പ്ലാറ്റ്ഫോമല്ല, ചില സന്ദർഭങ്ങളിൽ ഇത് നല്ലതാണ്).

റഫറൻസ് ഇമേജ് തിരിച്ചറിയൽ

[+] ക്രോസ്-പ്ലാറ്റ്ഫോം
[+-] താരതമ്യേന വിശ്വസനീയമാണ് (കോർഡിനേറ്റ് രീതിയേക്കാൾ മികച്ചത്), പക്ഷേ ഇപ്പോഴും ചില തന്ത്രങ്ങൾ ആവശ്യമാണ്.
[-+] താരതമ്യേന പതുക്കെ, കാരണം തിരിച്ചറിയൽ അൽഗോരിതങ്ങൾക്കായി CPU ഉറവിടങ്ങൾ ആവശ്യമാണ്.
[-] ടെക്സ്റ്റ് റെക്കഗ്നിഷൻ (OCR), ചട്ടം പോലെ, ചോദ്യത്തിന് പുറത്താണ് => ടെക്സ്റ്റ് ഡാറ്റ ലഭിക്കില്ല. എനിക്കറിയാവുന്നിടത്തോളം, നിലവിലുള്ള OCR സൊല്യൂഷനുകൾ ഇത്തരത്തിലുള്ള ജോലികൾക്ക് വളരെ വിശ്വസനീയമല്ല, മാത്രമല്ല അവ വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്നില്ല (ഇത് ഇതിനകം അങ്ങനെയല്ലെങ്കിൽ അഭിപ്രായങ്ങളിൽ സ്വാഗതം).

ഉപകരണങ്ങൾ: സികുലി, ലാക്കി (സികുലി-അനുയോജ്യമായ, ശുദ്ധമായ പൈത്തൺ), PyAutoGUI.

പ്രവേശനക്ഷമത സാങ്കേതികവിദ്യ

[+] ഏറ്റവും വിശ്വസനീയമായ രീതി, കാരണം സിസ്റ്റമോ ചട്ടക്കൂടോ എങ്ങനെ റെൻഡർ ചെയ്‌താലും, ടെക്‌സ്‌റ്റ് ഉപയോഗിച്ച് തിരയാൻ നിങ്ങളെ അനുവദിക്കുന്നു.
[+] ടെക്‌സ്‌റ്റ് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു => ടെസ്റ്റ് ഫലങ്ങൾ പരിശോധിക്കുന്നത് എളുപ്പമാണ്.
[+] ചട്ടം പോലെ, ഏറ്റവും വേഗതയേറിയത്, കാരണം മിക്കവാറും CPU ഉറവിടങ്ങളൊന്നും ഉപയോഗിക്കുന്നില്ല.
[-] ഒരു ക്രോസ്-പ്ലാറ്റ്ഫോം ടൂൾ നിർമ്മിക്കുന്നത് ബുദ്ധിമുട്ടാണ്: തീർച്ചയായും എല്ലാ ഓപ്പൺ സോഴ്സ് ലൈബ്രറികളും ഒന്നോ രണ്ടോ പ്രവേശനക്ഷമത സാങ്കേതികവിദ്യകളെ പിന്തുണയ്ക്കുന്നു. Windows/Linux/MacOS-നെ TestComplete, UFT അല്ലെങ്കിൽ Squish പോലുള്ള പണമടച്ചുള്ളവ ഒഴികെ മറ്റാരും പൂർണ്ണമായി പിന്തുണയ്ക്കുന്നില്ല.
[-] അത്തരം സാങ്കേതികവിദ്യ എല്ലായ്പ്പോഴും തത്വത്തിൽ ലഭ്യമല്ല. ഉദാഹരണത്തിന്, VirtualBox-നുള്ളിൽ ലോഡിംഗ് സ്ക്രീൻ പരിശോധിക്കുന്നു - ഇമേജ് തിരിച്ചറിയൽ ഇല്ലാതെ ഇത് ചെയ്യാൻ കഴിയില്ല. എന്നാൽ പല ക്ലാസിക് കേസുകളിലും, പ്രവേശനക്ഷമത സമീപനം ഇപ്പോഴും ബാധകമാണ്. ഇത് കൂടുതൽ ചർച്ച ചെയ്യും.

ഉപകരണങ്ങൾ: TestStack.White C#-ൽ, Winium.Desktop C#-ൽ (സെലിനിയം അനുയോജ്യം), MS WinApp ഡ്രൈവർ C#-ൽ (Appium അനുയോജ്യം), pywinauto, pyatom (LDTP അനുയോജ്യം) പൈത്തൺ-യുഐഎ ഓട്ടോമേഷൻ-ഫോർ-വിൻഡോസ്, റോ ഓട്ടോമേഷൻ റൂബിയിൽ, എൽ.ഡി.ടി.പി (ലിനക്സ് ഡെസ്ക്ടോപ്പ് ടെസ്റ്റിംഗ് പ്രോജക്റ്റ്) അതിന്റെ വിൻഡോസ് പതിപ്പും കോബ്ര.

പ്രവേശനക്ഷമതാ സാങ്കേതികവിദ്യകളെ അടിസ്ഥാനമാക്കിയുള്ള ഏക ക്രോസ്-പ്ലാറ്റ്ഫോം ഓപ്പൺ സോഴ്സ് ടൂൾ (കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ലൈബ്രറികളുടെ ഒരു കുടുംബം) LDTP ആയിരിക്കാം. എന്നിരുന്നാലും, ഇത് വളരെ ജനപ്രിയമല്ല. ഞാൻ ഇത് സ്വയം ഉപയോഗിച്ചിട്ടില്ല, പക്ഷേ അവലോകനങ്ങൾ അനുസരിച്ച്, അതിന്റെ ഇന്റർഫേസ് ഏറ്റവും സൗകര്യപ്രദമല്ല. നിങ്ങൾക്ക് പോസിറ്റീവ് ഫീഡ്ബാക്ക് ഉണ്ടെങ്കിൽ, അഭിപ്രായങ്ങളിൽ അത് പങ്കിടുക.

ടെസ്റ്റ് ബാക്ക്ഡോർ (അല്ലെങ്കിൽ ഇൻഡോർ ബൈക്ക്)

ക്രോസ്-പ്ലാറ്റ്ഫോം ആപ്ലിക്കേഷനുകൾക്കായി, ടെസ്റ്റബിലിറ്റി ഉറപ്പാക്കാൻ ഡവലപ്പർമാർ തന്നെ പലപ്പോഴും ഒരു ആന്തരിക സംവിധാനം സൃഷ്ടിക്കുന്നു. ഉദാഹരണത്തിന്, അവർ ആപ്ലിക്കേഷനിൽ ഒരു സേവന ടിസിപി സെർവർ സൃഷ്ടിക്കുന്നു, ടെസ്റ്റുകൾ അതിലേക്ക് കണക്റ്റുചെയ്യുകയും ടെക്സ്റ്റ് കമാൻഡുകൾ അയയ്ക്കുകയും ചെയ്യുന്നു: എന്തിൽ ക്ലിക്ക് ചെയ്യണം, ഡാറ്റ എവിടെ നിന്ന് ലഭിക്കും മുതലായവ. വിശ്വസനീയമാണ്, പക്ഷേ സാർവത്രികമല്ല.

അടിസ്ഥാന ഡെസ്ക്ടോപ്പ് പ്രവേശനക്ഷമത സാങ്കേതികവിദ്യകൾ

നല്ല പഴയ Win32 API

WPF-ന്റെ റിലീസിന് മുമ്പ് എഴുതിയ മിക്ക വിൻഡോസ് ആപ്ലിക്കേഷനുകളും വിൻഡോസ് സ്റ്റോറും ഒരു തരത്തിൽ അല്ലെങ്കിൽ മറ്റൊരു രീതിയിൽ Win32 API-യിൽ നിർമ്മിച്ചതാണ്. അതായത്, MFC, WTL, C++ Builder, Delphi, VB6 - ഈ ഉപകരണങ്ങളെല്ലാം Win32 API ഉപയോഗിക്കുന്നു. വിൻഡോസ് ഫോമുകൾ പോലും പ്രധാനമായും Win32 API അനുയോജ്യമാണ്.

ഉപകരണങ്ങൾ: ഓട്ടോഇറ്റ് (വിബിക്ക് സമാനമായത്) പൈത്തൺ റാപ്പറും pautoit, ഓട്ടോ ഹോട്ട്കീ (സ്വന്തം ഭാഷ, ഒരു IDispatch COM ഇന്റർഫേസ് ഉണ്ട്) pywinauto (പൈത്തൺ) റോ ഓട്ടോമേഷൻ (റൂബി) win32-autogui (റൂബി).

മൈക്രോസോഫ്റ്റ് യുഐ ഓട്ടോമേഷൻ

പ്രധാന നേട്ടം: MS UI ഓട്ടോമേഷൻ സാങ്കേതികവിദ്യ അപൂർവമായ ഒഴിവാക്കലുകളോടെ വിൻഡോസിലെ ഭൂരിഭാഗം GUI ആപ്ലിക്കേഷനുകളെയും പിന്തുണയ്ക്കുന്നു. പ്രശ്നം: Win32 API-യെക്കാൾ പഠിക്കുന്നത് അത്ര എളുപ്പമല്ല. അല്ലാത്തപക്ഷം, ആരും അതിന്മേൽ പൊതികൾ ഉണ്ടാക്കില്ല.

വാസ്തവത്തിൽ, ഇത് ഇഷ്‌ടാനുസൃത COM ഇന്റർഫേസുകളുടെ ഒരു കൂട്ടമാണ് (പ്രധാനമായും UIAutomationCore.dll), കൂടാതെ രൂപത്തിൽ ഒരു .NET റാപ്പറും ഉണ്ട് namespace System.Windows.Automation. വഴിയിൽ, ഇതിന് അവതരിപ്പിച്ച ഒരു ബഗ് ഉള്ളതിനാൽ ചില UI ഘടകങ്ങൾ നഷ്‌ടമായേക്കാം. അതിനാൽ, UIAutomationCore.dll നേരിട്ട് ഉപയോഗിക്കുന്നതാണ് നല്ലത് (നിങ്ങൾ C#-ൽ UiaComWrapper-നെക്കുറിച്ച് കേട്ടിട്ടുണ്ടെങ്കിൽ, ഇത് ഇതാണ്).

COM ഇന്റർഫേസുകളുടെ തരങ്ങൾ:

(1) അറിയപ്പെടുന്ന അടിസ്ഥാന - "എല്ലാ തിന്മകളുടെയും റൂട്ട്". ഏറ്റവും താഴ്ന്ന നില, ഒരിക്കലും ഉപയോക്തൃ സൗഹൃദമല്ല.
(2) ഐഡിസ്പാച്ചും ഡെറിവേറ്റീവുകളും (ഉദാ Excel.Application), ഇത് win32com.client പാക്കേജ് ഉപയോഗിച്ച് പൈത്തണിൽ ഉപയോഗിക്കാം (pyWin32-ൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു). ഏറ്റവും സൗകര്യപ്രദവും മനോഹരവുമായ ഓപ്ഷൻ.
(3) ഒരു മൂന്നാം കക്ഷി പൈത്തൺ പാക്കേജിന് പ്രവർത്തിക്കാൻ കഴിയുന്ന ഇഷ്‌ടാനുസൃത ഇന്റർഫേസുകൾ കോംടൈപ്പുകൾ.

ഉപകരണങ്ങൾ: TestStack.White C#-ൽ, pywinauto 0.6.0+, Winium.Desktop C#-ൽ, പൈത്തൺ-യുഐഎ ഓട്ടോമേഷൻ-ഫോർ-വിൻഡോസ് (UIAutomationCore.dll വഴിയുള്ള C റാപ്പറുകളുടെ സോഴ്സ് കോഡ് വെളിപ്പെടുത്തിയിട്ടില്ല) റോ ഓട്ടോമേഷൻ റൂബിയിൽ.

എടി-എസ്പിഐ

ലിനക്സ് കുടുംബത്തിലെ മിക്കവാറും എല്ലാ അക്ഷങ്ങളും എക്സ് വിൻഡോ സിസ്റ്റത്തിലാണ് നിർമ്മിച്ചിരിക്കുന്നത് എന്ന വസ്തുത ഉണ്ടായിരുന്നിട്ടും (ഫെഡോറ 25-ൽ, "എക്സ്" വെയ്‌ലാൻഡിലേക്ക് മാറ്റി), "എക്സ്" നിങ്ങളെ ടോപ്പ് ലെവൽ വിൻഡോകളും മൗസും മാത്രം പ്രവർത്തിപ്പിക്കാൻ അനുവദിക്കുന്നു. കീബോർഡ്. ബട്ടണുകൾ, ലിസ്റ്റ് ബോക്സുകൾ തുടങ്ങിയവയുടെ വിശദമായ വിശകലനത്തിന്, AT-SPI സാങ്കേതികവിദ്യയുണ്ട്. ഏറ്റവും ജനപ്രിയമായ വിൻഡോ മാനേജർമാർക്ക് AT-SPI രജിസ്ട്രി ഡെമൺ എന്ന് വിളിക്കപ്പെടുന്നു, അത് ആപ്ലിക്കേഷനുകൾക്കായി ഒരു ഓട്ടോമേറ്റഡ് GUI നൽകുന്നു (കുറഞ്ഞത് Qt, GTK എന്നിവയെങ്കിലും പിന്തുണയ്ക്കുന്നു).

ഉപകരണങ്ങൾ: pyatspi2.

pyatspi2, എന്റെ അഭിപ്രായത്തിൽ, PyGObject പോലുള്ള നിരവധി ഡിപൻഡൻസികൾ അടങ്ങിയിരിക്കുന്നു. സാങ്കേതികവിദ്യ തന്നെ ഒരു സാധാരണ ഡൈനാമിക് ലൈബ്രറിയായി ലഭ്യമാണ് libatspi.so. ഒരു ഉണ്ട് റഫറൻസ് മാനുവൽ. pywinauto ലൈബ്രറിക്കായി, AT-SPI പിന്തുണ ഈ രീതിയിൽ നടപ്പിലാക്കാൻ ഞങ്ങൾ പദ്ധതിയിടുന്നു: libatspi.so, ctypes മൊഡ്യൂൾ എന്നിവ ലോഡുചെയ്യുന്നതിലൂടെ. ആവശ്യമായ പതിപ്പ് ഉപയോഗിക്കുന്നതിൽ മാത്രം ഒരു ചെറിയ പ്രശ്നമുണ്ട്, കാരണം GTK+, Qt ആപ്ലിക്കേഷനുകൾക്ക് അവ അല്പം വ്യത്യസ്തമാണ്. പൂർണ്ണ ലിനക്സ് പിന്തുണയോടെ pywinauto 0.7.0 ന്റെ റിലീസ് 2018 ന്റെ ആദ്യ പകുതിയിൽ പ്രതീക്ഷിക്കാം.

Apple പ്രവേശനക്ഷമത API

MacOS-ന് സ്വന്തം ഓട്ടോമേഷൻ ഭാഷയുണ്ട്, AppleScript. പൈത്തണിൽ ഇതുപോലൊന്ന് നടപ്പിലാക്കാൻ, തീർച്ചയായും, നിങ്ങൾ ObjectiveC-ൽ നിന്നുള്ള ഫംഗ്ഷനുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്. ആരംഭിക്കുന്നത്, MacOS 10.6-ൽ, pyobjc പാക്കേജ് മുൻകൂട്ടി ഇൻസ്റ്റാൾ ചെയ്ത പൈത്തണിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. pywinauto-യിൽ ഭാവി പിന്തുണയ്‌ക്കായി ഡിപൻഡൻസികൾ ലിസ്റ്റ് ചെയ്യുന്നതും ഇത് എളുപ്പമാക്കും.

ഉപകരണങ്ങൾ: ആപ്പിൾ സ്ക്രിപ്റ്റ് ഭാഷയ്ക്ക് പുറമേ, ഇത് ശ്രദ്ധിക്കേണ്ടതാണ് ATOMac, aka pyatom. ഇത് എൽ‌ഡി‌ടി‌പിയുമായി പൊരുത്തപ്പെടുന്ന ഇന്റർഫേസ് ആണ്, പക്ഷേ ഒരു ഒറ്റപ്പെട്ട ലൈബ്രറി കൂടിയാണ്. അതിനുണ്ട് macO-കളിലെ iTunes ഓട്ടോമേഷന്റെ ഉദാഹരണം, എന്റെ വിദ്യാർത്ഥി എഴുതിയത്. അറിയപ്പെടുന്ന ഒരു പ്രശ്നമുണ്ട്: ഫ്ലെക്സിബിൾ ടൈമിംഗുകൾ പ്രവർത്തിക്കുന്നില്ല (രീതികൾ waitFor*). എന്നാൽ മൊത്തത്തിൽ, ഒരു മോശം കാര്യമല്ല.

Pywinauto ഉപയോഗിച്ച് എങ്ങനെ ആരംഭിക്കാം

ഒരു GUI ഒബ്‌ജക്‌റ്റ് ഇൻസ്‌പെക്ടർ (സ്‌പൈ ടൂൾ എന്ന് വിളിക്കുന്നത്) ഉപയോഗിച്ച് സ്വയം ആയുധമാക്കുക എന്നതാണ് ആദ്യപടി. ഉള്ളിൽ നിന്ന് ആപ്ലിക്കേഷൻ പഠിക്കാൻ ഇത് നിങ്ങളെ സഹായിക്കും: മൂലകങ്ങളുടെ ശ്രേണി എങ്ങനെ ഘടനാപരമാണ്, എന്തൊക്കെ പ്രോപ്പർട്ടികൾ ലഭ്യമാണ്. ഏറ്റവും പ്രശസ്തമായ സൈറ്റ് ഇൻസ്പെക്ടർമാർ:

• സ്പൈ++ - എക്സ്പ്രസ് അല്ലെങ്കിൽ കമ്മ്യൂണിറ്റി പതിപ്പ് ഉൾപ്പെടെ, വിഷ്വൽ സ്റ്റുഡിയോയിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. Win32 API ഉപയോഗിക്കുന്നു. അദ്ദേഹത്തിന്റെ ക്ലോണും അറിയപ്പെടുന്നു ഓട്ടോഇറ്റ് വിൻഡോ വിവരം.
• Inspect.exe - Windows SDK-യിൽ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. നിങ്ങൾ ഇത് ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ടെങ്കിൽ, 64-ബിറ്റ് വിൻഡോസിൽ നിങ്ങൾക്ക് അത് ഫോൾഡറിൽ കണ്ടെത്താനാകും C:Program Files (x86)Windows Kits<winver>binx64. ഇൻസ്പെക്ടറിൽ തന്നെ നിങ്ങൾ ഒരു മോഡ് തിരഞ്ഞെടുക്കേണ്ടതുണ്ട് യുഐ ഓട്ടോമേഷൻ എംഎസ് എഎയ്ക്ക് പകരം (സജീവ പ്രവേശനക്ഷമത, യുഐ ഓട്ടോമേഷന്റെ പൂർവ്വികൻ).

ആപ്ലിക്കേഷൻ പരിശോധിച്ച ശേഷം, ഞങ്ങൾ ഉപയോഗിക്കുന്ന ബാക്കെൻഡ് ഞങ്ങൾ തിരഞ്ഞെടുക്കുന്നു. ആപ്ലിക്കേഷൻ ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ ബാക്കെൻഡിന്റെ പേര് വ്യക്തമാക്കിയാൽ മതി.

• ബാക്കെൻഡ്=”win32″ — സ്ഥിരസ്ഥിതിയായി ഉപയോഗിക്കുമ്പോൾ, MFC, WTL, VB6, മറ്റ് ലെഗസി ആപ്ലിക്കേഷനുകൾ എന്നിവയിൽ നന്നായി പ്രവർത്തിക്കുന്നു.
• ബാക്കെൻഡ്=”uia” - MS UI ഓട്ടോമേഷനായുള്ള പുതിയ ബാക്കെൻഡ്: WPF, WinForms എന്നിവയിൽ നന്നായി പ്രവർത്തിക്കുന്നു; ഡെൽഫി, വിൻഡോസ് സ്റ്റോർ ആപ്ലിക്കേഷനുകൾക്കും നല്ലതാണ്; Qt5, ചില ജാവ ആപ്ലിക്കേഷനുകൾ എന്നിവയിൽ പ്രവർത്തിക്കുന്നു. പൊതുവേ, Inspect.exe മൂലകങ്ങളും അവയുടെ ഗുണങ്ങളും കാണുകയാണെങ്കിൽ, ഈ ബാക്കെൻഡ് അനുയോജ്യമാണ്. തത്വത്തിൽ, മിക്ക ബ്രൗസറുകളും യുഐ ഓട്ടോമേഷനെ പിന്തുണയ്ക്കുന്നു (മോസില്ല സ്ഥിരസ്ഥിതിയായി, ആരംഭിക്കുമ്പോൾ Chrome-ന് കമാൻഡ് ലൈൻ കീ നൽകേണ്ടതുണ്ട്. --force-renderer-accessibilityInspect.exe-ലെ പേജുകളിലെ ഘടകങ്ങൾ കാണുന്നതിന്). തീർച്ചയായും, ഈ മേഖലയിൽ സെലിനിയവുമായുള്ള മത്സരം സാധ്യമല്ല. ബ്രൗസറിൽ പ്രവർത്തിക്കാനുള്ള മറ്റൊരു മാർഗം (ഒരു ക്രോസ്-പ്രൊഡക്റ്റ് സാഹചര്യത്തിന് ഉപയോഗപ്രദമായേക്കാം).

ഓട്ടോമേഷനുള്ള എൻട്രി പോയിന്റുകൾ

ആപ്ലിക്കേഷൻ വിപുലമായി ഗവേഷണം ചെയ്തിട്ടുണ്ട്. ഒരു അപ്ലിക്കേഷൻ ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിച്ച് അത് പ്രവർത്തിപ്പിക്കാനോ ഇതിനകം പ്രവർത്തിക്കുന്ന ഒന്നിലേക്ക് അറ്റാച്ചുചെയ്യാനോ സമയമായി. ഇത് ഒരു സ്റ്റാൻഡേർഡ് ക്ലാസിന്റെ ഒരു ക്ലോൺ മാത്രമല്ല subprocess.Popen, അതായത് നിങ്ങളുടെ എല്ലാ പ്രവർത്തനങ്ങളെയും പ്രക്രിയയുടെ അതിരുകളിലേക്ക് പരിമിതപ്പെടുത്തുന്ന ഒരു ഇൻപുട്ട് ഒബ്‌ജക്റ്റ്. ആപ്ലിക്കേഷന്റെ നിരവധി സന്ദർഭങ്ങൾ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽ ഇത് വളരെ ഉപയോഗപ്രദമാണ്, എന്നാൽ ബാക്കിയുള്ളവ തൊടാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നില്ല.

from pywinauto.application import Application
app = Application(backend="uia").start('notepad.exe')

# Опишем окно, которое хотим найти в процессе Notepad.exe
dlg_spec = app.UntitledNotepad
# ждем пока окно реально появится
actionable_dlg = dlg_spec.wait('visible')

നിങ്ങൾക്ക് ഒരേസമയം നിരവധി ആപ്ലിക്കേഷനുകൾ കൈകാര്യം ചെയ്യണമെങ്കിൽ, ഈ ക്ലാസ് നിങ്ങളെ സഹായിക്കും Desktop. ഉദാഹരണത്തിന്, Win10-ലെ ഒരു കാൽക്കുലേറ്ററിൽ, ഘടകങ്ങളുടെ ശ്രേണി നിരവധി പ്രക്രിയകളിൽ വ്യാപിച്ചിരിക്കുന്നു (മാത്രമല്ല calc.exe). അതിനാൽ ഒരു വസ്തുവും ഇല്ല Desktop പോരാ.

from subprocess import Popen
from pywinauto import Desktop

Popen('calc.exe', shell=True)
dlg = Desktop(backend="uia").Calculator
dlg.wait('visible')

റൂട്ട് ഒബ്ജക്റ്റ് (Application അഥവാ Desktop) നിങ്ങൾ ബാക്കെൻഡ് വ്യക്തമാക്കേണ്ട ഒരേയൊരു സ്ഥലമാണ്. മറ്റെല്ലാം "സ്പെസിഫിക്കേഷൻ-> റാപ്പർ" എന്ന ആശയത്തിലേക്ക് സുതാര്യമായി വീഴുന്നു, അത് പിന്നീട് ചർച്ച ചെയ്യപ്പെടും.

വിൻഡോ/എലമെന്റ് സ്പെസിഫിക്കേഷനുകൾ

ഇതാണ് pywinauto ഇന്റർഫേസ് നിർമ്മിച്ചിരിക്കുന്ന പ്രധാന ആശയം. നിങ്ങൾക്ക് ഒരു വിൻഡോ/ഘടകം ഏകദേശം അല്ലെങ്കിൽ കൂടുതൽ വിശദമായി വിവരിക്കാം, അത് ഇതുവരെ നിലവിലില്ലെങ്കിലും ഇതിനകം അടച്ചിട്ടുണ്ടെങ്കിലും. വിൻഡോ സ്പെസിഫിക്കേഷൻ (വസ്തു വിൻഡോ സ്പെസിഫിക്കേഷൻ) ഒരു യഥാർത്ഥ വിൻഡോ അല്ലെങ്കിൽ ഘടകത്തിനായി തിരയുന്നതിനുള്ള മാനദണ്ഡം സംഭരിക്കുന്നു.

വിശദമായ വിൻഡോ സ്പെസിഫിക്കേഷന്റെ ഉദാഹരണം:

>>> dlg_spec = app.window(title='Untitled - Notepad')

>>> dlg_spec
<pywinauto.application.WindowSpecification object at 0x0568B790>

>>> dlg_spec.wrapper_object()
<pywinauto.controls.win32_controls.DialogWrapper object at 0x05639B70>

രീതി വിളിക്കുന്നതിലൂടെ വിൻഡോ തിരയൽ തന്നെ സംഭവിക്കുന്നു .wrapper_object(). ഇത് ഒരു യഥാർത്ഥ വിൻഡോ/ഘടകം അല്ലെങ്കിൽ ത്രോകൾക്കായി ഒരു നിശ്ചിത "റാപ്പർ" നൽകുന്നു ElementNotFoundError (ചിലപ്പോൾ ElementAmbiguousError, നിരവധി ഘടകങ്ങൾ കണ്ടെത്തിയാൽ, അതായത്, നിങ്ങൾ തിരയൽ മാനദണ്ഡം വ്യക്തമാക്കേണ്ടതുണ്ട്). ഈ "റാപ്പർ" ഇതിനകം ഒരു ഘടകം ഉപയോഗിച്ച് ചില പ്രവർത്തനങ്ങൾ എങ്ങനെ ചെയ്യാമെന്നും അതിൽ നിന്ന് ഡാറ്റ സ്വീകരിക്കണമെന്നും അറിയാം.

പൈത്തണിന് കോൾ മറയ്ക്കാൻ കഴിയും .wrapper_object(), അതിനാൽ അന്തിമ കോഡ് ചെറുതായി മാറുന്നു. ഡീബഗ്ഗിംഗ് ആവശ്യങ്ങൾക്കായി മാത്രം ഇത് ഉപയോഗിക്കാൻ ഞങ്ങൾ ശുപാർശ ചെയ്യുന്നു. അടുത്ത രണ്ട് വരികളും ഒരേ കാര്യം ചെയ്യുന്നു:

dlg_spec.wrapper_object().minimize() # debugging
dlg_spec.minimize() # production

ഒരു വിൻഡോ സ്പെസിഫിക്കേഷനായി നിരവധി തിരയൽ മാനദണ്ഡങ്ങളുണ്ട്. ഇവിടെ ഏതാനും ഉദാഹരണങ്ങൾ മാത്രം:

# могут иметь несколько уровней
app.window(title_re='.* - Notepad$').window(class_name='Edit')

# можно комбинировать критерии (как AND) и не ограничиваться одним процессом приложения
dlg = Desktop(backend="uia").Calculator
dlg.window(auto_id='num8Button', control_type='Button')

സാധ്യമായ എല്ലാ മാനദണ്ഡങ്ങളുടെയും ഒരു ലിസ്റ്റ് ഫംഗ്ഷൻ ഡോക്‌സിൽ ഉണ്ട് pywinauto.findwindows.find_elements(...).

ആട്രിബ്യൂട്ടും കീയും വഴിയുള്ള ആക്‌സസ്സിന്റെ മാന്ത്രികത

വിൻഡോ സ്പെസിഫിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതും ഒബ്ജക്റ്റ് ആട്രിബ്യൂട്ടുകൾ ചലനാത്മകമായി തിരിച്ചറിയുന്നതും പൈത്തൺ എളുപ്പമാക്കുന്നു (ആന്തരികമായി, രീതി അസാധുവാക്കിയിരിക്കുന്നു __getattribute__). തീർച്ചയായും, ഏതെങ്കിലും വേരിയബിളിന്റെ പേരിലുള്ള അതേ നിയന്ത്രണങ്ങൾ ആട്രിബ്യൂട്ട് നാമത്തിലും ഏർപ്പെടുത്തിയിട്ടുണ്ട് (നിങ്ങൾക്ക് സ്‌പെയ്‌സുകളോ കോമകളോ മറ്റ് പ്രത്യേക പ്രതീകങ്ങളോ ചേർക്കാൻ കഴിയില്ല). ഭാഗ്യവശാൽ, അക്ഷരത്തെറ്റുകൾക്കും ചെറിയ വ്യതിയാനങ്ങൾക്കും പ്രതിരോധശേഷിയുള്ള "മികച്ച പൊരുത്തം" എന്ന് വിളിക്കപ്പെടുന്ന തിരയൽ അൽഗോരിതം pywinauto ഉപയോഗിക്കുന്നു.

app.UntitledNotepad
# то же самое, что
app.window(best_match='UntitledNotepad')

നിങ്ങൾക്ക് ഇപ്പോഴും യൂണികോഡ് സ്‌ട്രിംഗുകൾ ആവശ്യമുണ്ടെങ്കിൽ (ഉദാഹരണത്തിന്, റഷ്യൻ ഭാഷയ്‌ക്ക്), സ്‌പെയ്‌സുകൾ മുതലായവ, നിങ്ങൾക്ക് കീ ഉപയോഗിച്ച് ആക്‌സസ് ചെയ്യാൻ കഴിയും (ഒരു സാധാരണ നിഘണ്ടു പോലെ):

app['Untitled - Notepad']
# то же самое, что
app.window(best_match='Untitled - Notepad')

മാന്ത്രിക നാമങ്ങൾക്കുള്ള അഞ്ച് നിയമങ്ങൾ

സാധാരണ മാജിക് പേരുകൾ എങ്ങനെ കണ്ടെത്താം? തിരയുന്നതിന് മുമ്പ് ഘടകത്തിലേക്ക് അസൈൻ ചെയ്തവ. സ്റ്റാൻഡേർഡിന് സമാനമായ ഒരു പേര് നിങ്ങൾ വ്യക്തമാക്കിയാൽ, ഘടകം കണ്ടെത്തും.

1. ശീർഷകം പ്രകാരം (ടെക്‌സ്റ്റ്, പേര്): app.Properties.OK.click()
2. വാചകം വഴിയും എലമെന്റ് തരം അനുസരിച്ച്: app.Properties.OKButton.click()
3. തരവും നമ്പറും അനുസരിച്ച്: app.Properties.Button3.click() (പേരുകൾ Button0 и Button1 കണ്ടെത്തിയ ആദ്യത്തെ മൂലകവുമായി ബന്ധിപ്പിച്ചിരിക്കുന്നു, Button2 - രണ്ടാമത്തേതിലേക്ക്, തുടർന്ന് ക്രമത്തിൽ - ചരിത്രപരമായി ഇത് സംഭവിച്ചത് ഇങ്ങനെയാണ്)
4. സ്റ്റാറ്റിക് ടെക്‌സ്‌റ്റ് (ഇടത് അല്ലെങ്കിൽ മുകളിൽ) കൂടാതെ തരം അനുസരിച്ച്: app.OpenDialog.FileNameEdit.set_text("") (ഡൈനാമിക് ടെക്സ്റ്റുള്ള ഘടകങ്ങൾക്ക് ഉപയോഗപ്രദമാണ്)
5. ടൈപ്പും ഉള്ളിലെ വാചകവും അനുസരിച്ച്: app.Properties.TabControlSharing.select("General")

സാധാരണയായി രണ്ടോ മൂന്നോ നിയമങ്ങൾ ഒരേ സമയം പ്രയോഗിക്കുന്നു, അപൂർവ്വമായി കൂടുതൽ. ഓരോ ഘടകത്തിനും ഏതൊക്കെ നിർദ്ദിഷ്ട പേരുകൾ ലഭ്യമാണെന്ന് പരിശോധിക്കാൻ, നിങ്ങൾക്ക് രീതി ഉപയോഗിക്കാം print_control_identifiers(). ഇതിന് സ്‌ക്രീനിലേക്കും ഫയലിലേക്കും ഘടകങ്ങളുടെ ഒരു ട്രീ പ്രിന്റ് ചെയ്യാൻ കഴിയും. ഓരോ മൂലകത്തിനും, അതിന്റെ സ്റ്റാൻഡേർഡ് മാജിക് പേരുകൾ അച്ചടിക്കുന്നു. നിങ്ങൾക്ക് അവിടെ നിന്ന് ചൈൽഡ് ഘടകങ്ങളുടെ കൂടുതൽ വിശദമായ സ്പെസിഫിക്കേഷനുകൾ പകർത്തി ഒട്ടിക്കാം. സ്ക്രിപ്റ്റിലെ ഫലം ഇതുപോലെ കാണപ്പെടും:

app.Properties.child_window(data-gt-translate-attributes='["title"]' title="Contains:", auto_id="13087", control_type="Edit")

മൂലകങ്ങളുടെ വൃക്ഷം തന്നെ സാധാരണയായി ഒരു വലിയ പാദരക്ഷയാണ്.

>>> app.Properties.print_control_identifiers()

Control Identifiers:

Dialog - 'Windows NT Properties'    (L688, T518, R1065, B1006)
[u'Windows NT PropertiesDialog', u'Dialog', u'Windows NT Properties']
child_window(data-gt-translate-attributes='["title"]' title="Windows NT Properties", control_type="Window")
   |
   | Image - ''    (L717, T589, R749, B622)
   | [u'', u'0', u'Image1', u'Image0', 'Image', u'1']
   | child_window(auto_id="13057", control_type="Image")
   |
   | Image - ''    (L717, T630, R1035, B632)
   | ['Image2', u'2']
   | child_window(auto_id="13095", control_type="Image")
   |
   | Edit - 'Folder name:'    (L790, T596, R1036, B619)
   | [u'3', 'Edit', u'Edit1', u'Edit0']
   | child_window(data-gt-translate-attributes='["title"]' title="Folder name:", auto_id="13156", control_type="Edit")
   |
   | Static - 'Type:'    (L717, T643, R780, B658)
   | [u'Type:Static', u'Static', u'Static1', u'Static0', u'Type:']
   | child_window(data-gt-translate-attributes='["title"]' title="Type:", auto_id="13080", control_type="Text")
   |
   | Edit - 'Type:'    (L790, T643, R1036, B666)
   | [u'4', 'Edit2', u'Type:Edit']
   | child_window(data-gt-translate-attributes='["title"]' title="Type:", auto_id="13059", control_type="Edit")
   |
   | Static - 'Location:'    (L717, T669, R780, B684)
   | [u'Location:Static', u'Location:', u'Static2']
   | child_window(data-gt-translate-attributes='["title"]' title="Location:", auto_id="13089", control_type="Text")
   |
   | Edit - 'Location:'    (L790, T669, R1036, B692)
   | ['Edit3', u'Location:Edit', u'5']
   | child_window(data-gt-translate-attributes='["title"]' title="Location:", auto_id="13065", control_type="Edit")
   |
   | Static - 'Size:'    (L717, T695, R780, B710)
   | [u'Size:Static', u'Size:', u'Static3']
   | child_window(data-gt-translate-attributes='["title"]' title="Size:", auto_id="13081", control_type="Text")
   |
   | Edit - 'Size:'    (L790, T695, R1036, B718)
   | ['Edit4', u'6', u'Size:Edit']
   | child_window(data-gt-translate-attributes='["title"]' title="Size:", auto_id="13064", control_type="Edit")
   |
   | Static - 'Size on disk:'    (L717, T721, R780, B736)
   | [u'Size on disk:', u'Size on disk:Static', u'Static4']
   | child_window(data-gt-translate-attributes='["title"]' title="Size on disk:", auto_id="13107", control_type="Text")
   |
   | Edit - 'Size on disk:'    (L790, T721, R1036, B744)
   | ['Edit5', u'7', u'Size on disk:Edit']
   | child_window(data-gt-translate-attributes='["title"]' title="Size on disk:", auto_id="13106", control_type="Edit")
   |
   | Static - 'Contains:'    (L717, T747, R780, B762)
   | [u'Contains:1', u'Contains:0', u'Contains:Static', u'Static5', u'Contains:']
   | child_window(data-gt-translate-attributes='["title"]' title="Contains:", auto_id="13088", control_type="Text")
   |
   | Edit - 'Contains:'    (L790, T747, R1036, B770)
   | [u'8', 'Edit6', u'Contains:Edit']
   | child_window(data-gt-translate-attributes='["title"]' title="Contains:", auto_id="13087", control_type="Edit")
   |
   | Image - 'Contains:'    (L717, T773, R1035, B775)
   | [u'Contains:Image', 'Image3', u'Contains:2']
   | child_window(data-gt-translate-attributes='["title"]' title="Contains:", auto_id="13096", control_type="Image")
   |
   | Static - 'Created:'    (L717, T786, R780, B801)
   | [u'Created:', u'Created:Static', u'Static6', u'Created:1', u'Created:0']
   | child_window(data-gt-translate-attributes='["title"]' title="Created:", auto_id="13092", control_type="Text")
   |
   | Edit - 'Created:'    (L790, T786, R1036, B809)
   | [u'Created:Edit', 'Edit7', u'9']
   | child_window(data-gt-translate-attributes='["title"]' title="Created:", auto_id="13072", control_type="Edit")
   |
   | Image - 'Created:'    (L717, T812, R1035, B814)
   | [u'Created:Image', 'Image4', u'Created:2']
   | child_window(data-gt-translate-attributes='["title"]' title="Created:", auto_id="13097", control_type="Image")
   |
   | Static - 'Attributes:'    (L717, T825, R780, B840)
   | [u'Attributes:Static', u'Static7', u'Attributes:']
   | child_window(data-gt-translate-attributes='["title"]' title="Attributes:", auto_id="13091", control_type="Text")
   |
   | CheckBox - 'Read-only (Only applies to files in folder)'    (L790, T825, R1035, B841)
   | [u'CheckBox0', u'CheckBox1', 'CheckBox', u'Read-only (Only applies to files in folder)CheckBox', u'Read-only (Only applies to files in folder)']
   | child_window(data-gt-translate-attributes='["title"]' title="Read-only (Only applies to files in folder)", auto_id="13075", control_type="CheckBox")
   |
   | CheckBox - 'Hidden'    (L790, T848, R865, B864)
   | ['CheckBox2', u'HiddenCheckBox', u'Hidden']
   | child_window(data-gt-translate-attributes='["title"]' title="Hidden", auto_id="13076", control_type="CheckBox")
   |
   | Button - 'Advanced...'    (L930, T845, R1035, B868)
   | [u'Advanced...', u'Advanced...Button', 'Button', u'Button1', u'Button0']
   | child_window(data-gt-translate-attributes='["title"]' title="Advanced...", auto_id="13154", control_type="Button")
   |
   | Button - 'OK'    (L814, T968, R889, B991)
   | ['Button2', u'OK', u'OKButton']
   | child_window(data-gt-translate-attributes='["title"]' title="OK", auto_id="1", control_type="Button")
   |
   | Button - 'Cancel'    (L895, T968, R970, B991)
   | ['Button3', u'CancelButton', u'Cancel']
   | child_window(data-gt-translate-attributes='["title"]' title="Cancel", auto_id="2", control_type="Button")
   |
   | Button - 'Apply'    (L976, T968, R1051, B991)
   | ['Button4', u'ApplyButton', u'Apply']
   | child_window(data-gt-translate-attributes='["title"]' title="Apply", auto_id="12321", control_type="Button")
   |
   | TabControl - ''    (L702, T556, R1051, B962)
   | [u'10', u'TabControlSharing', u'TabControlPrevious Versions', u'TabControlSecurity', u'TabControl', u'TabControlCustomize']
   | child_window(auto_id="12320", control_type="Tab")
   |    |
   |    | TabItem - 'General'    (L704, T558, R753, B576)
   |    | [u'GeneralTabItem', 'TabItem', u'General', u'TabItem0', u'TabItem1']
   |    | child_window(data-gt-translate-attributes='["title"]' title="General", control_type="TabItem")
   |    |
   |    | TabItem - 'Sharing'    (L753, T558, R801, B576)
   |    | [u'Sharing', u'SharingTabItem', 'TabItem2']
   |    | child_window(data-gt-translate-attributes='["title"]' title="Sharing", control_type="TabItem")
   |    |
   |    | TabItem - 'Security'    (L801, T558, R851, B576)
   |    | [u'Security', 'TabItem3', u'SecurityTabItem']
   |    | child_window(data-gt-translate-attributes='["title"]' title="Security", control_type="TabItem")
   |    |
   |    | TabItem - 'Previous Versions'    (L851, T558, R947, B576)
   |    | [u'Previous VersionsTabItem', u'Previous Versions', 'TabItem4']
   |    | child_window(data-gt-translate-attributes='["title"]' title="Previous Versions", control_type="TabItem")
   |    |
   |    | TabItem - 'Customize'    (L947, T558, R1007, B576)
   |    | [u'CustomizeTabItem', 'TabItem5', u'Customize']
   |    | child_window(data-gt-translate-attributes='["title"]' title="Customize", control_type="TabItem")
   |
   | TitleBar - 'None'    (L712, T521, R1057, B549)
   | ['TitleBar', u'11']
   |    |
   |    | Menu - 'System'    (L696, T526, R718, B548)
   |    | [u'System0', u'System', u'System1', u'Menu', u'SystemMenu']
   |    | child_window(data-gt-translate-attributes='["title"]' title="System", auto_id="MenuBar", control_type="MenuBar")
   |    |    |
   |    |    | MenuItem - 'System'    (L696, T526, R718, B548)
   |    |    | [u'System2', u'MenuItem', u'SystemMenuItem']
   |    |    | child_window(data-gt-translate-attributes='["title"]' title="System", control_type="MenuItem")
   |    |
   |    | Button - 'Close'    (L1024, T519, R1058, B549)
   |    | [u'CloseButton', u'Close', 'Button5']
   |    | child_window(data-gt-translate-attributes='["title"]' title="Close", control_type="Button")

ചില സന്ദർഭങ്ങളിൽ, മുഴുവൻ ട്രീയും പ്രിന്റ് ചെയ്യുന്നത് മന്ദഗതിയിലായിരിക്കാം (ഉദാഹരണത്തിന്, iTunes-ൽ ഒരു ടാബിൽ മൂവായിരത്തോളം ഘടകങ്ങൾ ഉണ്ട്!), എന്നാൽ നിങ്ങൾക്ക് ഓപ്ഷൻ ഉപയോഗിക്കാം depth (ആഴം): depth=1 - മൂലകം തന്നെ, depth=2 - ഉടനടിയുള്ള കുട്ടികൾ മാത്രം, തുടങ്ങിയവ. സൃഷ്ടിക്കുമ്പോൾ സ്പെസിഫിക്കേഷനുകളിലും ഇത് വ്യക്തമാക്കാം child_window.

ഉദാഹരണങ്ങൾ

ഞങ്ങൾ നിരന്തരം നിറയ്ക്കുന്നു ശേഖരത്തിലെ ഉദാഹരണങ്ങളുടെ പട്ടിക. അടുത്തിടെയുള്ളവയിൽ, WireShark നെറ്റ്‌വർക്ക് അനലൈസറിന്റെ ഓട്ടോമേഷൻ ശ്രദ്ധിക്കേണ്ടതാണ് (ഇത് ഒരു Qt5 ആപ്ലിക്കേഷന്റെ മികച്ച ഉദാഹരണമാണ്; ഒരു GUI ഇല്ലാതെ ഈ ടാസ്‌ക്ക് പരിഹരിക്കാൻ കഴിയുമെങ്കിലും, കാരണം ഉണ്ട് scapy.Sniffer പൈത്തൺ പാക്കേജിൽ നിന്ന് സ്കാപ്പി). റിബൺ ടൂൾബാറിനൊപ്പം എംഎസ് പെയിന്റ് ഓട്ടോമേഷന്റെ ഒരു ഉദാഹരണവുമുണ്ട്.

എന്റെ ഒരു വിദ്യാർത്ഥി എഴുതിയ മറ്റൊരു മികച്ച ഉദാഹരണം: explorer.exe-ൽ നിന്ന് Google ഡ്രൈവിനായുള്ള Chrome പേജിലേക്ക് ഒരു ഫയൽ വലിച്ചിടുന്നു (അത് കുറച്ച് കഴിഞ്ഞ് പ്രധാന ശേഖരത്തിലേക്ക് നീങ്ങും).

കൂടാതെ, തീർച്ചയായും, കീബോർഡ് (ഹോട്ട് കീകൾ), മൗസ് ഇവന്റുകൾ എന്നിവയിലേക്ക് സബ്‌സ്‌ക്രൈബുചെയ്യുന്നതിനുള്ള ഒരു ഉദാഹരണം:
hook_and_listen.py.

അംഗീകാരങ്ങൾ

പ്രോജക്റ്റ് വികസിപ്പിക്കാൻ നിരന്തരം സഹായിക്കുന്നവർക്ക് പ്രത്യേക നന്ദി. എനിക്കും ഒപ്പം വാലന്റൈൻ ഇതൊരു സ്ഥിരം ഹോബിയാണ്. UNN-ൽ നിന്നുള്ള എന്റെ രണ്ട് വിദ്യാർത്ഥികൾ അടുത്തിടെ ഈ വിഷയത്തിൽ അവരുടെ ബാച്ചിലേഴ്സ് ഡിഗ്രികളെ ന്യായീകരിച്ചു. Александр MS UI ഓട്ടോമേഷനെ പിന്തുണയ്‌ക്കുന്നതിന് വലിയ സംഭാവന നൽകി, ടെക്‌സ്‌റ്റ് പ്രോപ്പർട്ടികളെ അടിസ്ഥാനമാക്കിയുള്ള "റെക്കോർഡ്-പ്ലേബാക്ക്" തത്വത്തെ അടിസ്ഥാനമാക്കി അടുത്തിടെ ഒരു ഓട്ടോമാറ്റിക് കോഡ് ജനറേറ്റർ നിർമ്മിക്കാൻ തുടങ്ങി (ഇത് ഏറ്റവും സങ്കീർണ്ണമായ സവിശേഷതയാണ്), ഇതുവരെ "uia" ബാക്കെൻഡിനായി മാത്രം. ഇവാൻ AT-SPI (മൊഡ്യൂളുകൾ) അടിസ്ഥാനമാക്കി ലിനക്സിനായി ഒരു പുതിയ ബാക്കെൻഡ് വികസിപ്പിക്കുന്നു mouse и keyboard അടിസ്ഥാനമാക്കിയുള്ളത് python-xlib - ഇതിനകം 0.6.x റിലീസുകളിൽ).

ഞാൻ കുറച്ച് കാലമായി പൈത്തണിൽ ഓട്ടോമേഷനെക്കുറിച്ചുള്ള ഒരു പ്രത്യേക കോഴ്‌സ് പഠിപ്പിക്കുന്നതിനാൽ, ചില മാസ്റ്റേഴ്സ് വിദ്യാർത്ഥികൾ ഗൃഹപാഠം ചെയ്യുന്നു, ചെറിയ സവിശേഷതകളോ ഓട്ടോമേഷന്റെ ഉദാഹരണങ്ങളോ നടപ്പിലാക്കുന്നു. ഗവേഷണ ഘട്ടത്തിലെ ചില പ്രധാന കാര്യങ്ങളും ഒരിക്കൽ വിദ്യാർത്ഥികൾ കണ്ടെത്തിയിരുന്നു. ചിലപ്പോൾ നിങ്ങൾ കോഡിന്റെ ഗുണനിലവാരം കർശനമായി നിരീക്ഷിക്കേണ്ടതുണ്ടെങ്കിലും. ഏകദേശം 95% കോഡ് കവറേജുള്ള സ്റ്റാറ്റിക് അനലൈസറുകളും (QuantifiedCode, Codacy, Landscape) ക്ലൗഡിലെ ഓട്ടോമാറ്റിക് ടെസ്റ്റുകളും (AppVeyor സേവനം) ഇതിന് വളരെയധികം സഹായിക്കുന്നു.

കൂടാതെ അവലോകനങ്ങൾ നൽകുകയും ബഗുകൾ ഉയർത്തുകയും പുൾ അഭ്യർത്ഥനകൾ അയയ്ക്കുകയും ചെയ്യുന്ന എല്ലാവർക്കും നന്ദി!

അധിക വിഭവങ്ങൾ

ഞങ്ങൾ ചോദ്യങ്ങൾ പിന്തുടരുന്നു StackOverflow എന്നതിൽ ടാഗ് ചെയ്യുക (അടുത്തിടെ പ്രത്യക്ഷപ്പെട്ടത് SO യുടെ റഷ്യൻ പതിപ്പിൽ ടാഗ്) ഒപ്പം ടോസ്റ്ററിലെ കീവേഡ് വഴി. ഉണ്ട് ഗിറ്ററിൽ റഷ്യൻ ഭാഷയിലുള്ള ചാറ്റ്.

ഞങ്ങൾ എല്ലാ മാസവും അപ്ഡേറ്റ് ചെയ്യുന്നു GUI പരിശോധനയ്ക്കുള്ള ഓപ്പൺ സോഴ്‌സ് ലൈബ്രറികളുടെ റേറ്റിംഗ്. GitHub-ലെ നക്ഷത്രങ്ങളുടെ എണ്ണത്തിന്റെ കാര്യത്തിൽ, Autohotkey (അവയ്ക്ക് വളരെ വലിയ ഒരു സമൂഹവും ഒരു നീണ്ട ചരിത്രവുമുണ്ട്) PyAutoGUI എന്നിവ മാത്രമേ അതിവേഗം വളരുന്നുള്ളൂ (അതിന്റെ രചയിതാവ് അൽ സ്വീഗാർട്ടിന്റെ പുസ്തകങ്ങളുടെ ജനപ്രീതി കാരണം: “ബോറിങ് സ്റ്റഫ് ഓട്ടോമേറ്റ് ചെയ്യുക പൈത്തൺ" എന്നിവയും മറ്റുള്ളവയും).

അവലംബം: www.habr.com