"""Suite AppleScript Suite: Standard terms for AppleScript

Level 1, version 1

Generated from /Volumes/Sap/System Folder/Extensions/AppleScript

AETE/AEUT resource version 1/0, language 0, script 0

"""

import aetools

import MacOS

_code = 'ascr'

class AppleScript_Suite_Events:

    def _26_(self, _object, _attributes={}, **_arguments):

        """&: Concatenation

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'ccat'

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _2a_(self, _object, _attributes={}, **_arguments):

        """*: Multiplication

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '*   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _2b_(self, _object, _attributes={}, **_arguments):

        """+: Addition

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '+   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _2d_(self, _object, _attributes={}, **_arguments):

        """-: Subtraction

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '-   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _3c_(self, _object, _attributes={}, **_arguments):

        """<: Less than

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '<   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _3d_(self, _object, _attributes={}, **_arguments):

        """=: Equality

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '=   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _3e_(self, _object, _attributes={}, **_arguments):

        """>: Greater than

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '>   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    _argmap_Call_a5_subroutine = {

        'at' : 'at  ',

        'from_' : 'from',

        'for_' : 'for ',

        'to' : 'to  ',

        'thru' : 'thru',

        'through' : 'thgh',

        'by' : 'by  ',

        'on' : 'on  ',

        'into' : 'into',

        'onto' : 'onto',

        'between' : 'btwn',

        'against' : 'agst',

        'out_of' : 'outo',

        'instead_of' : 'isto',

        'aside_from' : 'asdf',

        'around' : 'arnd',

        'beside' : 'bsid',

        'beneath' : 'bnth',

        'under' : 'undr',

        'over' : 'over',

        'above' : 'abve',

        'below' : 'belw',

        'apart_from' : 'aprt',

        'about' : 'abou',

        'since' : 'snce',

        'given' : 'givn',

        'with' : 'with',

        'without' : 'wout',

    }

    def Call_a5_subroutine(self, _object=None, _attributes={}, **_arguments):

        """Call\xa5subroutine: A subroutine call

        Required argument: anything

        Keyword argument at: a preposition

        Keyword argument from_: a preposition

        Keyword argument for_: a preposition

        Keyword argument to: a preposition

        Keyword argument thru: a preposition

        Keyword argument through: a preposition

        Keyword argument by: a preposition

        Keyword argument on: a preposition

        Keyword argument into: a preposition

        Keyword argument onto: a preposition

        Keyword argument between: a preposition

        Keyword argument against: a preposition

        Keyword argument out_of: a preposition

        Keyword argument instead_of: a preposition

        Keyword argument aside_from: a preposition

        Keyword argument around: a preposition

        Keyword argument beside: a preposition

        Keyword argument beneath: a preposition

        Keyword argument under: a preposition

        Keyword argument over: a preposition

        Keyword argument above: a preposition

        Keyword argument below: a preposition

        Keyword argument apart_from: a preposition

        Keyword argument about: a preposition

        Keyword argument since: a preposition

        Keyword argument given: parameter:value pairs, comma-separated

        Keyword argument with: formal parameter set to true if matching actual parameter is provided

        Keyword argument without: formal parameter set to false if matching actual parmeter is provided

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'psbr'

        aetools.keysubst(_arguments, self._argmap_Call_a5_subroutine)

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def _5e_(self, _object, _attributes={}, **_arguments):

        """^: Exponentiation

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = '^   '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def activate(self, _no_object=None, _attributes={}, **_arguments):

        """activate: Bring the targeted application program to the front

        Keyword argument _attributes: AppleEvent attribute dictionary

        """

        _code = 'misc'

        _subcode = 'actv'

        if _arguments: raise TypeError, 'No optional args expected'

        if _no_object is not None: raise TypeError, 'No direct arg expected'

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def and_(self, _object, _attributes={}, **_arguments):

        """and: Logical conjunction

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'AND '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def as_(self, _object, _attributes={}, **_arguments):

        """as: Coercion

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'coer'

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def contains(self, _object, _attributes={}, **_arguments):

        """contains: Containment

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'cont'

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def div(self, _object, _attributes={}, **_arguments):

        """div: Quotient

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'div '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def end_tell(self, _no_object=None, _attributes={}, **_arguments):

        """end tell: Record or log an \xd4end tell\xd5 statement

        Keyword argument _attributes: AppleEvent attribute dictionary

        """

        _code = 'ascr'

        _subcode = 'tend'

        if _arguments: raise TypeError, 'No optional args expected'

        if _no_object is not None: raise TypeError, 'No direct arg expected'

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def ends_with(self, _object, _attributes={}, **_arguments):

        """ends with: Ends with

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'ends'

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    _argmap_error = {

        'number' : 'errn',

        'partial_result' : 'ptlr',

        'from_' : 'erob',

        'to' : 'errt',

    }

    def error(self, _object=None, _attributes={}, **_arguments):

        """error: Raise an error

        Required argument: anything

        Keyword argument number: an error number

        Keyword argument partial_result: any partial result occurring before the error

        Keyword argument from_: the object that caused the error

        Keyword argument to: the desired class for a failed coercion

        Keyword argument _attributes: AppleEvent attribute dictionary

        """

        _code = 'ascr'

        _subcode = 'err '

        aetools.keysubst(_arguments, self._argmap_error)

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def idle(self, _no_object=None, _attributes={}, **_arguments):

        """idle: Sent to a script application when it is idle

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: the number of seconds to wait for next idle event

        """

        _code = 'misc'

        _subcode = 'idle'

        if _arguments: raise TypeError, 'No optional args expected'

        if _no_object is not None: raise TypeError, 'No direct arg expected'

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def launch(self, _no_object=None, _attributes={}, **_arguments):

        """launch: Start an application for scripting

        Keyword argument _attributes: AppleEvent attribute dictionary

        """

        _code = 'ascr'

        _subcode = 'noop'

        if _arguments: raise TypeError, 'No optional args expected'

        if _no_object is not None: raise TypeError, 'No direct arg expected'

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def log(self, _object, _attributes={}, **_arguments):

        """log: Cause a comment to be logged

        Required argument: undocumented, typecode 'TEXT'

        Keyword argument _attributes: AppleEvent attribute dictionary

        """

        _code = 'ascr'

        _subcode = 'cmnt'

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def mod(self, _object, _attributes={}, **_arguments):

        """mod: Remainder

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'mod '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object

        _reply, _arguments, _attributes = self.send(_code, _subcode,

                _arguments, _attributes)

        if _arguments.get('errn', 0):

            raise aetools.Error, aetools.decodeerror(_arguments)

        # XXXX Optionally decode result

        if _arguments.has_key('----'):

            return _arguments['----']

    def negate(self, _object, _attributes={}, **_arguments):

        """negate: Numeric negation

        Required argument: an AE object reference

        Keyword argument _attributes: AppleEvent attribute dictionary

        Returns: anything

        """

        _code = 'ascr'

        _subcode = 'neg '

        if _arguments: raise TypeError, 'No optional args expected'

        _arguments['----'] = _object