Create a New Python File to Edit. 

3.      From a new Command Prompt window navigate to your favorite directory and please type:

notepad spelling.py

4.      notepad should now start a new window and inform you that ‘spelling.py not found’.  When asked if you’d like to create this new file, click the Yes button.

Use the clr Module to Access MS Word APIs

1.      Add the following to spelling.py:

import clr

The import statement is used to import other Python modules.  The clr module is provided by IronPython to do Common Language Runtime oriented tasks such as adding .NET assembly references.

2.      Add the following to spelling.py:

clr.AddReferenceByPartialName("Microsoft.Office.Interop.Word")

from Microsoft.Office.Interop.Word import ApplicationClass

 

These two lines inject Microsoft Word’s ApplicationClass COM class into our namespace.

3.      Add the following to spelling.py:

ms_word = ApplicationClass()

ms_word.Documents.Add()

 

Here we create a global variable, ms_word, which is really an instance of the winword.exe process.  Also, we add a document to it so that we can get Word to offer spelling suggestions later on in this exercise.

Checkpoint

At this point your copy of spelling.py should be capable of displaying functionality provided by the Microsoft Word API:

1.      Save spelling.py in notepad by holding down the Ctrl key and pressing S once.

2.      From the Command Prompt started earlier in this exercise, start IronPython in interactive mode.  This is accomplished by running the following in the Command Prompt window:

ipy –i spelling.py

The “-i” flag tells IronPython to run in interactive mode.  The Python module specified after “-i” (e.g., spelling.py) will be automatically run and its contents injected into the global namespace.  In the Command Prompt you should now see the following:

>>> 

3.      Type:

dir(ms_word)

in the Command Prompt and press the Enter key.  You should now see all methods and properties Word provides us with.

4.      Type:

ms_word.Visible = True

 in the Command Prompt and press Enter.  Microsoft Word should open a new window.

5.      Type:

ms_word.Quit()

in the Command Prompt and press Enter.  This shuts down the new instance of Word.

6.      Hold down the Ctrl key and press Z in the Command Prompt.  Now press Enter to exit out of the interactive session.

Check the Spelling of a Word

Add the following to spelling.py:

def check_word(x):

    return ms_word.CheckSpelling(x)

check_word returns True if Microsoft Word thinks the spelling of the input parameter, x, is correct.

Spelling Suggestions

Add the following to spelling.py:

def suggestions(x):

    res_objects = ms_word.GetSpellingSuggestions(x)

    return [y.Name for y in res_objects.GetEnumerator()]

The suggestions function asks MS Word for spelling suggestions of the misspelled word x.   It then returns these suggestions in the form of a Python list using list comprehension (i.e., the “[y.Name for y in …]” line).  Specifics about Python list comprehension are beyond the scope of this exercise, but you can learn more about them here - http://docs.python.org/tut/node7.html#SECTION007140000000000000000.

Checkpoint

1.      Save spelling.py in notepad.

2.      From the Command Prompt, run spelling.py in interactive mode again:

ipy –i spelling.py

3.      Play around with the functions you created:

>>> check_word("ab")

False

>>> suggestions("ab")

['abs', 'alb', 'am', 'an', 'as', 'at', 'a', 'bad', 'ad', 'ax']

>>> 

4.      Once you’re satisfied that the functions work as intended, press Ctrl+Z followed by Enter to exit out of the interactive session.

5.      You’ve now completed the first part of this exercise and may close notepad.

Create Another Python Module

1.      In the Command Prompt window please type:

notepad main.py

2.      notepad should now start a new window and inform you that ‘main.py not found’.  When asked if you’d like to create this new file, click the Yes button.

Open a Source File With “#”Style Comments

1.      Add the following to main.py:

import sys

import clr

from   spelling import *

sys is a standard CPython module which we use to access command-line parameters.  The clr module was described previously.  The third line above shows how to import all functions and global variables defined in the spelling.py module you created into main.py’s namespace.

2.      Add the following to main.py:

_temp_file = open(sys.argv[1], "r")

lines_in_file = _temp_file.readlines()

_temp_file.close()

This little snippet opens a file and stores all of its lines to a list/array called lines_in_file.  The name of the file is passed into IronPython from the command-line and obtained via the argv module attribute of sys.

Access Windows Presentation Foundation Types

Add the following to main.py:

clr.AddReferenceByPartialName("PresentationCore")

clr.AddReferenceByPartialName("PresentationFramework")

from System.Windows import Window, Application, HorizontalAlignment

from System.Windows.Controls import FlowDocumentScrollViewer, ComboBox

from System.Windows.Documents import FlowDocument, Paragraph, Run

from System.Windows.Media.Brushes import Black, PaleGreen, Red

Here we import various types from Microsoft’s Windows Presentation Foundation assemblies which we will later use to display our file.

Create a Window

1.      Add the following to main.py:

main_window = Window()

main_window.Title = "IronPython Comment Checker"

main_window.Background = Black

main_window.Foreground = PaleGreen

We’ve now created our main Window and set a few of its properties.

2.      Add the following text to main.py:

main_window.Content = FlowDocumentScrollViewer()

main_window.Content.Document = FlowDocument()

Our main_window object would not be very useful without any content attached to it.  For this reason we attach a document viewer which is used to dynamically display documents.

Generate a Paragraph

In this part of the exercise, we will add a function to create, populate, and return a Paragraph object which we will later add to the document.  This paragraph will consist of the entire file passed in from the command prompt (e.g., misspelled.py) with suggestions for all misspelled words in “#” style comments.

Add the following to main.py:

def create_paragraph(file_lines):

    #Create a "Paragraph" object to hold all text from the file

    paragraph = Paragraph()

    #Text in the paragraph will have a font size of 16

    paragraph.FontSize = 16.0

 

    #Go through every line in the file passed in from the command

    #line...

    for x in file_lines:

        #...looking for Python/Ruby/PowerShell style comments

        if "#" in x:

 

            #Split the line whenever a comment is found

            first, second = x.split("#", 1)

 

            #Add the first part of the line to the paragraph

            paragraph.Inlines.Add(Run(first + "#"))

           

            #Split the second part of the line based on whitespace

            for y in second.split():

                #If the word is misspelled...

                if not check_word(y):

                    #Add a drop down menu to offer alternative

                    #spelling suggestions

                    c = ComboBox()

                    c.Background = Red

                    c.HorizontalAlignment = HorizontalAlignment.Left

                    #Add the misspelled word to the drop down menu

                    #and make it the first item

                    c.AddText(y)

                    c.SelectedItem = y

                    #Offer alternative spellings in the drop down menu

                    for suggest in suggestions(y):

                        c.AddText(suggest)

                    #Add the combo box to the drop down menu

                    paragraph.Inlines.Add(c)

                else:

                    paragraph.Inlines.Add(Run(y))

                paragraph.Inlines.Add(" ")

            paragraph.Inlines.Add(Run("\n"))

        else:

            #If there's no comment in the line, just directly

            #add it to the paragraph

            paragraph.Inlines.Add(Run(x))

    return paragraph

Attach the Paragraph to the Document

Add the following to main.py:

main_window.Content.Document.Blocks.Add(create_paragraph(lines_in_file))

main_window.Show()

Application().Run()

ms_word.Quit()

 

Last but not least we:

1.      Add the paragraph created in the previous step to our document

2.      Make main_window visible by calling the Show method

3.      Call Application().Run() to begin accepting events and stop ipy.exe from exiting out of main.py until the end-user closes the window.

4.      Finally when the main window has finished running, we tell Microsoft Word to terminate.  Take note that this is the same ms_word object found in the spelling.py module.

Run Your Application

Now that you’ve finished coding this part of the exercise, it’s time to run it!  Due to the Application().Run() call made in the last step, you cannot pass the “-i” flag to ipy.  Instead you should call main.py using one of the following two patterns:

ipy main.py misspelled.py

or preferably:

            ipyw main.py misspelled.py

from the Command Prompt.  ipy is a console process and ipyw returns control immediately from the Command Prompt.  The second parameter to ipy/ipyw above, misspelled.py, is a file containing “#” style code comments and many misspelled words.  This file is denoted by “sys.argv[1]” in main.py.