29 |
30 | /* Header file for ae module */
31 |
32 | #ifdef AE_MODULE_C
33 | /* This section is used when compiling ae.c */
34 |
35 | static PyObject * AE_AEDesc_New (AEDesc *);
36 | static PyObject * AE_AEDesc_NewBorrowed (AEDesc *);
37 | static int AE_AEDesc_Convert (PyObject *, AEDesc *);
38 | static int AE_AEDesc_ConvertDisown (PyObject *, AEDesc *);
39 | static PyObject * AE_GetMacOSErrorException (void);
40 | static PyObject * AE_MacOSError (int);
41 | static int AE_GetOSType (PyObject *, OSType *);
42 | static PyObject * AE_BuildOSType (OSType);
43 |
44 | #else /* AE_MODULE_C */
45 | /* This section is used in modules that use the ae module's API */
46 |
47 | static void **AE_API;
48 |
49 | #define AE_AEDesc_New (*(PyObject * (*) (AEDesc *) )AE_API[0])
50 | #define AE_AEDesc_NewBorrowed (*(PyObject * (*) (AEDesc *) )AE_API[1])
51 | #define AE_AEDesc_Convert (*(int (*) (PyObject *, AEDesc *))AE_API[2])
52 | #define AE_AEDesc_ConvertDisown (*(int (*) (PyObject *, AEDesc *))AE_API[3])
53 | #define AE_GetMacOSErrorException (*(PyObject * (*) (void) )AE_API[4])
54 | #define AE_MacOSError (*(PyObject * (*) (int) )AE_API[5])
55 | #define AE_GetOSType (*(int (*) (PyObject *, OSType *))AE_API[6])
56 | #define AE_BuildOSType (*(PyObject * (*) (OSType) )AE_API[7])
57 |
58 | /* Return -1 on error, 0 on success.
59 | * PyCapsule_Import will set an exception if there's an error.
60 | */
61 | static int
62 | import_ae(void)
63 | {
64 | AE_API = (void **)PyCapsule_Import("aem.ae._C_API", 0);
65 | return (AE_API != NULL) ? 0 : -1;
66 | }
67 |
68 | #endif /* AE_MODULE_C */
69 |
70 | #ifdef __cplusplus
71 | }
72 | #endif
73 |
74 | #endif /* AE_MODULE_H */
75 |
--------------------------------------------------------------------------------
/py-appscript/lib/appscript/genericreference.py:
--------------------------------------------------------------------------------
1 | """genericreference -- allows user to construct relative (con- and its- based) references without immediate access to application terminology. """
2 |
3 | import aem
4 |
5 | ######################################################################
6 | # PUBLIC
7 | ######################################################################
8 |
9 | class GenericReference(object):
10 | def __init__(self, call):
11 | self._call = call # list of recorded call information (inital value is ['app'], ['con'] or ['its'])
12 |
13 | def __getattr__(self, i):
14 | return GenericReference(self._call + [('__getattr__', i, '.{}')])
15 |
16 | def __getitem__(self, i):
17 | return GenericReference(self._call + [('__getitem__', i, '[{!r}]')])
18 |
19 | def __call__(self, *args, **kargs):
20 | return GenericReference(self._call + [('__call__', (args, kargs), None)])
21 |
22 | def __gt__(self, i):
23 | return GenericReference(self._call + [('AS__gt__', i, ' > {!r}')])
24 |
25 | def __ge__(self, i):
26 | return GenericReference(self._call + [('AS__ge__', i, ' >= {!r}')])
27 |
28 | def __eq__(self, i):
29 | return GenericReference(self._call + [('AS__eq__', i, ' == {!r}')])
30 |
31 | def __ne__(self, i):
32 | return GenericReference(self._call + [('AS__ne__', i, ' != {!r}')])
33 |
34 | def __lt__(self, i):
35 | return GenericReference(self._call + [('AS__lt__', i, ' < {!r}')])
36 |
37 | def __le__(self, i):
38 | return GenericReference(self._call + [('AS__le__', i, ' <= {!r}')])
39 |
40 | def __hash__(self):
41 | return hash(self._call)
42 |
43 | def __repr__(self):
44 | s = self._call[0]
45 | for method, args, repstr in self._call[1:]:
46 | if method == '__call__':
47 | s += '({})'.format(', '.join(['{!r}'.format(i) for i in args[0]] + ['{}={!r}'.format(i) for i in args[1].items()]))
48 | elif method == '__getitem__' and isinstance(args, slice):
49 | s+= '[{!r}:{!r}]'.format(args.start, args.stop)
50 | elif method == '__getattr__' and args in ['AND', 'OR', 'NOT']:
51 | s = '({}).{}'.format(s, args)
52 | else:
53 | s += repstr.format(args)
54 | return s
55 |
56 | def AS_resolve(self, Reference, appdata):
57 | # (Note: reference.Reference class is passed as argument simply to avoid circular import between that module and this)
58 | ref = Reference(appdata, {'app':aem.app, 'con':aem.con, 'its':aem.its}[self._call[0]])
59 | for method, args, repstr in self._call[1:]:
60 | if method == '__getattr__':
61 | ref = getattr(ref, args)
62 | elif method == '__call__':
63 | ref = ref(*args[0], **args[1])
64 | else:
65 | ref = getattr(ref, method)(args)
66 | return ref
67 |
68 | ##
69 |
70 | con = GenericReference(['con'])
71 | its = GenericReference(['its'])
72 | # 'app' is defined in reference module
73 |
74 |
--------------------------------------------------------------------------------
/py-appscript/doc/mactypes-manual/04_unitsclass.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | py-mactypes manual | 4. Units class
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 | 
14 |
15 |
16 |
27 |
28 |
29 |
30 |
31 |
4. The Units class
32 |
33 |
The Units class represents a measurement of some sort, e.g. 3 inches, 98.5 degrees Fahrenheit.
34 |
35 |
class Units
36 |
37 | Constructor:
38 |
39 | Units(value, type)
40 | value : int | float -- the amount, e.g. 3.5
41 | type : str -- the unit of measurement, e.g. 'centimeters'
42 |
43 | Properties:
44 |
45 | value : int | float -- returns the amount
46 |
47 | type : str -- returns the unit of measurement
48 |
49 |
The following unit types are defined as standard:
50 |
51 |
'centimeters' 'cubic_inches'
52 | 'meters' 'cubic_feet'
53 | 'kilometers' 'cubic_yards'
54 | 'inches'
55 | 'feet' 'liters'
56 | 'yards' 'quarts'
57 | 'miles' 'gallons'
58 |
59 | 'square_meters' 'grams'
60 | 'square_kilometers' 'kilograms'
61 | 'square_feet' 'ounces'
62 | 'square_yards' 'pounds'
63 | 'square_miles'
64 | 'degrees_Celsius'
65 | 'cubic_centimeters' 'degrees_Fahrenheit'
66 | 'cubic_meters' 'degrees_Kelvin'
67 |
68 |
Additional application-specific unit types can be added if needed.
69 |
70 |
71 |
Examples
72 |
73 |
mactypes.Units(14, 'inches')
74 |
75 | mactypes.Units(3.5, 'square_meters')
76 |
77 |
78 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
1. Introduction
33 |
34 |
The osax module is deprecated and its use is not recommended.
35 |
36 |
The osax module provides an easy way to call macOS's Standard Additions scripting addition from Python. It exports a single public class, OSAX. For convenience, it also re-exports appscript's ApplicationNotFoundError and CommandError classes and k variable.
37 |
38 |
An OSAX instance represents a running process into which the Standard Additions scripting addition has been automatically loaded. It is similar to an appscript application object, except that it defines commands for Standard Additions instead of the application's normal commands.
39 |
40 |
Once you've created a OSAX instance, you can invoke its commands in exactly the same way as you would call a scriptable application's commands in appscript.
41 |
42 |
For example:
43 |
44 |
import osax
45 |
46 | sa = osax.OSAX()
47 |
48 | sa.say("Hello world", using="Victoria")
49 |
50 |
The default application commands (run, activate, quit, etc.) are also available; see the appscript manual for details on those.
51 |
52 |
By default, OSAX objects are targeted at the current application. You can specify another application by supplying one of the following optional keyword arguments: name, id, or url. These arguments are the same as for appscript.
53 |
54 |
55 |
14 |
15 |
16 |
27 |
28 |
29 |
30 |
31 |
8. Examples
32 |
33 |
Identifying Applications
34 |
35 |
# application "Macintosh HD:System:Applications:TextEdit.app"
36 | textedit = aem.Application('/System/Applications/TextEdit.app')
37 |
38 | # application "TextEdit"
39 | textedit = aem.Application(aem.findapp.byname('TextEdit'))
40 |
41 | # application "TextEdit" of machine "eppc://my-mac.local"
42 | textedit = aem.Application('eppc://my-mac.local/TextEdit')
43 |
44 |
45 |
Building References
46 |
47 |
# name (of application)
48 | aem.app.property(b'pnam')
49 |
50 | # text of every document
51 | aem.app.elements(b'docu').property(b'ctxt')
52 |
53 | # end of every paragraph of text of document 1
54 | aem.app.elements(b'docu').byindex(1).property(b'ctxt').elements(b'cpar').end
55 |
56 | # paragraphs 2 thru last of first document
57 | aem.app.elements(b'docu').first.elements(b'cpar').byrange(
58 | aem.con.elements(b'cpar').byindex(2),
59 | aem.con.elements(b'cpar').last)
60 |
61 | # paragraphs of document 1 where it != "\n"
62 | aem.app.elements(b'docu').byindex(1).elements(b'cpar').byfilter(aem.its.ne('\n'))
63 |
64 |
65 |
Sending Events
66 |
67 |
# quit TextEdit
68 | textedit.event(b'corequit').send()
69 |
70 | # name of TextEdit
71 | print textedit.event(b'coregetd', {b'----': aem.app.property(b'pnam')}).send()
72 |
73 | # count documents of TextEdit
74 | print textedit.event(b'corecnte', {b'----': aem.app.elements(b'docu')}).send()
75 |
76 | # make new document at end of documents of TextEdit
77 | textedit.event(b'corecrel', {
78 | b'kocl': aem.AEType(b'docu'),
79 | b'insh': aem.app.elements(b'docu').end
80 | }).send()
81 |
82 |
83 |
84 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
3. Packing and unpacking data
33 |
34 |
Codecs
35 |
36 |
The aem.Codecs class provides methods for converting Python data to aem.ae.AEDesc objects, and vice-versa.
37 |
38 |
39 |
Codecs
40 |
41 | Constructor:
42 | __init__(self)
43 |
44 | Methods:
45 | pack(self, data) -- convert Python data to an AEDesc; will
46 | raise a TypeError if data's type/class is unsupported
47 | data : anything
48 | Result : AEDesc
49 |
50 | unpack(self, desc) -- convert an AEDesc to Python data;
51 | will return AEDesc if it's an unsupported type
52 | desc : AEDesc
53 | Result : anything
54 |
55 |
56 |
57 |
AE types
58 |
59 |
The Apple Event Manager defines several types for representing type/class names, enumerator names, etc. that have no direct equivalent in Python. Accordingly, AEM defines several classes to represent these types on the Python side. All share a common abstract base class, AETypeBase:
60 |
61 |
62 |
63 | AETypeBase -- Abstract base class
64 |
65 | Constructor:
66 | __init__(self, code)
67 | code : bytes -- a four-character Apple event code
68 |
69 | Properties:
70 | code : bytes (read-only) -- Apple event code
71 |
72 |
73 |
The four concrete classes are:
74 |
75 |
AEType(AETypeBase) -- represents an AE object of typeType
76 |
77 |
78 | AEEnum(AETypeBase) -- represents an AE object of typeEnumeration
79 |
80 |
81 | AEProp(AETypeBase) -- represents an AE object of typeProperty
82 |
83 |
84 | AEKey(AETypeBase) -- represents an AE object of typeKeyword
85 |
86 |
87 |
88 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
5. Keyword conversion
33 |
34 |
Keyword conversion
35 |
36 |
Because application terminology resources specify AppleScript-style keywords for class, property, command, etc. names, appscript uses the following rules to translate these keywords to legal Python identifiers:
37 |
38 |
70 |
71 |
You can use ASDictionary or appscript's built-in help method to export or view application terminology in appscript format. See the Getting Help chapter for more information.
72 |
73 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
8. Real vs generic references
33 |
34 |
Real vs. generic references
35 |
36 |
References may be either 'real' or 'generic'. A real reference relates to a specific application, while a generic reference doesn't. Generic references provide a convenient shortcut for writing literal references without having to specify an application each time.
37 |
38 |
A real reference begins with an app object that identifies the application whose object(s) it refers to, e.g.:
39 |
40 |
app('TextEdit').documents.end
41 | app(url='eppc://my-mac.local/Finder').home.folders.name
42 |
43 |
A generic reference begins with app, con or its and does not identify the application to which it relates, e.g.:
44 |
45 |
app.documents.end
46 | con.word[3]
47 | its.name.beginswith('d')
48 |
49 |
Generic references are only evaluated when used used within real references as selectors:
50 |
51 |
app('Finder').home.folders[its.name.beginswith('d')].get()
52 |
53 | app('Tex-Edit Plus').windows[1].text[con.words[2]:con.words[-2]].get()
54 |
55 |
or as command parameters:
56 |
57 |
app('TextEdit').make(new=k.word,
58 | at=app.documents[1].words.end, with_data='Hello')
59 |
60 | app('Finder').desktop.duplicate(to=app.home.folders['Desktop Copy'])
61 |
62 |
63 |
Comparing and hashing references
64 |
65 |
Real application references can be compared for equality and are hashable (so can be used as dictionary keys). For two references to be considered equal, both must have the same application path or url and reference structure. Examples:
66 |
67 |
print(app('TextEdit').documents[1] == \
68 | app(id='com.apple.textedit').documents[1].get())
69 | # Result: True; both references evaluate to the same
70 | # application path and reference
71 |
72 | print(app('Finder').home == \
73 | app('Finder').home.get())
74 | # Result: False; app('Finder').home.get() returns a
75 | # different reference to the same application object
76 |
77 |
Generic references cannot be compared or hashed.
78 |
79 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
1. Introduction
33 |
34 |
About appscript
35 |
36 |
Python appscript (py-appscript) is an easy-to-use Apple event bridge that allows 'AppleScriptable' applications to be controlled by ordinary Python scripts. Appscript makes Python an excellent alternative to Apple's own AppleScript language for automating your Mac.
37 |
38 |
For example, to get the value of the first paragraph of the topmost document in TextEdit:
39 |
40 |
app('TextEdit').documents['Read Me'].paragraphs[1].get()
41 |
42 |
This is equivalent to the AppleScript statement:
43 |
44 |
tell application "TextEdit"
45 | get paragraph 1 of document "Read Me"
46 | end tell
47 |
48 |
49 |
Before you start...
50 |
51 |
In order to use appscript effectively, you will need to understand the differences between the Apple event and Python object systems.
52 |
53 |
In contrast to the familiar object-oriented approach of other inter-process communication systems such as COM and Distributed Objects, Apple event IPC is based on a combination of remote procedure calls and first-class queries - somewhat analogous to using XPath over XML-RPC.
54 |
55 |
While appscript uses an object-oriented-like syntax for conciseness and readability, like AppleScript, it behaves according to Apple event rules. As a result, Python users will discover that some things work differently in appscript from what they're used to. For example:
56 |
57 |
58 | - object elements are one-indexed, not zero-indexed like Python lists
59 |
60 | - referencing a property of an application object does not automatically return the property's value (you need a
get command for that)
61 |
62 | - many applications allow a single command to operate on multiple objects at the same time, providing significant performance benefits when manipulating large numbers of application objects.
63 |
64 |
65 |
66 |
Chapters 2 and 3 of this manual provide further information on how Apple event IPC works and a tutorial-based introduction to the Python appscript bridge. Chapter 4 describes various ways of getting help when scripting applications. Chapters 5 through 12 cover the appscript API, and chapter 13 discusses techniques for optimising performance.
67 |
68 |
69 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
2. API overview
33 |
34 |
Classes
35 |
36 |
The main AEM classes are as follows:
37 |
38 |
39 | - Application
40 | - Represents a scriptable application, and provides an
event method for constructing Apple events.
41 |
42 | - Event
43 | - Represents a ready-to-send Apple event, and provides a
send method for sending it. Returned by the Application class's event method.
44 |
45 | - EventError
46 | - Represents an error raised by the target application or the Apple Event Manager.
47 |
48 | - Codecs
49 | - Provides
pack and unpack methods for converting Python values to AE types, and vice-versa. Clients usually don't need to access this class directly.
50 |
51 | - AEType, AEEnum
52 | - Represent Apple event type and enumerator values.
53 |
54 |
55 |
56 |
In addition, there are a number of classes used to represent application references, although the user does not instantiate these directly.
57 |
58 |
59 |
Attributes
60 |
61 |
AEM exports three top-level attributes for use in constructing application references:
62 |
63 |
64 | - app
65 | - Base object used to construct absolute references.
66 |
67 | - con
68 | - Base object used to construct relative reference to container object (used in range specifiers).
69 |
70 | - its
71 | - Base object used to construct relative reference to object being tested (used in filter specifiers).
72 |
73 |
74 |
75 |
References are constructed from these base objects using chained property/method calls.
76 |
77 |
78 |
Modules
79 |
80 |
AEM also exports the following support modules:
81 |
82 |
83 | - findapp
84 | - Provides functions for locating applications by name or bundle id.
85 |
86 | - ae
87 | - Low-level extension that defines an
AEDesc type representing Carbon Apple event descriptors (AEDescs). Also provides a number of support functions used by AEM, appscript and related packages.
88 |
89 | - kae
90 | - Exports constants defined by Apple Event Manager and Open Scripting APIs.
91 |
92 |
93 |
94 |
95 |
96 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
2. The Alias class
33 |
34 |
The Alias class represents a persistent reference to a filesystem object. Aliases keep track of filesystem objects even if they're renamed or moved to another location on the same disk.
35 |
36 |
37 |
Methods
38 |
39 |
Alias -- A persistent reference to a filesystem object. Aliases keep
40 | track of filesystem objects as they're moved around the disk
41 | or renamed. Provides a variety of properties and constructors
42 | for converting to and from other Python types.
43 |
44 | Constructors:
45 |
46 | Alias(path) -- make Alias object from POSIX path
47 |
48 | File.makewithhfspath(path) -- make Alias object from HFS path
49 |
50 | Alias.makewithurl(url) -- make Alias object from file URL
51 |
52 | Alias.makewithdesc(desc) -- make Alias object from an
53 | AEDesc of typeAlias
54 |
55 | Properties:
56 |
57 | path : unicode -- POSIX path
58 |
59 | hfspath : unicode -- HFS path
60 |
61 | url : string -- file URL
62 |
63 | file : mactypes.File
64 |
65 | alias : mactypes.Alias -- itself
66 |
67 | desc : aem.ae.AEDesc
68 |
69 |
70 |
Examples
71 |
72 |
from appscript import *
73 | from mactypes import *
74 |
75 | f = Alias('/Users/foo/some file')
76 |
77 | print f
78 | # mactypes.Alias("/Users/foo/some file")
79 |
80 | print f.path
81 | # /Users/foo/some file
82 |
83 | app('TextEdit').open(f)
84 | # opens document in TextEdit
85 |
86 | Alias('/some/non/existent/location')
87 | # ValueError: Can't make mactypes.Alias as file doesn't exist:
88 | # '/some/non/existent/location'
89 |
90 |
91 |
Notes
92 |
93 |
When creating an Alias instance, POSIX paths may be either relative or absolute and are automatically normalised using os.path.abspath. Paths to non-existent filesystem locations will result in a ValueError being raised.
94 |
95 |
Note that comparing an Alias object against a File object always returns false, even if both point to the same location.
96 |
97 |
Remember that aliases can change when the corresponding filesystem object is moved, so take care when using Alias objects in situations that involve comparing or hashing them (e.g. as dict keys).
98 |
99 |
100 |
101 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
33 |
3. The File class
34 |
35 |
The File class represents a fixed filesystem location which may or may not already exist.
36 |
37 |
Methods
38 |
39 |
File -- A reference to a fixed filesystem location which may or may not
40 | already exist. Provides a variety of properties and constructors
41 | for converting to and from other Python types.
42 |
43 | Constructors:
44 |
45 | File(path) -- make File object from POSIX path
46 |
47 | File.makewithhfspath(path) -- make File object from HFS path
48 |
49 | File.makewithurl(url) -- make File object from file URL
50 |
51 | File.makewithdesc(desc) -- make File object from
52 | aem.ae.AEDesc of typeFileURL
53 |
54 | Properties:
55 |
56 | path : unicode -- POSIX path
57 |
58 | hfspath : unicode -- HFS path
59 |
60 | url : string -- file URL
61 |
62 | file : mactypes.File -- a new File object
63 |
64 | alias : mactypes.Alias
65 |
66 | desc : aem.ae.AEDesc
67 |
68 |
69 |
Examples
70 |
71 |
from appscript import *
72 | from mactypes import *
73 |
74 | f = File('/Users/foo/some file')
75 |
76 | print f
77 | # mactypes.File("/Users/foo/some file")
78 |
79 | print f.path
80 | # /Users/foo/some file
81 |
82 | print f.url
83 | # file://localhost/Users/foo/some%20file
84 |
85 | app('TextEdit').documents[1].save(in_=f)
86 | # saves front TextEdit document at the given location
87 |
88 |
89 |
Notes
90 |
91 |
When creating a File instance, POSIX paths may be either relative or absolute and are automatically normalised using os.path.abspath.
92 |
93 |
When comparing File objects for equality, File.__eq__ will perform a case-sensitive comparison of their file paths. Client that need to perform (for example) case-insensitive comparisons should obtain path strings from each File object, then normalise and compare those values as necessary.
94 |
95 |
The File class normally wraps AEDescs of typeFileURL, which can represent both existing and non-existing locations. For legacy compatibility with older Carbon apps, it can also wrap existing AEDescs of typeFSRef or typeFSS, although these obsolete Carbon types are long since deprecated and should not be used now.
96 |
97 |
')
29 | self._foundproperties = set()
30 | self._foundelements = set()
31 | self._foundclasses = set()
32 | self._foundenumerators = set()
33 | # ideally, aetes should define both singular and plural names for each class, but
34 | # some define only one or the other so we need to fill in any missing ones afterwards
35 | self._spareclassnames = {}
36 | self._foundclasscodes = set()
37 | self._foundelementcodes = set()
38 |
39 | def start_command(self, code, name, description, directarg, reply):
40 | self.commandargs = []
41 | if name not in self.commands or self.commands[name][1] == code:
42 | self.commands[name] = (self.convert(name), code, self.commandargs)
43 |
44 | def add_labelledarg(self, code, name, description, datatype, isoptional, islist, isenum):
45 | self.commandargs.append((self.convert(name), code))
46 |
47 | def start_class(self, code, name, description):
48 | self.classname = self.convert(name)
49 | self.classcode = code
50 | self.isplural = False
51 | self._spareclassnames[code] = self.classname
52 |
53 | def is_plural(self):
54 | self.isplural = True
55 |
56 | def add_property(self, code, name, description, datatype, islist, isenum, ismutable):
57 | if (name, code) not in self._foundproperties:
58 | self.properties.append((self.convert(name), code))
59 | self._foundproperties.add((name, code))
60 |
61 | def end_class(self):
62 | name, code = self.classname, self.classcode
63 | if self.isplural:
64 | if (name, code) not in self._foundelements:
65 | self.elements.append((name, code))
66 | self._foundelements.add((name, code))
67 | self._foundelementcodes.add(code)
68 | else:
69 | if (name, code) not in self._foundclasses:
70 | self.classes.append((name, code))
71 | self._foundclasses.add((name, code))
72 | self._foundclasscodes.add(code)
73 |
74 | def add_enumerator(self, code, name, description):
75 | if (name, code) not in self._foundenumerators:
76 | self.enumerators.append((self.convert(name), code))
77 | self._foundenumerators.add((name, code))
78 |
79 | def result(self):
80 | # singular names are normally used in the classes table and plural names in the elements table. However, if an aete defines a singular name but not a plural name then the missing plural name is substituted with the singular name; and vice-versa if there's no singular equivalent for a plural name.
81 | missingElements = self._foundclasscodes - self._foundelementcodes
82 | missingClasses = self._foundelementcodes - self._foundclasscodes
83 | for code in missingElements:
84 | self.elements.append((self._spareclassnames[code], code))
85 | for code in missingClasses:
86 | self.classes.append((self._spareclassnames[code], code))
87 | return (self.classes, self.enumerators, self.properties, self.elements, list(self.commands.values()))
88 |
89 |
90 | ######################################################################
91 | # PUBLIC
92 | ######################################################################
93 |
94 | def buildtablesforaetes(aetes, style='py-appscript'):
95 | """
96 | aetes : list of AEDesc
97 | style : str
98 | """
99 | receiver = TerminologyTableReceiver(style)
100 | parse(aetes, receiver)
101 | return receiver.result()
102 |
103 |
104 |
105 |
--------------------------------------------------------------------------------
/py-osaterminology/lib/osaterminology/renderers/typerenderers.py:
--------------------------------------------------------------------------------
1 | """typerenderers"""
2 |
3 | from osaterminology.dom.osadictionary import kAll, Nodes
4 |
5 | from codecs import getencoder
6 |
7 | strtohex = getencoder('hex_codec')
8 |
9 |
10 | ######################################################################
11 |
12 |
13 | class TypeRendererBase:
14 |
15 | def __init__(self):
16 | self._renderedtypes = {} # cache
17 |
18 | def render(self, types, sep=' | '): # TO DO: rename (typeorenum? typename?)
19 | # oldvis = types.setvisibility(kAll) # TO DO: find right place for these calls
20 | res = []
21 | if not isinstance(types, (list, Nodes)):
22 | types = [types]
23 | for otype in types:
24 | type = otype.realvalue() # TO DO: this might throw up weird results if there's a mix (not that there should be if the dictionary is properly designed...)
25 | if type.code:
26 | if type.code not in self._renderedtypes:
27 | self._renderedtypes[type.code] = self._render(type)
28 | s = self._renderedtypes[type.code]
29 | else:
30 | s = type.name
31 | if otype.islist:
32 | s = 'list of '+s
33 | res.append(s)
34 | # types.setvisibility(oldvis)
35 | return sep.join(res)
36 |
37 |
38 | ######################################################################
39 |
40 |
41 | class AppscriptTypeRenderer(TypeRendererBase):
42 |
43 | def _render(self, type):
44 | if type.kind == 'enumeration':
45 | return ' / '.join([e.name and self._keyword % e.name or self._enum % self.escapecode(e.code)
46 | for e in type.enumerators()])
47 | else:
48 | return type.name or self._type % self.escapecode(type.code)
49 |
50 | def escapecode(self, s): # TO DO: how is s arg represented?
51 | # format non-ASCII characters as '\x00' hex values for readability (also backslash and single and double quotes)
52 | if isinstance(s, bytes): s = str(s, 'macroman')
53 | res = ''
54 | for c in s:
55 | n = ord(c)
56 | if 31 < n < 128 and c not in '\\\'"':
57 | res += c
58 | else:
59 | res += '\\x%02x' % n
60 | return res
61 |
62 | def elementname(self, type): # appscript uses plural names for elements
63 | type = type.realvalue()
64 | return getattr(type, 'pluralname', type.name) or self._render(type)
65 |
66 |
67 | class PyAppscriptTypeRenderer(AppscriptTypeRenderer):
68 | _type = 'AEType(%r)'
69 | _enum = 'AEEnum(%r)'
70 | _keyword = 'k.%s'
71 |
72 |
73 | class RbAppscriptTypeRenderer(AppscriptTypeRenderer):
74 | _type = 'AEType.new("%s")'
75 | _enum = 'AEEnum.new("%s")'
76 | _keyword = ':%s'
77 |
78 |
79 | class NodeAutomationTypeRenderer(TypeRendererBase):
80 | _type = 'k.fromTypeCode(%s)'
81 | _enum = 'k.fromEnumCode(%s)'
82 | _keyword = 'k.%s'
83 |
84 | def _render(self, type):
85 | if type.kind == 'enumeration':
86 | return ' / '.join([e.name and self._keyword % e.name or self._enum % self.escapecode(e.code)
87 | for e in type.enumerators()])
88 | else:
89 | return type.name or self._type % self.escapecode(type.code)
90 |
91 | def escapecode(self, s):
92 | if isinstance(s, bytes): s = str(s, 'macroman')
93 | res = ''
94 | for c in s:
95 | n = ord(c)
96 | if 31 < n < 128 and c not in '\\\'"':
97 | res += c
98 | else:
99 | n = 0
100 | for c in s[::-1]:
101 | n *= 256
102 | n += ord(c)
103 | return '0x{:08x}'.format(n)
104 | return "'#{}'".format(res)
105 |
106 | def elementname(self, type): # appscript uses plural names for elements
107 | type = type.realvalue()
108 | return getattr(type, 'pluralname', type.name) or self._render(type)
109 |
110 |
111 | ######################################################################
112 |
113 |
114 | class ApplescriptTypeRenderer(TypeRendererBase):
115 |
116 | def _render(self, type):
117 | if type.kind == 'enumeration':
118 | return ' / '.join([e.name or '' % self.escapecode(e.code)
119 | for e in type.enumerators()])
120 | else:
121 | return type.name or '' % self.escapecode(type.code)
122 |
123 | def escapecode(self, s):
124 | return str(s, 'macroman')
125 |
126 | def elementname(self, type): # AppleScript uses singular names for elements
127 | return self._render(type.realvalue())
128 |
129 |
130 | ######################################################################
131 |
132 | typerenderers = {
133 | 'applescript': ApplescriptTypeRenderer,
134 | 'appscript': PyAppscriptTypeRenderer,
135 | 'py-appscript': PyAppscriptTypeRenderer,
136 | 'rb-scpt': RbAppscriptTypeRenderer,
137 | 'nodeautomation': NodeAutomationTypeRenderer,
138 | }
139 |
140 | ######################################################################
141 |
142 |
143 | def gettyperenderer(name):
144 | try:
145 | return typerenderers[name]()
146 | except KeyError:
147 | raise KeyError("Couldn't find a type renderer named %r." % name)
148 |
149 |
--------------------------------------------------------------------------------
/py-appscript/doc/appscript-manual/12_commandexamples.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | py-appscript manual | 12. Command examples
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
28 |
29 |
30 |
31 |
32 |
12. Command examples
33 |
34 |
get
35 |
36 |
Get the name of every folder in the user's home folder:
37 |
38 |
# tell application "Finder" to get name of every folder of home
39 |
40 | app('Finder').get(app.home.folders.name)
41 |
42 |
Note that if the direct parameter is omitted from the parameter list, the reference that the command is invoked on is used instead. For example, the above example would normally be written as:
43 |
44 |
app('Finder').home.folders.name.get()
45 |
46 |
Also note that the .get portion can be omitted for convenience:
47 |
48 |
app('Finder').home.folders.name()
49 |
50 |
51 |
set
52 |
53 |
Set the content of a TextEdit document:
54 |
55 |
# tell application "TextEdit" to set text of document 1 to "Hello World"
56 |
57 | app('TextEdit').documents[1].text.set('Hello World')
58 |
59 |
60 |
count
61 |
62 |
Count the words in a TextEdit document:
63 |
64 |
# tell application "TextEdit" to count words of document 1
65 |
66 | app('TextEdit').documents[1].words.count()
67 |
68 |
Count the items in the current user's home folder:
69 |
70 |
#tell application "Finder" to count items of home
71 |
72 | app('Finder').home.count(each=k.item)
73 |
74 |
(Note that the each parameter is required in Finder's count command.)
75 |
76 |
77 |
make
78 |
79 |
Create a new TextEdit document:
80 |
81 |
# tell application "TextEdit" to make new document ¬
82 | # with properties {text:"Hello World\n"}
83 |
84 | app('TextEdit').make(
85 | new=k.document,
86 | with_properties={k.text:'Hello World\n'})
87 |
88 |
Append text to a TextEdit document:
89 |
90 |
# tell application "TextEdit" to make new paragraph ¬
91 | # at end of text of document 1 ¬
92 | # with properties {text:"Yesterday\nToday\nTomorrow\n"}
93 |
94 | app('TextEdit').make(
95 | new=k.paragraph,
96 | at=app.documents[1].text.end,
97 | with_data='Yesterday\nToday\nTomorrow\n')
98 |
99 |
Note that the make command's at parameter can be omitted for convenience, in which case the reference that the command is invoked on is used instead:
100 |
101 |
app('TextEdit').documents[1].text.end.make(
102 | new=k.paragraph,
103 | with_data='Yesterday\nToday\nTomorrow\n')
104 |
105 |
106 |
duplicate
107 |
108 |
Duplicate a folder to a disk, replacing an existing item if one exists:
109 |
110 |
# tell application "Finder" to ¬
111 | # duplicate folder "Projects" of home to disk "Work" with replacing
112 |
113 | app('Finder').home.folders['Projects'].duplicate(
114 | to=app.disks['Work'], replacing=True)
115 |
116 |
117 |
add
118 |
119 |
Add every person with a known birthday to a group named "Birthdays":
120 |
121 |
# tell application "Contacts" to add ¬
122 | # every person whose birth date is not missing value ¬
123 | # to group "Birthdays"
124 |
125 | app('Contacts').people[
126 | its.birth_date != k.missing_value
127 | ].add(to=app.groups['Birthdays'])
128 |
129 |
130 |
131 |
14 |
15 |
16 |
27 |
28 |
29 |
30 |
31 |
14. Notes
32 |
33 |
Security issues
34 |
35 |
System Integrity Protection
36 |
37 |
In macOS 10.14+, System Integrity Protection helps to protect users from malicious AppleScripts by blocking (most) Apple events until and unless the user explicitly grants permission for one application to control another:
38 |
39 |
40 |
41 |
Be aware that these permissions apply at the GUI application level, not to specific python (or osascript) scripts or processes, so once granted for one script will apply to all scripts subsequently run by the same application. Standard commands (Apple events) recognized by all Mac applications (run, open, quit, etc.) are not affected.
42 |
43 |
The Automation controls in the Security & Privacy panel's Privacy tab in System Preferences may be used to alter an application's existing Automation (Apple event) permissions at any time:
44 |
45 |
46 |
47 |
To delete all existing Automation permissions in Terminal:
48 |
49 |
tccutil reset AppleEvents
50 |
51 |
(See also: AppleScript-related changes in macOS 10.14.)
52 |
53 |
54 |
GUI Scripting
55 |
56 |
Non-scriptable applications with macOS Accessibility support may be controlled from Python by using the System Events application to manipulate their graphical interfaces directly. In macOS 10.9 and later, the user will be prompted to allow/deny the current application access to Accessibility features upon first use.
57 |
58 |
The Accessibility controls in the Security & Privacy panel's Privacy tab in System Preferences may be used to add or remove an application's Accessibility permissions at any time:
59 |
60 |
61 |
62 |
Older Mac OS versions had less granular security model, allowing any application to use GUI Scripting once the "Enable access for assistive devices" checkbox in the Universal Access panel of System Preferences was enabled.
63 |
64 |
65 |
Remote Apple Events
66 |
67 |
If including user names and/or passwords in remote application URLs (not recommended), please note that appscript retains these URLs in both the terminology module's internal cache and in the app objects created with those URLs. Security here is the user's responsibility, as it's their code that creates and retains these objects.
68 |
69 |
70 |
AEDescs
71 |
72 |
Some applications (e.g. QuarkXpress) may return values which appscript cannot convert to equivalent Python types. These values are usually of types which are defined, used and understood only by that particular application, and will be represented in Python as raw aem.ae.AEDesc objects. While there's not much you can do with raw AEDesc objects within Python (it's best just to treat them as opaque types), subsequent commands can pass them back to the application for further use and/or conversion just like any other value.
73 |
74 |
75 |
Event loops
76 |
77 |
Python-based applications that use a Carbon/Cocoa event loop can import the appscript module as normal, but should not use it before the event loop has started as sending Apple events outwith the main event loop can disrupt the process's normal event handling.
78 |
79 |
80 |
Credits
81 |
82 |
Many thanks to Philip Aker, Ben Artin, Jack Jansen, Jordan K Hubbard, Bob Ippolito, Thomas Loredo, Jacob Kaplan-Moss, Georges Martin, Nick Matsakis, Larry McMunn, Chris Nandor, Chris Nebel, Matt Neuburg, Ronald Oussoren, David Person, Donovan Preston, Jon Pugh, Jay Soffian, Clayton Wheeler, Kevin Van Vechten, and all the appscript users who've provided comments, criticisms and encouragement along the way. Special thanks to those who've donated to the development and upkeep of this project.
83 |
84 |
85 |
Website
86 |
87 |
http://appscript.sourceforge.net
88 |
89 |
