Skip to content

C
cpython
Commit c15ab036 authored by Jack Jansen's avatar Jack Jansen
Browse files
Options

Updated the applescript documentation for te new framework, and replaced the... 

Updated the applescript documentation for te new framework, and replaced the Eudora example with one that uses Disk Copy (which everyone running MacOS 8 or
higher should have).
parent e743c6e2
Hide whitespace changes
Inline Side-by-side
Showing with 1252 additions and 691 deletions
Mac/Demo/applescript.html
View file @ c15ab036
......@@ -3,8 +3,7 @@
<H1>Using Open Scripting Extension from Python</H1>
<HR>
OSA support in Python is still far from complete, and what
support there is is likely to change in the forseeable future. Still,
OSA support in Python is still not 100% complete, but
there is already enough in place to allow you to do some nifty things
to other programs from your python program. <P>
......@@ -20,11 +19,27 @@ that and use that module to control the application. Because we want
to concentrate on the OSA details we don't bother with a real
user-interface for our application. <p>
The application we are going to script is Eudora Light, a free mail
program from <A HREF="http://www.qualcomm.com">QualComm</A>. This is a
very versatile mail-reader, and QualComm has an accompanying
commercial version once your needs outgrow Eudora Light. Our program
will tell Eudora to send queued mail, retrieve mail or quit. <p>
The application we are going to script is Disk Copy, Apple's standard
utility for making copies of floppies, creating files that are mountable
as disk images, etc. <p>
<H2>Python OSA architecture</H2>
Open Scripting suites and inheritance can be modelled rather nicely with
with Python packages, so for each application we want to script we generate
a package. Each suite defined in the application becomes a module in the
package, and the package main module imports everything from all the
submodules and glues all the classes (Python terminology, OSA terminology is
events, AppleScript terminology is verbs) together. <p>
A suite in an OSA application can extend the functionality of a standard
suite, and this is implemented in Python by importing everything from the
module that implements the standard suite and overriding anything that has
been extended. The standard suites live in the StdSuite package. <p>
This all sounds complicated, and you can do strange and wondrous things
with it once you fully understand it, but the good news is that simple
scripting is actually pretty simple. <p>
<H2>Creating the Python interface module</H2>
......@@ -33,51 +48,60 @@ for an 'AETE' or 'AEUT' resource, the internal representation of the
AppleScript dictionary. This tool is called
<CODE>gensuitemodule.py</CODE>, and lives in <CODE>Mac:scripts</CODE>.
When we start it, it asks us for an input file and we point it to the
Eudora Light executable. It starts parsing the AETE resource, and for
Disk Copy executable. <p>
Next it wants a folder where it will store the package it is going to generate.
Note that this is the package folder, not the parent folder, so we
navigate to <code>Python:Mac:Demo:applescript</code>, create a folder
<code>Disk_Copy</code> and select that. <p>
Next it wants the folder from which it should import the standard suites. Here
you always select <code>Python:Mac:Lib:lib-scriptpackages</code>. (There is
one exception to this rule: when you are generating <code>StdSuites</code> itself
you select <code>cancel</code>, for obvious reasons). <p>
It starts parsing the AETE resource, and for
each AppleEvent suite it finds it prompts us for the filename of the
resulting python module. Remember to change folders for the first
module, you don't want to clutter up the Eudora folder with your python
interfaces. If you want to skip a suite you press cancel and the process
continues with the next suite. In the case of Eudora, you do
<EM>not</EM> want to generate the Required and Standard suites, because
they are identical to the standard ones which are pregenerated (and
empty in the eudora binary). AppleScript understands that an empty suite
means "incorporate the whole standard suite by this name",
gensuitemodule does not currently understand this. Creating the empty
<CODE>Required_Suite.py</CODE> would hide the correct module of that
name from our application. <p>
continues with the next suite. <p>
Gensuitemodule may ask you questions like "Where is enum 'xyz ' declared?".
For the first time, cancel out of this dialog after taking down the
enum (or class or prop) name. After you've created all the suites look
for these codes, in the suites generated here and in the standard suites.
If you've found them all run gensuitemodule again and point it to the right
file for each declaration. Gensuitemodule will generate the imports to make the
reference work. <p>
This is either due to a misunderstanding on my part or (rather too common)
bugs in the AETE resources. Pressing <code>cancel</code> is usually the
right option, it will cause the specific enum not to be treated as an enum
but as a "normal" type. As things like fsspecs and TEXT strings clearly are
not enumerators this is correct. If someone understands what is really going on
here please let me know. <p>
<BLOCKQUOTE>
Time for a sidebar. If you want to re-create
<CODE>Required_Suite.py</CODE> or one of the other standard modules
you should look in <CODE>System Folder:Extensions:Scripting
Additions:Dialects:English Dialect</CODE>, that is where the core
AppleEvent dictionaries live. Also, if you are looking for the
<CODE>Finder_Suite</CODE> interface: don't look in the finder (it has
an old System 7.0 scripting suite), look at the extension <CODE>Finder
Scripting Extension</CODE>. <p>
Time for a sidebar. If you want to re-create the StdSuite modules
you should look in one of two places. On older systems you will find the
AEUT resources in <CODE>System Folder:Extensions:Scripting
Additions:Dialects:English Dialect</CODE>. On newer systems you will
find them in <code>System Folder:Extensions:Applescript</code>. <p>
</BLOCKQUOTE>
Let's glance at the <A
HREF="scripting/Eudora_Suite.py">Eudora_Suite.py</A> just created. You
HREF="applescript/Disk_Copy">Disk_Copy</A> package just created. You
may want to open Script Editor alongside, and have a look at how it
interprets the dictionary. EudoraSuite.py starts with some
boilerplate, then a big class definition with methods for each
AppleScript Verb, then some small class definitions and then some dictionary
initializations. <p>
The <CODE>Eudora_Suite</CODE> class is the bulk of the code
interprets the dictionary. The main package module is in <code>__init__.py</code>
and the only interesting bit is the <code>Disk_Copy</code> class, which
includes the event handling classes from the individual suites. It also
inherits <code>aetools.TalkTo</code>, which is a base class that handles all
details on how to start the program and talk to it, and a class variable
<code>_signature</code> which is the default application this class will talk
to (you can override this in various when you instantiate your class, see
<code>aetools.py</code> for details).
<p>
The <a href="applescript/Disk_Copy/Special_Events.py">Special_Events</a>
module is a nice example of a suite module.
The <CODE>Special_Events_Events</CODE> class is the bulk of the code
generated. For each verb it contains a method. Each method knows what
arguments the verb expects, and it makes handy use of the keyword
argument scheme introduced in Python 1.3 to present a palatable
arguments the verb expects, and it makes handy use of keyword
arguments to present a palatable
interface to the python programmer. You will see that each method
calls some routines from <CODE>aetools</CODE>, an auxiliary module
living in <CODE>Lib:toolbox</CODE> which contains some other nifty
......@@ -85,9 +109,7 @@ AppleEvent tools as well. Have a look at it sometime, there is (of
course) no documentation yet. <p>
The other thing you notice is that each method calls
<CODE>self.send</CODE>, but no such method is defined. You will have
to provide it by subclassing or multiple inheritance, as we shall see
later. <p>
<CODE>self.send</CODE>, this comes from the <code>aetools.TalkTo</code> baseclass. <p>
After the big class we get a number of little class declarations. These
declarations are for the (appleevent) classes and properties in the suite.
......@@ -95,7 +117,7 @@ They allow you to create object IDs, which can then be passed to the verbs.
For instance, to get the name of the sender of the first message in mailbox
inbox you would use <code>mailbox("inbox").message(1).sender</code>. It is
also possible to specify this as <code>sender(message(1, mailbox("inbox")))</code>,
which is sometimes needed because these classes don't inherit correctly
which is sometimes needed because these classes don't always inherit correctly
from baseclasses, so you may have to use a class or property from another suite. <p>
<blockquote>
......@@ -112,11 +134,11 @@ Next we get the enumeration dictionaries, which allow you to pass
english names as arguments to verbs, so you don't have to bother with the 4-letter
type code. So, you can say
<CODE><PRE>
eudora.notice(occurrence="mail_arrives")
diskcopy.create(..., filesystem="Mac OS Standard")
</PRE></CODE>
instead of the rather more cryptic
as it is called in Script Editor, in stead of the cryptic lowlevel
<CODE><PRE>
eudora.notice(occurrence="wArv")
diskcopy.create(..., filesystem="Fhfs")
</PRE></CODE><p>
Finally, we get the "table of contents" of the module, listing all classes and such
......@@ -124,54 +146,25 @@ by code, which is used by gensuitemodule. <p>
<H2>Using a Python suite module</H2>
Now that we have created the suite module we can use it in an
application. We do this by creating a class that inherits
<CODE>Eudora_Suite</CODE> and the <CODE>TalkTo</CODE> class from
<CODE>aetools</CODE>. The <CODE>TalkTo</CODE> class is basically a
container for the <CODE>send</CODE> method used by the methods from
the suite classes. <p>
Actually, our class will also inherit <CODE>Required_Suite</CODE>,
because we also need functionality from that suite: the quit
command. Gensuitemodule could have created this completely derived
class for us, since it has access to all information needed to build
the class but unfortunately it does not do so at the moment. All in
all, the heart of our program looks like this:
Now that we have created the suite module we can use it in a Python script.
In older MacPython distributions this used to be a rather
complicated affair, but with the package scheme and with the application signature
known by the package it is very simple: you import the package and instantiate
the class, as
<CODE><PRE>
import Eudora_Suite, Required_Suite, aetools
class Eudora(Eudora_Suite.Eudora_Suite, Required_Suite.Required_Suite, \
aetools.TalkTo):
pass
talker = Disk_Copy.Disk_Copy(start=1)
</PRE></CODE>
Yes, our class body is <CODE>pass</CODE>, all functionality is already
provided by the base classes, the only thing we have to do is glue it
together in the right way. <p>
You will usually specify the start=1: it will run the application if it is
not already running. You may want to omit it if you want to talk to the application
only if it is already running, or if the application is something like the Finder. <p>
Looking at the sourcefile <A
HREF="scripting/testeudora.py">testeudora.py</A> we see that it starts
with some imports. Then we get the class definition
for our main object and a constant giving the signature of Eudora. <p>
This, again, needs a little explanation. There are various ways to
describe to AppleScript which program we want to talk to, but the
easiest one to use (from Python, at least) is creator
signature. Application name would be much nicer, but Python currently
does not have a module that interfaces to the Finder database (which
would allow us to map names to signatures). The other alternative,
<CODE>ChooseApplication</CODE> from the program-to-program toolbox, is
also not available from Python at the moment. <p>
If you specify the application by creator you can specify an optional
<CODE>start</CODE> parameter, which will cause the application to be
started if it is not running. <P>
HREF="applescript/makedisk.py">makedisk.py</A> we see that it starts
with some imports.
The main program itself is a wonder of simplicity. We create the
object that talks to Eudora (passing the signature as argument), ask
the user what she wants and call the appropriate method of the talker
object. The use of keyword arguments with the same names as used by
AppleScript make passing the parameters a breeze. <p>
object that talks to Disk Copy, creates a disk and mounts it. <p>
The exception handling does need a few comments, though. Since
AppleScript is basically a connectionless RPC protocol nothing happens
......@@ -188,8 +181,7 @@ If you want to use any of the scripting additions (or OSAXen, in
everyday speech) from a Python program you can use the same method
as for applications, i.e. run <CODE>gensuitemodule</CODE> on the
OSAX (commonly found in <CODE>System Folder:Extensions:Scripting Additions</CODE>
or something similar), define a class which inherits the generated
class and <CODE>aetools.TalkTo</CODE> and instantiate it. The application
or something similar). There is one minor gotcha: the application
signature to use is <CODE>'MACS'</CODE>. <P>
There are two minor points to watch out for when using gensuitemodule
......@@ -199,11 +191,8 @@ watch out for name conflicts, so, and make sure you select a reasonable dialect
(some of the non-english dialects cause gensuitemodule to generate incorrect
Python code). <P>
That concludes our simple example. Again, let me emphasize that
scripting support in Python is not very complete at the moment, and
the details of how to use AppleEvents will definitely change in the
near future. This will not only fix all the ideosyncracies noted in
this document but also break existing programs, since the current
suite organization will have to change to fix some of the problems.
Still, if you want to experiment with AppleEvents right now: go ahead!
<p>
<H2>Further Reading</H2>
If you want to look at more involved examples of applescripting look at the standard
modules <code>findertools</code> and <code>nsremote</code>, or (possibly better, as it
is more involved) <code>fullbuild</code> from the Mac:scripts folder.
Mac/Demo/applescript/Disk_Copy/Special_Events.py 0 → 100644
View file @ c15ab036
"""Suite Special Events: Commands for mounting Disk Copy images
Level 1, version 1
Generated from Macintosh HD:Hulpprogramma's:Disk Copy
AETE/AEUT resource version 1/0, language 0, script 0
"""
import aetools
import MacOS
_code = 'ddsk'
class Special_Events_Events:
_argmap_mount = {
'access_mode' : 'Acss',
'checksum_verification' : 'VChk',
'signature_verification' : 'VSig',
'RAM_caching' : 'Cach',
}
def mount(self, _object, _attributes={}, **_arguments):
"""mount: Mounts an Disk Copy image as a disk volume
Required argument: a reference to the disk image to be mounted
Keyword argument access_mode: the access mode for mounted volume (default is "any", i.e. best possible)
Keyword argument checksum_verification: Verify the checksum before mounting?
Keyword argument signature_verification: Verify the DigiSign signature before mounting?
Keyword argument RAM_caching: Cache the disk image in RAM? (if omitted, don't cache)
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: a reference to mounted disk
"""
_code = 'ddsk'
_subcode = 'Moun'
aetools.keysubst(_arguments, self._argmap_mount)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'Acss', _Enum_Acss)
aetools.enumsubst(_arguments, 'VChk', _Enum_bool)
aetools.enumsubst(_arguments, 'VSig', _Enum_bool)
aetools.enumsubst(_arguments, 'Cach', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_execute_DiskScript = {
'checksum_verification' : 'VChk',
'signature_verification' : 'VSig',
}
def execute_DiskScript(self, _object, _attributes={}, **_arguments):
"""execute DiskScript: Executes a Disk Copy-specific DiskScript
Required argument: a reference to the DiskScript to execute
Keyword argument checksum_verification: Should checksums be verified when mounting images referenced in the DiskScript?
Keyword argument signature_verification: Should the DigiSign signature of the DiskScript and the images it references be verified?
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'ddsk'
_subcode = 'XEQd'
aetools.keysubst(_arguments, self._argmap_execute_DiskScript)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'VChk', _Enum_bool)
aetools.enumsubst(_arguments, 'VSig', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def unmount(self, _object, _attributes={}, **_arguments):
"""unmount: Unmount and eject (if necessary) a volume
Required argument: a reference to disk to be unmounted (and ejected)
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'ddsk'
_subcode = 'Umnt'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_create = {
'saving_as' : 'SvAs',
'logical_blocks' : 'Blks',
'zeroing' : 'Zero',
'leave_image_mounted' : 'Moun',
'filesystem' : 'Fsys',
}
def create(self, _object, _attributes={}, **_arguments):
"""create: Create a new Disk Copy document
Required argument: the name of the volume to create
Keyword argument saving_as: the disk image to be created
Keyword argument logical_blocks: the number of logical blocks
Keyword argument zeroing: Should all blocks on the disk be set to zero?
Keyword argument leave_image_mounted: Should the image be mounted after it is created?
Keyword argument filesystem: file system to use (Mac OS Standard/compatible, Mac OS Enhanced)
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: a reference to newly created disk image (or newly mounted disk)
"""
_code = 'ddsk'
_subcode = 'Crea'
aetools.keysubst(_arguments, self._argmap_create)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'SvAs', _Enum_fss_)
aetools.enumsubst(_arguments, 'Blks', _Enum_long)
aetools.enumsubst(_arguments, 'Zero', _Enum_bool)
aetools.enumsubst(_arguments, 'Moun', _Enum_bool)
aetools.enumsubst(_arguments, 'Fsys', _Enum_Fsys)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def verify_checksum(self, _object, _attributes={}, **_arguments):
"""verify checksum: Verify the checksum of a Disk Copy 4.2 or a Disk Copy 6.0 read-only document
Required argument: the disk image to be verified
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: the result of the checksum verification
"""
_code = 'ddsk'
_subcode = 'Vcrc'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def verify_signature(self, _object, _attributes={}, **_arguments):
"""verify signature: Verify the DigiSign signature for a Disk Copy document
Required argument: the disk image to be verified
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: Is the DigiSign signature valid?
"""
_code = 'ddsk'
_subcode = 'Vsig'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_sign_image = {
'using_signer' : 'Sinr',
}
def sign_image(self, _object, _attributes={}, **_arguments):
"""sign image: Add a DigiSign signature to a Disk Copy document
Required argument: the disk image to be signed
Keyword argument using_signer: a reference to signer file to use
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'ddsk'
_subcode = 'Asig'
aetools.keysubst(_arguments, self._argmap_sign_image)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'Sinr', _Enum_alis)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_create_a_floppy_from = {
'signature_verification' : 'VSig',
'erase_confirmation' : 'Cfrm',
'make_multiple_floppies' : 'Mult',
}
def create_a_floppy_from(self, _object, _attributes={}, **_arguments):
"""create a floppy from: create a floppy disk from a Disk Copy document
Required argument: the disk image to make a floppy from
Keyword argument signature_verification: Should the DigiSign signature be verified before creating a floppy disk?
Keyword argument erase_confirmation: Should the user be asked to confirm the erasure of the previous contents of floppy disks?
Keyword argument make_multiple_floppies: Should the user be prompted to create multiple floppy disks?
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'ddsk'
_subcode = 'Bfpy'
aetools.keysubst(_arguments, self._argmap_create_a_floppy_from)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'VSig', _Enum_bool)
aetools.enumsubst(_arguments, 'Cfrm', _Enum_bool)
aetools.enumsubst(_arguments, 'Mult', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_check_image = {
'details' : 'ChDe',
}
def check_image(self, _object, _attributes={}, **_arguments):
"""check image: Check the disk images internal data structures for any inconsistencies. Works on NDIF, Disk Copy 4.2, DART, or DiskSet images.
Required argument: the disk image to be verified
Keyword argument details: Should the disk image details be displayed?
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: a record containing a boolean (true/false) value if the image passes consistency tests, and the numbers of warnings and errors
"""
_code = 'ddsk'
_subcode = 'Chek'
aetools.keysubst(_arguments, self._argmap_check_image)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'ChDe', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_segment_image = {
'segment_count' : 'SGCT',
'segment_size' : 'SGSZ',
'segment_name' : 'SGNM',
'image_ID' : 'SGID',
}
def segment_image(self, _object, _attributes={}, **_arguments):
"""segment image: Segment a NDIF R/W or R/O image into smaller pieces
Required argument: the disk image to be segmented
Keyword argument segment_count: the number of image segments to create
Keyword argument segment_size: the size of image segments (in blocks) to create
Keyword argument segment_name: the root name for each image segment file
Keyword argument image_ID: string used to generate a unique image ID to group the segments
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: a list of references to the image segments created
"""
_code = 'ddsk'
_subcode = 'SGMT'
aetools.keysubst(_arguments, self._argmap_segment_image)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_create_SMI = {
'source_images' : 'SMI1',
'launching_application' : 'SMI2',
'launching_document' : 'SMI3',
'version_string' : 'SMI4',
'checksum_verification' : 'VChk',
'signature_verification' : 'VSig',
'image_signing' : 'SImg',
}
def create_SMI(self, _object, _attributes={}, **_arguments):
"""create SMI: Creates a self-mounting image (SMI) from a list of NDIF disk images
Required argument: the self-mounting image to create
Keyword argument source_images: a list of references to sources images
Keyword argument launching_application: the path to an application to launch
Keyword argument launching_document: the path to a document to open
Keyword argument version_string: sets the 'vers' 1 resource of the self-mounting image
Keyword argument checksum_verification: Should the checksum of the source images be verified before creating the SMI?
Keyword argument signature_verification: Should the DigiSign signature of the source images be verified before creating the SMI?
Keyword argument image_signing: Should the SMI be given a digital signature when it is created?
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: a reference to the self-mounting image created
"""
_code = 'ddsk'
_subcode = 'MSMI'
aetools.keysubst(_arguments, self._argmap_create_SMI)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'VChk', _Enum_bool)
aetools.enumsubst(_arguments, 'VSig', _Enum_bool)
aetools.enumsubst(_arguments, 'SImg', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
class Verify_Checksum_reply_record(aetools.ComponentItem):
"""Verify Checksum reply record - """
want = 'Rcrc'
class validity(aetools.NProperty):
"""validity - true if checksum is valid """
which = 'Vlid'
want = 'bool'
class expected_checksum(aetools.NProperty):
"""expected checksum - checksum value stored in the image header (in hexadecimal) """
which = 'crcE'
want = 'TEXT'
class calculated_checksum(aetools.NProperty):
"""calculated checksum - checksum value actually calculated (in hexadecimal) """
which = 'crcA'
want = 'TEXT'
class Check_Image_reply_record(aetools.ComponentItem):
"""Check Image reply record - """
want = 'Rchk'
class consistency(aetools.NProperty):
"""consistency - Does the image pass consistency checks? """
which = 'Rch1'
want = 'bool'
class error_count(aetools.NProperty):
"""error count - the number of errors recorded """
which = 'Rch2'
want = 'long'
class warning_count(aetools.NProperty):
"""warning count - the number of warnings recorded """
which = 'Rch3'
want = 'long'
Verify_Checksum_reply_record._propdict = {
'validity' : validity,
'expected_checksum' : expected_checksum,
'calculated_checksum' : calculated_checksum,
}
Verify_Checksum_reply_record._elemdict = {
}
Check_Image_reply_record._propdict = {
'consistency' : consistency,
'error_count' : error_count,
'warning_count' : warning_count,
}
Check_Image_reply_record._elemdict = {
}
_Enum_Acss = {
'read_and_write' : 'RdWr', # read/write access
'read_only' : 'Rdxx', # read-only access
'any' : 'Anyx', # best possible access
}
_Enum_Fsys = {
'Mac_OS_Standard' : 'Fhfs', # classic HFS file system
'compatible_Mac_OS_Extended' : 'Fhf+', # new HFS+ file system
}
_Enum_alis = None # XXXX enum alis not found!!
_Enum_fss_ = None # XXXX enum fss not found!!
_Enum_long = None # XXXX enum long not found!!
_Enum_bool = None # XXXX enum bool not found!!
#
# Indices of types declared in this module
#
_classdeclarations = {
'Rchk' : Check_Image_reply_record,
'Rcrc' : Verify_Checksum_reply_record,
}
_propdeclarations = {
'crcE' : expected_checksum,
'Rch2' : error_count,
'crcA' : calculated_checksum,
'Rch3' : warning_count,
'Vlid' : validity,
'Rch1' : consistency,
}
_compdeclarations = {
}
_enumdeclarations = {
'Acss' : _Enum_Acss,
'Fsys' : _Enum_Fsys,
}
Mac/Demo/applescript/Disk_Copy/Standard_Suite.py 0 → 100644
View file @ c15ab036
"""Suite Standard Suite: Common terms for most applications
Level 1, version 1
Generated from Macintosh HD:Hulpprogramma's:Disk Copy
AETE/AEUT resource version 1/0, language 0, script 0
"""
import aetools
import MacOS
_code = 'Core'
class Standard_Suite_Events:
_argmap_save = {
'_in' : 'kfil',
'using_format' : 'SvAs',
'checksum_verification' : 'VChk',
'signature_verification' : 'VSig',
'image_signing' : 'SImg',
'leave_image_mounted' : 'Moun',
'percent_free_space' : 'Slop',
'logical_blocks' : 'Blks',
'zeroing' : 'Zero',
}
def save(self, _object, _attributes={}, **_arguments):
"""save: Save an object
Required argument: the source object
Keyword argument _in: the target object
Keyword argument using_format: the format for the target
Keyword argument checksum_verification: Should the checksum be verified before saving?
Keyword argument signature_verification: Should the DigiSign signature be verified before saving?
Keyword argument image_signing: Should the image be signed?
Keyword argument leave_image_mounted: Should the image be mounted after saving?
Keyword argument percent_free_space: percent free space to reserve (for image folder operation, 0-255%)
Keyword argument logical_blocks: number of logical blocks in the image (for image folder operation)
Keyword argument zeroing: Should all the blocks in the image be set to zeros? (for image folder operation)
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: the result of the save operation
"""
_code = 'core'
_subcode = 'save'
aetools.keysubst(_arguments, self._argmap_save)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'kfil', _Enum_obj_)
aetools.enumsubst(_arguments, 'SvAs', _Enum_SvAs)
aetools.enumsubst(_arguments, 'VChk', _Enum_bool)
aetools.enumsubst(_arguments, 'VSig', _Enum_bool)
aetools.enumsubst(_arguments, 'SImg', _Enum_bool)
aetools.enumsubst(_arguments, 'Moun', _Enum_bool)
aetools.enumsubst(_arguments, 'Slop', _Enum_long)
aetools.enumsubst(_arguments, 'Blks', _Enum_long)
aetools.enumsubst(_arguments, 'Zero', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def do_script(self, _object, _attributes={}, **_arguments):
"""do script: Execute an attached script located in the folder "Scripts"
Required argument: the script to be executed
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'dosc'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
class application(aetools.ComponentItem):
"""application - The Disk Copy application """
want = 'capp'
class version(aetools.NProperty):
"""version - the version of this application """
which = 'vers'
want = 'vers'
class name(aetools.NProperty):
"""name - the name of this application """
which = 'pnam'
want = 'TEXT'
class comment(aetools.NProperty):
"""comment - the comment associated with the application """
which = 'comt'
want = 'TEXT'
class driver_version(aetools.NProperty):
"""driver version - the version of the disk image driver """
which = 'dVer'
want = 'vers'
class nonejectable_mode(aetools.NProperty):
"""nonejectable mode - Should mounted images be non-ejectable? """
which = 'otto'
want = 'bool'
class save_log_file(aetools.NProperty):
"""save log file - Should the log file be saved on disk? """
which = 'PSaL'
want = 'bool'
class use_speech(aetools.NProperty):
"""use speech - Should Disk Copy use spoken feedback? """
which = 'PTlk'
want = 'bool'
class smart_Save_As(aetools.NProperty):
"""smart Save As - Should the Save As... dialog box automatically go to the right folder? """
which = 'PSSP'
want = 'bool'
class checksum_verification(aetools.NProperty):
"""checksum verification - Should image checksums be verified? """
which = 'PVeC'
want = 'bool'
class signature_verification(aetools.NProperty):
"""signature verification - Should digital signatures be verified? """
which = 'PVeS'
want = 'bool'
class exclude_DiskScripts(aetools.NProperty):
"""exclude DiskScripts - Should images referenced in DiskScripts/DiskSets be excluded from verification? """
which = 'PExD'
want = 'bool'
class exclude_remote_images(aetools.NProperty):
"""exclude remote images - Should images that are located on network volumes be excluded from verification? """
which = 'PExR'
want = 'bool'
class image_signing(aetools.NProperty):
"""image signing - Should images be signed with a digital signature? """
which = 'PSiI'
want = 'bool'
class leave_image_mounted(aetools.NProperty):
"""leave image mounted - Should images be mounted after they are created? """
which = 'PMoA'
want = 'bool'
class erase_confirmation(aetools.NProperty):
"""erase confirmation - Should the user be required to confirm commands that erase disks? """
which = 'PCoE'
want = 'bool'
class zeroing(aetools.NProperty):
"""zeroing - Should all blocks of a new image be set to zero? """
which = 'PZeB'
want = 'bool'
class default_create_size(aetools.NProperty):
"""default create size - the default size for a new image, in blocks (512 bytes per block) """
which = 'PDeS'
want = 'long'
class default_create_name(aetools.NProperty):
"""default create name - the default volume name for a new image """
which = 'PDeN'
want = 'TEXT'
class make_multiple_floppies(aetools.NProperty):
"""make multiple floppies - Should the user be prompted to make multiple floppy disk images at a time? """
which = 'PBuM'
want = 'bool'
class auto_image_upon_insert(aetools.NProperty):
"""auto image upon insert - Should a newly-inserted disk automatically be processed into an image? """
which = 'Paim'
want = 'bool'
class eject_after_auto_image(aetools.NProperty):
"""eject after auto image - Should auto-imaged disks be ejected afterwards? """
which = 'Pejc'
want = 'bool'
class auto_copy_upon_floppy_insert(aetools.NProperty):
"""auto copy upon floppy insert - Instead of auto-imaging, should newly-inserted floppy disks be copied? """
which = 'Pcpf'
want = 'bool'
class volume_suffix(aetools.NProperty):
"""volume suffix - the default volume name suffix """
which = 'PDiE'
want = 'TEXT'
class image_suffix(aetools.NProperty):
"""image suffix - the default image name suffix """
which = 'PImE'
want = 'TEXT'
class default_file_system(aetools.NProperty):
"""default file system - the default file system type for new blank images """
which = 'Pfsy'
want = 'Fsys'
class default_image_format(aetools.NProperty):
"""default image format - the default image file format """
which = 'Pdfm'
want = 'SvAs'
class disk(aetools.ComponentItem):
"""disk - A mounted volume """
want = 'Disk'
name = name
comment = comment
class locked(aetools.NProperty):
"""locked - Is the disk locked? """
which = 'islk'
want = 'bool'
class creation_date(aetools.NProperty):
"""creation date - the creation date of disk """
which = 'ascd'
want = 'ldt '
class modification_date(aetools.NProperty):
"""modification date - the modification date of disk """
which = 'asmo'
want = 'ldt '
class crc32_checksum(aetools.NProperty):
"""crc32 checksum - the crc-32 checksum of the disk """
which = 'Xcrc'
want = 'TEXT'
class disk_copy_4_2e_2_checksum(aetools.NProperty):
"""disk copy 4.2 checksum - the Disk Copy 4.2 checksum of the disk """
which = 'Xc42'
want = 'TEXT'
class block_count(aetools.NProperty):
"""block count - the number of blocks on disk """
which = 'Xblk'
want = 'long'
class file_system(aetools.NProperty):
"""file system - the file system used on disk """
which = 'Xfsi'
want = 'TEXT'
class folder(aetools.ComponentItem):
"""folder - A folder or directory on a disk """
want = 'Fold'
name = name
comment = comment
creation_date = creation_date
modification_date = modification_date
class disk_image(aetools.ComponentItem):
"""disk image - A disk image file """
want = 'DImg'
name = name
comment = comment
locked = locked
creation_date = creation_date
modification_date = modification_date
class file_format(aetools.NProperty):
"""file format - the format of the disk image file """
which = 'Ifmt'
want = 'TEXT'
class signed(aetools.NProperty):
"""signed - Does the disk image have a DigiSign signature? """
which = 'Isin'
want = 'bool'
class compressed(aetools.NProperty):
"""compressed - Is the disk image compressed? """
which = 'Icom'
want = 'bool'
class segmented(aetools.NProperty):
"""segmented - Is the disk image segmented? """
which = 'Iseg'
want = 'bool'
class segments(aetools.NProperty):
"""segments - a list of references to other segments that make up a complete image """
which = 'Isg#'
want = 'fss '
class disk_name(aetools.NProperty):
"""disk name - the name of the disk this image represents """
which = 'Idnm'
want = 'TEXT'
crc32_checksum = crc32_checksum
disk_copy_4_2e_2_checksum = disk_copy_4_2e_2_checksum
block_count = block_count
file_system = file_system
class data_fork_size(aetools.NProperty):
"""data fork size - the size (in bytes) of the data fork of the disk image """
which = 'Idfk'
want = 'long'
class resource_fork_size(aetools.NProperty):
"""resource fork size - the size (in bytes) of the resource fork of the disk image """
which = 'Irfk'
want = 'long'
class Save_reply_record(aetools.ComponentItem):
"""Save reply record - Result from the save operation """
want = 'cpyR'
class resulting_target_object(aetools.NProperty):
"""resulting target object - a reference to the target object after it has been saved """
which = 'rcpO'
want = 'obj '
class copy_type(aetools.NProperty):
"""copy type - the way in which the target object was saved """
which = 'rcpT'
want = 'rcpT'
application._propdict = {
'version' : version,
'name' : name,
'comment' : comment,
'driver_version' : driver_version,
'nonejectable_mode' : nonejectable_mode,
'save_log_file' : save_log_file,
'use_speech' : use_speech,
'smart_Save_As' : smart_Save_As,
'checksum_verification' : checksum_verification,
'signature_verification' : signature_verification,
'exclude_DiskScripts' : exclude_DiskScripts,
'exclude_remote_images' : exclude_remote_images,
'image_signing' : image_signing,
'leave_image_mounted' : leave_image_mounted,
'erase_confirmation' : erase_confirmation,
'zeroing' : zeroing,
'default_create_size' : default_create_size,
'default_create_name' : default_create_name,
'make_multiple_floppies' : make_multiple_floppies,
'auto_image_upon_insert' : auto_image_upon_insert,
'eject_after_auto_image' : eject_after_auto_image,
'auto_copy_upon_floppy_insert' : auto_copy_upon_floppy_insert,
'volume_suffix' : volume_suffix,
'image_suffix' : image_suffix,
'default_file_system' : default_file_system,
'default_image_format' : default_image_format,
}
application._elemdict = {
}
disk._propdict = {
'name' : name,
'comment' : comment,
'locked' : locked,
'creation_date' : creation_date,
'modification_date' : modification_date,
'crc32_checksum' : crc32_checksum,
'disk_copy_4_2e_2_checksum' : disk_copy_4_2e_2_checksum,
'block_count' : block_count,
'file_system' : file_system,
}
disk._elemdict = {
}
folder._propdict = {
'name' : name,
'comment' : comment,
'creation_date' : creation_date,
'modification_date' : modification_date,
}
folder._elemdict = {
}
disk_image._propdict = {
'name' : name,
'comment' : comment,
'locked' : locked,
'creation_date' : creation_date,
'modification_date' : modification_date,
'file_format' : file_format,
'signed' : signed,
'compressed' : compressed,
'segmented' : segmented,
'segments' : segments,
'disk_name' : disk_name,
'crc32_checksum' : crc32_checksum,
'disk_copy_4_2e_2_checksum' : disk_copy_4_2e_2_checksum,
'block_count' : block_count,
'file_system' : file_system,
'data_fork_size' : data_fork_size,
'resource_fork_size' : resource_fork_size,
}
disk_image._elemdict = {
}
Save_reply_record._propdict = {
'resulting_target_object' : resulting_target_object,
'copy_type' : copy_type,
}
Save_reply_record._elemdict = {
}
_Enum_UIAc = {
'never_interact' : 'eNvr', # Dont allow any interaction at all
'interact_with_self' : 'eInS', # Only allow interaction from internal events
'interact_with_local' : 'eInL', # Allow interaction from any event originating on this machine
'interact_with_all' : 'eInA', # Allow interaction from network events
}
_Enum_SvAs = {
'NDIF_RW' : 'RdWr', # read/write NDIF disk image
'NDIF_RO' : 'Rdxx', # read-only NDIF disk image
'NDIF_Compressed' : 'ROCo', # compressed NDIF disk image
'Disk_Copy_4_2e_2' : 'DC42', # Disk Copy 4.2 disk image
}
_Enum_rcpT = {
'block_disk_copy' : 'cpBl', # block-by-block disk-level copy
'files_and_file_ID_copy' : 'cpID', # all files including desktop databases and file IDs
'files_and_desktop_info' : 'cpDT', # all files and most desktop information
'files_only' : 'cpFI', # all files but no desktop information
'disk_image_conversion' : 'cpCV', # disk image format conversion
'disk_image_creation' : 'cpCR', # disk image creation
}
_Enum_long = None # XXXX enum long not found!!
_Enum_bool = None # XXXX enum bool not found!!
_Enum_obj_ = None # XXXX enum obj not found!!
#
# Indices of types declared in this module
#
_classdeclarations = {
'DImg' : disk_image,
'capp' : application,
'Disk' : disk,
'Fold' : folder,
'cpyR' : Save_reply_record,
}
_propdeclarations = {
'Xcrc' : crc32_checksum,
'PDeS' : default_create_size,
'Idnm' : disk_name,
'PSSP' : smart_Save_As,
'Pcpf' : auto_copy_upon_floppy_insert,
'pnam' : name,
'Isin' : signed,
'otto' : nonejectable_mode,
'PExD' : exclude_DiskScripts,
'Iseg' : segmented,
'islk' : locked,
'asmo' : modification_date,
'PTlk' : use_speech,
'Pfsy' : default_file_system,
'PVeC' : checksum_verification,
'Xc42' : disk_copy_4_2e_2_checksum,
'rcpO' : resulting_target_object,
'Paim' : auto_image_upon_insert,
'comt' : comment,
'PCoE' : erase_confirmation,
'dVer' : driver_version,
'PDeN' : default_create_name,
'PBuM' : make_multiple_floppies,
'rcpT' : copy_type,
'PDiE' : volume_suffix,
'Ifmt' : file_format,
'Pdfm' : default_image_format,
'ascd' : creation_date,
'Pejc' : eject_after_auto_image,
'PZeB' : zeroing,
'PExR' : exclude_remote_images,
'PImE' : image_suffix,
'PVeS' : signature_verification,
'PSaL' : save_log_file,
'Xblk' : block_count,
'PMoA' : leave_image_mounted,
'Isg#' : segments,
'Irfk' : resource_fork_size,
'Icom' : compressed,
'Xfsi' : file_system,
'Idfk' : data_fork_size,
'vers' : version,
'PSiI' : image_signing,
}
_compdeclarations = {
}
_enumdeclarations = {
'SvAs' : _Enum_SvAs,
'UIAc' : _Enum_UIAc,
'rcpT' : _Enum_rcpT,
}
Mac/Demo/scripting/Standard_Suite.py → Mac/Demo/applescript/Disk_Copy/Utility_Events.py
View file @ c15ab036
"""Suite Standard Suite: Common terms for most applications
"""Suite Utility Events: Commands that allow the user to select Disk Copy files
Level 1, version 1
Generated from flap:Programma's:Eudora Light
AETE/AEUT resource version 2/16, language 0, script 0
Generated from Macintosh HD:Hulpprogramma's:Disk Copy
AETE/AEUT resource version 1/0, language 0, script 0
"""
import aetools
import MacOS
_code = 'CoRe'
_code = 'ddsk'
class Standard_Suite:
class Utility_Events_Events:
def close(self, _object, _attributes={}, **_arguments):
"""close: Close an object
Required argument: the object to close
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'clos'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_count = {
'each' : 'kocl',
_argmap_select_disk_image = {
'with_prompt' : 'SELp',
}
def count(self, _object, _attributes={}, **_arguments):
"""count: Return the number of elements of a particular class within an object
Required argument: the object whose elements are to be counted
Keyword argument each: the class of the elements to be counted. Keyword 'each' is optional in AppleScript
def select_disk_image(self, _no_object=None, _attributes={}, **_arguments):
"""select disk image: Prompt the user to select a disk image
Keyword argument with_prompt: the prompt string to be displayed
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: the number of elements
Returns: a reference to a disk image
"""
_code = 'core'
_subcode = 'cnte'
_code = 'UTIL'
_subcode = 'SEL1'
aetools.keysubst(_arguments, self._argmap_count)
_arguments['----'] = _object
aetools.keysubst(_arguments, self._argmap_select_disk_image)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'SELp', _Enum_TEXT)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -58,39 +38,23 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
def exists(self, _object, _attributes={}, **_arguments):
"""exists: Verify if an object exists
Required argument: the object in question
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: true if it exists, false if not
"""
_code = 'core'
_subcode = 'doex'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_select_DiskScript = {
'with_prompt' : 'SELp',
}
def get(self, _object, _attributes={}, **_arguments):
"""get: Get the data for an object
Required argument: the object whose data is to be returned
def select_DiskScript(self, _no_object=None, _attributes={}, **_arguments):
"""select DiskScript: Prompt the user to select a DiskScript
Keyword argument with_prompt: the prompt string to be displayed
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: the data from the object
Returns: a reference to a DiskScript
"""
_code = 'core'
_subcode = 'getd'
_code = 'UTIL'
_subcode = 'SEL2'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
aetools.keysubst(_arguments, self._argmap_select_DiskScript)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'SELp', _Enum_TEXT)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -100,24 +64,23 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
_argmap_make = {
'new' : 'kocl',
'at' : 'insh',
_argmap_select_disk_image_or_DiskScript = {
'with_prompt' : 'SELp',
}
def make(self, _no_object=None, _attributes={}, **_arguments):
"""make: Make a new element
Keyword argument new: the class of the new element. Keyword 'new' is optional in AppleScript
Keyword argument at: the location at which to insert the element
def select_disk_image_or_DiskScript(self, _no_object=None, _attributes={}, **_arguments):
"""select disk image or DiskScript: Prompt the user to select a disk image or DiskScript
Keyword argument with_prompt: the prompt string to be displayed
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the new object
Returns: a reference to disk image or a DiskScript
"""
_code = 'core'
_subcode = 'crel'
_code = 'UTIL'
_subcode = 'SEL3'
aetools.keysubst(_arguments, self._argmap_make)
aetools.keysubst(_arguments, self._argmap_select_disk_image_or_DiskScript)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'SELp', _Enum_TEXT)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -127,23 +90,23 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
_argmap_move = {
'to' : 'insh',
_argmap_select_floppy_disk_image = {
'with_prompt' : 'SELp',
}
def move(self, _object, _attributes={}, **_arguments):
"""move: Move object to a new location
Required argument: the object to move
Keyword argument to: the new location for the object
def select_floppy_disk_image(self, _no_object=None, _attributes={}, **_arguments):
"""select floppy disk image: Prompt the user to select a floppy disk image
Keyword argument with_prompt: the prompt string to be displayed
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the object after they have been moved
Returns: a reference to a floppy disk image
"""
_code = 'core'
_subcode = 'move'
_code = 'UTIL'
_subcode = 'SEL4'
aetools.keysubst(_arguments, self._argmap_move)
_arguments['----'] = _object
aetools.keysubst(_arguments, self._argmap_select_floppy_disk_image)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'SELp', _Enum_TEXT)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -153,23 +116,23 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
_argmap_duplicate = {
'to' : 'insh',
_argmap_select_disk = {
'with_prompt' : 'SELp',
}
def duplicate(self, _object, _attributes={}, **_arguments):
"""duplicate: Make a duplicate object
Required argument: the object to move
Keyword argument to: the new location for the object
def select_disk(self, _no_object=None, _attributes={}, **_arguments):
"""select disk: Prompt the user to select a disk volume
Keyword argument with_prompt: the prompt string to be displayed
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the object after they have been moved
Returns: a reference to the disk
"""
_code = 'core'
_subcode = 'clon'
_code = 'UTIL'
_subcode = 'SEL5'
aetools.keysubst(_arguments, self._argmap_duplicate)
_arguments['----'] = _object
aetools.keysubst(_arguments, self._argmap_select_disk)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'SELp', _Enum_TEXT)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -179,37 +142,23 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
def open(self, _object, _attributes={}, **_arguments):
"""open: Open the specified object
Required argument: list of objects to open
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'aevt'
_subcode = 'odoc'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_select_folder = {
'with_prompt' : 'SELp',
}
def _print(self, _object, _attributes={}, **_arguments):
"""print: Print the specified message
Required argument: the message to print
def select_folder(self, _no_object=None, _attributes={}, **_arguments):
"""select folder: Prompt the user to select a folder
Keyword argument with_prompt: the prompt string to be displayed
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: a reference to the folder
"""
_code = 'aevt'
_subcode = 'pdoc'
_code = 'UTIL'
_subcode = 'SEL6'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
aetools.keysubst(_arguments, self._argmap_select_folder)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'SELp', _Enum_TEXT)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -219,17 +168,23 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
def save(self, _object, _attributes={}, **_arguments):
"""save: Save an object
Required argument: the composition message to save
_argmap_log = {
'time_stamp' : 'TSMP',
}
def log(self, _object, _attributes={}, **_arguments):
"""log: Add a string to the log window
Required argument: the string to add to the log window
Keyword argument time_stamp: Should the log entry be time-stamped? (false if not supplied)
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'save'
_code = 'UTIL'
_subcode = 'LOG '
if _arguments: raise TypeError, 'No optional args expected'
aetools.keysubst(_arguments, self._argmap_log)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'TSMP', _Enum_bool)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
......@@ -239,34 +194,20 @@ class Standard_Suite:
if _arguments.has_key('----'):
return _arguments['----']
_argmap_set = {
'to' : 'data',
}
def set(self, _object, _attributes={}, **_arguments):
"""set: Set an object's data
Required argument: the object to change
Keyword argument to: the new value
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'setd'
aetools.keysubst(_arguments, self._argmap_set)
_arguments['----'] = _object
_Enum_TEXT = None # XXXX enum TEXT not found!!
_Enum_bool = None # XXXX enum bool not found!!
#
# Indices of types declared in this module
#
_classdeclarations = {
}
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_propdeclarations = {
}
_compdeclarations = {
}
# Class 'application' ('capp') -- 'An application program'
# property 'version' ('vers') 'itxt' -- 'the version number' []
# property 'selected text' ('eStx') 'TEXT' -- 'the text of the user\325s current selection' []
# element 'euMF' as ['indx', 'name']
# element 'ePrf' as ['indx']
_enumdeclarations = {
}
Mac/Demo/applescript/Disk_Copy/__init__.py 0 → 100644
View file @ c15ab036
"""
Package generated from Macintosh HD:Hulpprogramma's:Disk Copy
Resource aete resid 0
"""
import aetools
Error = aetools.Error
import Standard_Suite
import Special_Events
import Utility_Events
_code_to_module = {
'Core' : Standard_Suite,
'ddsk' : Special_Events,
'ddsk' : Utility_Events,
}
_code_to_fullname = {
'Core' : ('Disk_Copy.Standard_Suite', 'Standard_Suite'),
'ddsk' : ('Disk_Copy.Special_Events', 'Special_Events'),
'ddsk' : ('Disk_Copy.Utility_Events', 'Utility_Events'),
}
from Standard_Suite import *
from Special_Events import *
from Utility_Events import *
class Disk_Copy(Standard_Suite_Events,
Special_Events_Events,
Utility_Events_Events,
aetools.TalkTo):
_signature = 'ddsk'
Mac/Demo/applescript/makedisk.py 0 → 100644
View file @ c15ab036
import Disk_Copy
import macfs
import sys
talker = Disk_Copy.Disk_Copy(start=1)
talker.activate()
filespec = macfs.FSSpec('my disk image.img')
try:
objref = talker.create('my disk image', saving_as=filespec, leave_image_mounted=1)
except Disk_Copy.Error, arg:
print "ERROR: my disk image:", arg
else:
print 'objref=', objref
print 'Type return to exit-'
sys.stdin.readline()
Mac/Demo/scripting/Eudora_Suite.py deleted 100644 → 0
View file @ e743c6e2
"""Suite Eudora Suite: Terms specific to Eudora
Level 1, version 1
Generated from flap:Programma's:Eudora Light
AETE/AEUT resource version 2/16, language 0, script 0
"""
import aetools
import MacOS
_code = 'CSOm'
class Eudora_Suite:
_argmap_connect = {
'sending' : 'eSen',
'checking' : 'eChk',
'waiting' : 'eIdl',
}
def connect(self, _no_object=None, _attributes={}, **_arguments):
"""connect: Connect to the mail server and transfer mail
Keyword argument sending: true to make eudora send queued messages
Keyword argument checking: true to make eudora check for mail
Keyword argument waiting: true to make eudora wait for idle time before checking
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'eCon'
aetools.keysubst(_arguments, self._argmap_connect)
if _no_object != None: raise TypeError, 'No direct arg expected'
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_reply = {
'quoting' : 'eQTx',
'everyone' : 'eRAl',
'self' : 'eSlf',
}
def reply(self, _object, _attributes={}, **_arguments):
"""reply: Reply to a message
Required argument: the message to reply to
Keyword argument quoting: true if you want to quote the original text in the reply
Keyword argument everyone: true if you want the reply to go to everyone who got the original
Keyword argument self: true if you want the reply to go to yourself, too
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the reply message
"""
_code = 'CSOm'
_subcode = 'eRep'
aetools.keysubst(_arguments, self._argmap_reply)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def forward(self, _object, _attributes={}, **_arguments):
"""forward: Forward a message
Required argument: the message to forward
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the forwarded message
"""
_code = 'CSOm'
_subcode = 'eFwd'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def redirect(self, _object, _attributes={}, **_arguments):
"""redirect: Redirect a message
Required argument: the message to redirect
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the redirected message
"""
_code = 'CSOm'
_subcode = 'eRdr'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def send_again(self, _object, _attributes={}, **_arguments):
"""send again: Send a message again
Required argument: the message to send again
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: to the message sent again
"""
_code = 'CSOm'
_subcode = 'eSav'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_queue = {
'_for' : 'eWhn',
}
def queue(self, _object, _attributes={}, **_arguments):
"""queue: Queue a message to be sent
Required argument: the message to queue
Keyword argument _for: date to send the message, in seconds since 1904, UTC
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'eQue'
aetools.keysubst(_arguments, self._argmap_queue)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def unqueue(self, _object, _attributes={}, **_arguments):
"""unqueue: Remove a message from the queue, so it won¹t be sent
Required argument: the message to unqueue
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'eUnQ'
if _arguments: raise TypeError, 'No optional args expected'
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_attach_to = {
'documents' : 'eDcl',
}
def attach_to(self, _object, _attributes={}, **_arguments):
"""attach to: Attach documents to a message
Required argument: the message to attach the documents to
Keyword argument documents: list of documents to attach
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'eAtc'
aetools.keysubst(_arguments, self._argmap_attach_to)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_start_notifying = {
'when' : 'eWHp',
}
def start_notifying(self, _object, _attributes={}, **_arguments):
"""start notifying: Notify an application of things that happen
Required argument: an application to notify
Keyword argument when: what to notify the application of
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'nIns'
aetools.keysubst(_arguments, self._argmap_start_notifying)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_stop_notifying = {
'when' : 'eWHp',
}
def stop_notifying(self, _object, _attributes={}, **_arguments):
"""stop notifying: Stop notifying applications of things that are happening
Required argument: an application currently being notified
Keyword argument when: the things no longer to notify it of
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'nRem'
aetools.keysubst(_arguments, self._argmap_stop_notifying)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_notice = {
'occurrence' : 'eWHp',
'messages' : 'eMLs',
}
def notice(self, _no_object=None, _attributes={}, **_arguments):
"""notice: Eudora sends this event to notify an application that something happened
Keyword argument occurrence: what happened
Keyword argument messages: of the messages involved
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'CSOm'
_subcode = 'eNot'
aetools.keysubst(_arguments, self._argmap_notice)
if _no_object != None: raise TypeError, 'No direct arg expected'
aetools.enumsubst(_arguments, 'eWHp', _Enum_eNot)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.has_key('errn'):
raise aetools.Error, aetools.decodeerror(_arguments)
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
class mail_folder(aetools.ComponentItem):
"""mail folder - A folder containing mailboxes or other mail folders."""
want = 'euMF'
class name(aetools.NProperty):
"""name - the name"""
which = 'pnam'
want = 'itxt'
# element 'euMB' as ['indx', 'name']
# element 'euMF' as ['indx', 'name']
class mailbox(aetools.ComponentItem):
"""mailbox - A mailbox."""
want = 'euMB'
# repeated property name the name of the mail folder
class space_wasted(aetools.NProperty):
"""space wasted - the amount of waste space in the mailbox"""
which = 'euWS'
want = 'long'
class space_required(aetools.NProperty):
"""space required - the minimum amount of space required to hold the mailbox"""
which = 'euNS'
want = 'long'
class location(aetools.NProperty):
"""location - the file the mailbox is stored in"""
which = 'euFS'
want = 'fss '
class toc_location(aetools.NProperty):
"""toc location - the file the table of contents is stored in"""
which = 'eTFS'
want = 'fss '
# element 'euMS' as ['indx']
class message(aetools.ComponentItem):
"""message - A message"""
want = 'euMS'
class body(aetools.NProperty):
"""body - the body of the message"""
which = 'eBod'
want = 'TEXT'
class priority(aetools.NProperty):
"""priority - the priority"""
which = 'euPY'
want = 'long'
class label(aetools.NProperty):
"""label - the index of the label"""
which = 'eLbl'
want = 'long'
class status(aetools.NProperty):
"""status - the message status"""
which = 'euST'
want = 'eSta'
class sender(aetools.NProperty):
"""sender - the sender as appearing in the message summary"""
which = 'euSe'
want = 'itxt'
class date(aetools.NProperty):
"""date - the date as appearing in the message summary"""
which = 'euDa'
want = 'itxt'
class subject(aetools.NProperty):
"""subject - the subject as appearing in the message summary"""
which = 'euSu'
want = 'itxt'
class size(aetools.NProperty):
"""size - the size of the message"""
which = 'euSi'
want = 'long'
class outgoing(aetools.NProperty):
"""outgoing - is the message is outgoing?"""
which = 'euOu'
want = 'bool'
class signature(aetools.NProperty):
"""signature - which signature the message should have"""
which = 'eSig'
want = 'eSig'
class QP(aetools.NProperty):
"""QP - is Eudora allowed to encode text?"""
which = 'eMQP'
want = 'bool'
class return_receipt(aetools.NProperty):
"""return receipt - is a return receipt is requested?"""
which = 'eRRR'
want = 'bool'
class wrap(aetools.NProperty):
"""wrap - should the text be wrapped when sent?"""
which = 'eWrp'
want = 'bool'
class tab_expansion(aetools.NProperty):
"""tab expansion - should tabs get expanded to spaces?"""
which = 'eTab'
want = 'bool'
class keep_copy(aetools.NProperty):
"""keep copy - should a copy should be kept after message is sent?"""
which = 'eCpy'
want = 'bool'
class preserve_macintosh_info(aetools.NProperty):
"""preserve macintosh info - should Macintosh information always be sent with attachments?"""
which = 'eXTX'
want = 'bool'
class attachment_encoding(aetools.NProperty):
"""attachment encoding - the type of encoding to use for attachments"""
which = 'eATy'
want = 'eAty'
class show_all_headers(aetools.NProperty):
"""show all headers - should all headers be visible?"""
which = 'eBla'
want = 'bool'
class transliteration_table(aetools.NProperty):
"""transliteration table - the resource id of the transliteration table"""
which = 'eTbl'
want = 'long'
class will_be_fetched(aetools.NProperty):
"""will be fetched - will the message be [re]fetched on next check?"""
which = 'eWFh'
want = 'bool'
class will_be_deleted(aetools.NProperty):
"""will be deleted - will the message be deleted from server on next check?"""
which = 'eWDl'
want = 'bool'
# element 'euFd' as ['name']
class field(aetools.ComponentItem):
"""field - An RFC 822 header field in a message (field named "" is the body)"""
want = 'euFd'
class setting(aetools.ComponentItem):
"""setting - Eudora's settings"""
want = 'ePrf'
mail_folder._propdict = {
'name' : name,
}
mail_folder._elemdict = {
'mailbox' : mailbox,
'mail_folder' : mail_folder,
}
mailbox._propdict = {
'name' : name,
'space_wasted' : space_wasted,
'space_required' : space_required,
'location' : location,
'toc_location' : toc_location,
}
mailbox._elemdict = {
'message' : message,
}
message._propdict = {
'body' : body,
'priority' : priority,
'label' : label,
'status' : status,
'sender' : sender,
'date' : date,
'subject' : subject,
'size' : size,
'outgoing' : outgoing,
'signature' : signature,
'QP' : QP,
'return_receipt' : return_receipt,
'wrap' : wrap,
'tab_expansion' : tab_expansion,
'keep_copy' : keep_copy,
'preserve_macintosh_info' : preserve_macintosh_info,
'attachment_encoding' : attachment_encoding,
'show_all_headers' : show_all_headers,
'transliteration_table' : transliteration_table,
'will_be_fetched' : will_be_fetched,
'will_be_deleted' : will_be_deleted,
}
message._elemdict = {
'field' : field,
}
field._propdict = {
}
field._elemdict = {
}
setting._propdict = {
}
setting._elemdict = {
}
_Enum_eSta = {
'unread' : 'euS\001', # has not been read
'already_read' : 'euS\002', # has been read
'replied' : 'euS\003', # has been replied to
'forwarded' : 'euS\010', # has been forwarded
'redirected' : 'euS\004', # has been redirected
'not_sendable' : 'euS\005', # cannot be sent
'sendable' : 'euS\006', # can be sent
'queued' : 'euS\007', # queued for delivery
'sent' : 'euS\011', # has been sent
'never_sent' : 'euS\012', # never was sent
}
_Enum_eSig = {
'none' : 'sig\000', # no signature
'standard' : 'sig\001', # standard signature file
'alternate' : 'sig\002', # alternate signature file
}
_Enum_eAty = {
'AppleDouble' : 'atc\000', # AppleDouble format
'AppleSingle' : 'atc\001', # AppleSingle format
'BinHex' : 'atc\002', # BinHex format
'uuencode' : 'atc\003', # uuencode format
}
_Enum_eNot = {
'mail_arrives' : 'wArv', # mail arrival
'mail_sent' : 'wSnt', # mail has been sent
'will_connect' : 'wWCn', # eudora is about to connect to a mail server
'has_connected' : 'wHCn', # eudora has finished talking to a mail server
'has_manually_filtered' : 'mFil', # eudora has finished manually filtering messages
'opens_filters' : 'wFil', # user has requested Eudora open the filter window
}
#
# Indices of types declared in this module
#
_classdeclarations = {
'euMB' : mailbox,
'euMS' : message,
'euMF' : mail_folder,
'ePrf' : setting,
'euFd' : field,
}
_propdeclarations = {
'eWFh' : will_be_fetched,
'euDa' : date,
'euSi' : size,
'eRRR' : return_receipt,
'pnam' : name,
'euSe' : sender,
'eWrp' : wrap,
'eSig' : signature,
'euOu' : outgoing,
'eMQP' : QP,
'eTFS' : toc_location,
'eWDl' : will_be_deleted,
'eLbl' : label,
'eATy' : attachment_encoding,
'euSu' : subject,
'eBla' : show_all_headers,
'eCpy' : keep_copy,
'euWS' : space_wasted,
'eBod' : body,
'euNS' : space_required,
'eTab' : tab_expansion,
'eTbl' : transliteration_table,
'eXTX' : preserve_macintosh_info,
'euFS' : location,
'euST' : status,
'euPY' : priority,
}
_compdeclarations = {
}
_enumdeclarations = {
'eAty' : _Enum_eAty,
'eNot' : _Enum_eNot,
'eSta' : _Enum_eSta,
'eSig' : _Enum_eSig,
}
Mac/Demo/scripting/testeudora.py deleted 100644 → 0
View file @ e743c6e2
"""A test program that allows us to control Eudora"""
import sys
import aetools
import Eudora_Suite
import Required_Suite
import Standard_Suite
import MacOS
class Eudora(Eudora_Suite.Eudora_Suite, Required_Suite.Required_Suite, \
Standard_Suite.Standard_Suite, aetools.TalkTo):
"""A class that can talk to Eudora"""
pass
# The Creator signature of eudora:
SIGNATURE="CSOm"
def main():
talker = Eudora(SIGNATURE, start=1)
while 1:
print 'get, put, name (of first folder), list (foldernames), quit (eudora) or exit (this program) ?'
line = sys.stdin.readline()
try:
if line[0] == 'g':
talker.connect(checking=1)
elif line[0] == 'p':
talker.connect(sending=1)
elif line[0] == 'n':
id = Eudora_Suite.mailbox(1).name
name = talker._get(id, as='text')
print "It is called", name
elif line[0] == 'l':
pass
elif line[0] == 'q':
talker.quit()
elif line[0] == 'e':
break
except MacOS.Error, arg:
if arg[0] == -609:
print 'Connection invalid, is eudora running?'
else:
print 'MacOS Error:', arg[1]
except aetools.Error, arg:
print 'Eudora returned error:', arg
main()
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7