Win32com client dispatch word application

Based on the script here: .doc to pdf using python I’ve got a semi-working script to export .docx files to pdf from C:Export_to_pdf into a new folder.

The problem is that it gets through the first couple of documents and then fails with:

(-2147352567, 'Exception occurred.', (0, u'Microsoft Word', u'Command failed', u'wdmain11.chm', 36966, -2146824090), None)

This, apparently is an unhelpful general error message. If I debug slowly it using pdb, I can loop through all files and export successfully. If I also keep an eye on the processes in Windows Task Manager I can see that WINWORD starts then ends when it is supposed to, but on the larger files it takes longer for the memory usage to stablise. This makes me think that the script is tripping up when WINWORD doesn’t have time to initialize or quit before the next method is called on the client.Dispatch object.

Is there a way with win32com or comtypes to identify and wait for a process to start or finish?

My script:

import os
from win32com import client

folder = "C:\Export_to_pdf"
file_type = 'docx'
out_folder = folder + "\PDF"

os.chdir(folder)

if not os.path.exists(out_folder):
    print 'Creating output folder...'
    os.makedirs(out_folder)
    print out_folder, 'created.'
else:
    print out_folder, 'already exists.n'

for files in os.listdir("."):
    if files.endswith(".docx"):
        print files

print 'nn'

try:
    for files in os.listdir("."):
        if files.endswith(".docx"):
            out_name = files.replace(file_type, r"pdf")
            in_file = os.path.abspath(folder + "\" + files)
            out_file = os.path.abspath(out_folder + "\" + out_name)
            word = client.Dispatch("Word.Application")
            doc = word.Documents.Open(in_file)
            print 'Exporting', out_file
            doc.SaveAs(out_file, FileFormat=17)
            doc.Close()
            word.Quit()
except Exception, e:
    print e

The working code — just replaced the try block with this. Note moved the DispatchEx statement outside the for loop and the word.Quit() to a finally statement to ensure it closes.

try:
    word = client.DispatchEx("Word.Application")
    for files in os.listdir("."):
        if files.endswith(".docx") or files.endswith('doc'):
            out_name = files.replace(file_type, r"pdf")
            in_file = os.path.abspath(folder + "\" + files)
            out_file = os.path.abspath(out_folder + "\" + out_name)
            doc = word.Documents.Open(in_file)
            print 'Exporting', out_file
            doc.SaveAs(out_file, FileFormat=17)
            doc.Close()
except Exception, e:
    print e
finally:
    word.Quit()

In order to implement COM objects in the Python version of Windows, you need a set of extensions developed by Mark Hammond and Greg Stein. Part of the win32com package, these extensions enable you to do everything that is COM-related, including writing COM clients and COM servers.

The following link takes you to the download page of these extensions:

http://www.python.org/download/download_windows.html

All the Win32 extensions (including the COM extensions) are part of the win32all installation package. This package also installs the PythonWin IDE in your machine.

The latest version of this whole package is located at the win32all home page. Search for the win32all.exe file:

http://www.python.org/windows/win32all/

You can also go directly to Mark Hammond’s starship home page, which might have more recent beta releases of this package:

http://starship.python.net/crew/mhammond/

After installing the package in your machine, take a look at the readme.htm file, which is stored at the win32com directory.

COM support for Python is compounded of the core PythonCOM module, which supports the C++ code, and the other modules that implement helper code in Python. The whole package is known as win32com.

The win32com Package

The win32com support is standalone, as it does not require PythonWin. The win32com package itself does not provide any functionality. Some of the modules contained in this package are win32com.pythoncom— Provides core C++ support for COM objects and exposes COM object methods, such as QueryInterface() and Invoke(), just as the C++ API does. Note that all the reference counting is automatically done for you. Programmers rarely access this module directly. Instead, they usually use the win32com wrapper classes and functions written in Python to provide a nice, programmable interface.

win32com.client— Provides support for COM clients (for example, using Python to start Microsoft Excel and create a spreadsheet). The COM client support enables Python to manipulate other COM objects via their exposed interfaces. All client-side IUnknown-derived objects, including IDispatch, are supported.

win32com.server— Provides support for COM servers (for example, creating and registering a COM server object in Python and using a language such as Visual Basic or Delphi to access the Python objects). The COM server support enables Python to create COM servers, which can be manipulated by another COM client. All server-side IUnknown-derived objects are supported.

win32com.axscript— This is the ActiveX Scripting implementation for Python.

win32com.axdebug— This is the Active Debugging implementation for Python.

win32com.mapi— Provides utilities for working with MAPI and the Microsoft Exchange Server.

Talking to Windows Applications

The COM technology has been part of the Windows world for a long time. The COM genealogy can be traced back to DDE (Dynamic Data Exchange). DDE was the first device for transferring data between various applications in a multi-tasking computer. After some time, DDE was expanded to Object Linking and Embedding (OLE)—note that COM was invented as part of OLE. The creation of the Visual Basic Extensions (VBXs) enhanced the OLE technology for visual components, originating a new standard called OLE2, which was based on top of COM. Soon, the OLE2 technology became more integrated with COM, which is a generalpurpose mechanism. Nowadays, COM is mostly known, in part, because of the ActiveX technology.

Professional applications such as Microsoft Office and the Netscape browser enable you to control their objects using COM. Therefore, programs written in Python can be easily used to control those applications.

COM passes string objects as Unicode characters. Before using these objects in Python, it’s necessary to convert them to strings. The Python-2.0 Unicode string type is not the same as the string type, but it is easy to convert between the two.

PythonWin comes with a basic COM browser (Python Object browser). This program helps you to identify the current objects in your system that implement COM interfaces.

To run the browser, select it from the PythonWin Tools menu, or double-click on the file win32comclientcombrowse.py.

Note that there are other COM browsers available, such as the one that comes with the Microsoft Visual C++.

If you study the file pythonwin32comserversinterp.py, which is installed as part of your PythonWin distribution, you will learn how to implement a very simple COM server. This server exposes the Python interpreter by providing a COM object that handles both the exec and eval methods. Before using this object, register it by running the module from Python.exe. Then, from Visual Basic, use CreateObject(‘Python.Interpreter’) to initialize the object, and you can start calling the methods.

Word and Excel

Let’s quit talking and get to some practicing. Our objective here is to open and manipulate Microsoft applications from Python.

The first thing that you need to do is to import the COM client and dispatch the right object. In the next example, a variable is assigned a reference to an Excel application:

>>> import win32com.client

>>> xl = win32com.client.Dispatch(«Excel.Application»)

The following does the same thing, but this time the reference is to a Word application. >>> wd = win32com.client.Dispatch(«Word.Application»)

Excel.Application and Word.Application are the Program IDs (progid), which are the names of the objects for which you want to create an instance. Internally, these objects have a Class ID (clsid) that uniquely registers them in the Windows Registry. The matching table between progids and clsids is stored in the Windows Registry and the matching is performed by the COM mechanism.

It is not an easy job to identify an application progid, or to find out object methods and attributes. You can use COM browsers to see what applications have COM interfaces in your system.

For the Microsoft Products, you can take a look at the documentation; it is a good source of information.

Not necessarily every COM object implements the same interface. However, there are similarities.

For example, if the previous assignments have just created the objects and you want to make them visible, you have to type

>>> xl.Visible = 1 # Sets the visible property for the Excel application >>> wd.Visible = 1 # Sets the visible property for the Word application

To close both programs and release the memory, you need to say

>>> xl = None >>> wd = None or, you could use >>> del xl, wd

These were simple examples of implementing COM clients in Python. Next, we will see how to implement a Python COM server by creating a Python interface that exposes an object. The next block of code registers the interface in the Windows Registry.

Note that every new COM object that you create must have a unique clsid, but you don’t have to worry about it. The complex algorithm that works behind the scenes is ready to generate a unique identification, as shown here:

>>> import pythoncom

>>> print pythoncom.CreateGuid()

Your COM server is defined next. You have to execute the program in order to make the COM object available in the system. Store it on a file, and double-click on it.

1: class TaxApplication:

3: _reg_progid_ = «Tax.Application»

4: _reg_clsid_ = «{D2DEB6E1-3C6D-11D4-804E-0050041A5111}» 5:

10: print «Registering COM server»

11: import win32com.server.register

12: win32com.server.register.UseCommandLine(TaxApplication)

Line 2: Exposes the method to be exported.

Line 3: Defines the name that the COM client application must use to connect to the object. Line 4: Defines the unique Class ID (clsid) used by the object. Line 12: Registers the TaxApplication class.

In order to test the program, we need to have an external COM client. Let’s use the Visual Basic for Applications Editor, which is present in both Excel and Word.

Open your Microsoft application, type ALT+F8 in the Macro dialog box, and select the option that creates a macro. Now, you need to type the following block of code:

Set TaxApplication = CreateObject(«Tax.Application») newamount = TaxApplication.PAtax(100) MsgBox newamount Set TaxApplication = Nothing

End Sub

Now, if you press F5, Visual Basic should display a message box showing the result of our simple tax operation, which, in our case, is 107.

To unregister your COM object you can either pass the argument —unregister when calling your script, or you can use the following line of code inside your Python program:

>>> win32com.server.register.UnregisterClasses(TaxApplication)

A very comprehensive example of using Microsoft Word and Excel is stored in the testMSOffice.py file, which is part of your PythonWin distribution. It’s worth checking out!!!

Word

The following code implements a simple wrapper for the Microsoft Word Application. To test it you need to create a Word document and replace its path in the code. The program will open this file, replace the first occurrence of the string «#name#» within the file, add a small bit of text to the end of the line, and print the file.

import win32com.client False = 0 True = -1 wdLine = 5

class WordApp:

self.app = win32com.client.Dispatch(«Word.Application») def open(self, document_file):

self.app.Documents.Open(document_file) def replace(self, source_selection, new_text): self.app.Selection.HomeKey(Unit=wdLine) self.app.Selection.Find.Text = source_selection self.app.Selection.Find.Execute() self.app.Selection.TypeText(Text=new_text) def addtext(self, new_text):

self.app.Selection.EndKey(Unit=wdLine) self.app.Selection.TypeText(Text=new_text) def printdoc(self):

self.app.Application.PrintOut() def close(self):

self.app.ActiveDocument.Close(SaveChanges =False)

worddoc = WordApp()

worddoc.open(r»s: template.doc»)

worddoc.replace(«#name#», «Andre Lessa»)

worddoc.addtext(» What do you want to learn ?»)

worddoc.printdoc()

worddoc.close

If you type in the name of the object’s attribute that accesses the Dispatch method, you get as a result, the COM object name:

<COMObject Word..Application.>

This object is an example of a dynamic dispatch object. The provided name indicates that the object is a generic COM object, and affirms that Python doesn’t know anything about it, except the name that you used to create it. All the information about this object is built dynamically.

Besides dynamic dispatches, you can also use static dispatches, which involve the generation of a .py file that contains support for the specific COM object. In CORBA speak, this is called stub generation, or IDL compilation.

In order to generate the Python files that support a specific COM object, you need to execute win32comclientmakepy.py. A list of Type Libraries will be displayed. Select one (for example, ‘Microsoft Word 8.0 Object Library’) and click OK. You can also call the makepy.py program directly from the command prompt by typing makepy.py «Microsoft Word 8.0 Object Library».

Now, Python knows exactly how to handle the interfaces before invoking the COM object. Although, you can’t see any differences, you can check that Python really knows something else now by querying the COM object:

>>> import win32com.client

>>> wd=win32com.client.Dispatch(«Word.Application») >>> wd

<win32com.gen_py.Microsoft Word 8.0 Object Library._Application>

Note that Python knows the explicit type of the object now.

All the compiled information is stored in a file in the win32com/gen_py directory. You probably won’t understand the filename because it is encoded. Actually, you don’t need to use this file at all. All the interface information is made available via win32com.client.Dispatch and win32com.client.constants.

If you really need to identify the name of the module that was generated, you can use the win32com.client.gencache module. This module has two functions: GetModuleForCLSID and GetModuleForProgID that return Python module objects you can use in your code.

makepy.py also automatically installs all generated constants from a library of types in an object called win32com.clients.constants. After creating the object, all the constants become available to you.

In the previous example, we had to initialize the constant wdLine, because the constants were not available. Now, after running makepy.py, you can replace the line self.app.Selection.EndKey(Unit=wdLine)

with self.app.Selection.EndKey(Unit=win32com.clients.constants.wdLine)

and remove the initialization line wdLine = 5

The next example uses the wdWindowStateMaximize constant to maximize Microsoft Word: >>> w.WindowState = win32com.client.constants.wdWindowStateMaximize

Excel

Next, we’ll see how to create COM clients using Microsoft Excel. The principle is very simple. Actually, it is the same one used previously for wrapping Microsoft Word, as it is demonstrated in the following example.

>>> import win32com.client

>>> excelapp = win32com.client.Dispatch(«Excel.Application») >>> excelapp.Visible = 1

Note that we have to change the Visible property in order to see the Excel application. The default behavior is to hide the application window because it saves processor cycles. However, the object is available to any COM client that asks for it.

As you can see in the example, Excel’s progid is Excel.Application.

After you create the Excel object, you are able to call its methods and set its properties. Keep in mind that the Excel Object Model has the following hierarchy: Application, WorkBook, Sheet, Range, and Cell.

Let’s play a little with Excel. The following statements write to the workbook:

>>> excelapp.Range(«A1:C1»).Value = «Hello», «Python», «World» >>> excelapp.Range(«A2:A2»).Value = ‘SPAM! SPAM! SPAM!’

Note that you can also use tuples to transport values:

>>> excelapp.Range(«A1:C1»).Value = (‘Hello’, ‘Python’, ‘World’) To print a selected area, you need to use the PrintOut() method:

>>> excelapp.Range(«A1:C1»).PrintOut()

What about entering date and time information? The following examples will show you how to set the Date/Time format for Excel cells.

First, call Excel’s time function:

>>> excelapp.Cells(4,3).Value = «=Now()»

>>> excelapp.Columns(«C»).EntireColumn.AutoFit()

The AutoFit() function is required in order to display the information, instead of showing «#######». Now, use Python to set the time you want:

>>> import time, pythoncom

>>> excelapp.Cells(4,1).Value = pythoncom.MakeTime(time.time())

>>> excelapp.Range(«A4:A4»).NumberFormat = «d/mm/yy h:mm»

>>> excelapp.Columns(«A:C»).EntireColumn.AutoFit()

Note that the Cells() structure works like a numeric array. That means that instead of using Excel’s notation of letters and numbers, you need to think of the spreadsheet as a numeric matrix.

Visual Basic

In order to implement a COM object using Python you need to implement a Python class that exposes the functionality to be exported. It is also necessary to assign two special attributes to this class, as required by the Python COM implementation.

The first attribute is the Class ID (_reg_clsid_). This attribute must contain a UUID, which can be generated by calling the pythoncom.CreateGuid() function. The other attribute is a friendly string that you will use to call the COM object (_reg_progid_), as follows:

class COMCalcServer:

_reg_clsid_ = ‘{ C76BEA61-3B39-11D4-8A7C-444553546170} ‘ _reg_progid_ = ‘COMCALCSERVER.VERSION1’ _public_methods_ = [‘mul,,,div,,,add,,,sub’]

Other interesting attributes are

• _public_methods—A list of all method names that you want to publicly expose to remote COM clients.

• _public_attrs—A list of all attribute names to be exposed to remote COM clients.

• _readonly_attrs—A list of all attributes that can be accessed, but not set. This list should be a subset of the list exposed by _public_attrs.

After creating the class, you need to register your COM object. The general technique is to run the module that implements the COM object as a script, in order to register the object:

import win32com.server.register win32com.server.register.UseCommandLine(COMCalcServer)

Notice that you need to inform the class object, and not a class instance. After the UseCommandLine() function has been successfully executed, the following message is returned by the Python interpreter:

Registered: COMCALCSERVER.VERSION1

When you have your COM object up and running, any automation-capable language, such as Python, Visual Basic, Delphi, or Perl, can use it.

The following example is a complete program that implements a calculator. First, you need to collect the unique IDs for your class:

Python 1.5.2 (#0, Apr 13 1999, 10:51:12) [MSC 32 bit (Intel)] on Win32

Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam

>>> import pythoncom

>>> print pythoncom.CreateGuid()

<iid:{C76BEA6 0-3B3 9-11D4-8A7C-444 553 546170}>

After informing the new clsid value to the _reg_clsid_ attribute, we have the following program:

# File: comcalcserver.py class COMCalcServer:

_reg_clsid_ = ‘{C76BEA61-3B39-11D4-8A7C-444553546170}’ _reg_progid_ = ‘COMCALCSERVER.VERSION1’ _public_methods_ = [‘mul,,,div,,,add,,,sub’] def mul(self, arg1, arg2):

return arg1 * arg2 def div(self, arg1, arg2):

return arg1 / arg2 def add(self, arg1, arg2):

return arg1 + arg2 def sub(self, arg1, arg2): return arg1 — arg2

import win32com.server.register win32com.server.register.UseCommandLine(COMCalcServer)

Make sure that all methods are included in the _public_methods_. Otherwise, the program will fail. Now, go to the DOS prompt and execute the program to register the COM object:

C:python>c:progra~1pythonpython comcalcserver.py Registered: COMCALCSERVER.VERSION1

To create the Visual Basic COM client, you need to create a Visual Basic Form that contains all the implementation details (see Figure 7.1).

Figure 7.1. A design for creating the Visual Basic Form.

Figure 7.1. A design for creating the Visual Basic Form.

Most of the time, the initialization steps are stored in the Form_Load section in order to be executed when the application starts:

Dim COMCalcServer as Object

Set COMCalcServer = CreateObject(«COMCALCSERVER.VERSION1»

Remember to always deallocate the objects before exiting the application. It’s good practice to do it in the Form Unload section:

Set COMCalcServer = Nothing

Public COMCalcServer As Object

Private Sub Form_Unload(Cancel As Integer)

Set COMCalcServer = Nothing End Sub

Sub InitCOMCalcServer()

Set COMCalcServer = CreateObject(«COMCALCSERVER.VERSION1») Exit Sub End Sub

Private Sub Command1_Click() Dim result As Double result = COMCalcServer.Mul(Val(Text1), Val(Text2)) MsgBox Text1 & «*» & Text2 & «=» & Str(result) End Sub

Private Sub Command2_Click() Dim result As Double result = COMCalcServer.Div(Val(Text1), Val(Text2)) MsgBox Text1 & «/» & Text2 & «=» & Str(result) End Sub

Private Sub Command3_Click() Dim result As Double result = COMCalcServer.Add(Val(Text1), Val(Text2)) MsgBox Text1 & «+» & Text2 & «=» & Str(result) End Sub

Private Sub Command4_Click() Dim result As Double result = COMCalcServer.Sub(Val(Text1), Val(Text2)) MsgBox Text1 & «-» & Text2 & «=» & Str(result) End Sub

Continue reading here: DBM Database Managers Databases

Was this article helpful?

Вопрос:

import win32com.client

app = win32com.client.Dispatch('Word.Application')
doc = app.Documents.Open(r'C:UsersSBYSMR10DesktopNew folder (2)GENERAL DATA.doc')
content=doc.Content.Text
app.Quit()
print content

content = " ".join(content.replace(u"xa0", " ").strip().split())

Лучший ответ:

Ответ №1

Ответ №2

Ответ №3

import os
directory='your/path/to/file/'
file='yourword.doc'
doc=open(directory+file,'r+b')
for line in doc:
line2=str(line)
print(line2))

Вот этот код

import win32com.client as client
import pythoncom, os

pythoncom.CoInitialize()
word = client.Dispatch('Word.Application')
doc = word.Documents.Open(os.path.abspath(document_word))
doc.SaveAs(os.path.abspath(document_pdf), FileFormat=17)
doc.Close()
word.Quit()
pythoncom.CoUninitialize()

не работает на win 2012 к которому я подключаюсь по удаленному рабочему столу.Локально у себя на компьютере он работает в двух случаях если я запускаю его с встроенным серваком джанги, или же под apache но при условии что сделаю как сказано здесь http://stackoverflow.com/questions/26991609/python… в общем этот совет локально лечит все , но на сервере где каждый под своим доменом, даже указав в DCOM себя и запустив APACHE так же под своими данными проблема не решается, хотелось бы отметить что word запускается однако я не могу получить к нему доступа , насколько я понимаю дело в правах доступа.Этот совет stackoverflow.com/questions/4803850/win32com-excel… не дает никаких результатов

Here are two ways:

Use win32com Use docx

1. Use win32com extension package

Only valid for windows platforms

Code:

#coding=utf-8
import win32com
from win32com.client import dispatch, dispatchex
word=dispatch ("word.application") #open word application
#word=dispatchex ("word.application") #Start a separate process
word.visible=0 #run in the background,Do not show
word.displayalerts=0 #no warning
path="g:/workspace/python/tmp/test.docx" #word file path
doc=word.documents.open (filename=path, encoding="gbk")
#content=doc.range (doc.content.start, doc.content.end)
#content=doc.range ()
print "----------------"
print "Number of paragraphs:", doc.paragraphs.count
#Use subscript to traverse paragraphs
for i in range (len (doc.paragraphs)):
  para=doc.paragraphs [i]
  print para.range.text
print "-------------------------"
#Iterate through paragraphs directly
for para in doc.paragraphs:
  print para.range.text
  #print para #Can only be used when the content of the document is full English
doc.close () #Close word document
#word.quit #Close the word program

2. Using the docx extension package

advantage:Does not rely on the operating system,Cross-platform

installation:

pip install python-docx

Code:

import docx
def read_docx (file_name):
  doc=docx.document (file_name)
  content=" n" .join ([para.text for para in doc.paragraphs])
  return content

Create form

#coding=utf-8
import docx
doc=docx.document ()
table=doc.add_table (rows=1, cols=3,) #Create a table with borders
hdr_cells=table.rows [0] .cells #Get all cells in row 0
hdr_cells [0] .text="name"
hdr_cells [1] .text="id"
hdr_cells [2] .text="desc"
#Add three rows of data
data_lines=3
for i in range (data_lines):
  cells=table.add_row (). cells
  cells [0] .text="name%s"%i
  cells [1] .text="id%s"%i
  cells [2] .text="desc%s"%i
rows=2
cols=4
table=doc.add_table (rows=rows, cols=cols)
val=1
for i in range (rows):
  cells=table.rows [i] .cells
  for j in range (cols):
    cells [j] .text=str (val * 10)
    val +=1
doc.save ("tmp.docx")

Read form

#coding=utf-8
import docx
doc=docx.document ("tmp.docx")
for table in doc.tables:#Iterate over all tables
  print "---- table ------"
  for row in table.rows:#traverse all rows of the table
    #row_str=" t" .join ([cell.text for cell in row.cells]) #one row of data
    #print row_str
    for cell in row.cells:
      print cell.text, " t",    print

Related style references: