예제 #1
0
파일: utils.py 프로젝트: gijs/music-player
def do_in_mainthread(f, wait=True):
	# Note: We don't need/want the NSThread.isMainThread() check and extra handling.
	# The `performSelectorOnMainThread:withObject:waitUntilDone:` does the right thing
	# in case we are the main thread: if wait is True, it is executed from here,
	# otherwise it is queued and executed in the next frame.
	
	try:
		NSObject = objc.lookUpClass("NSObject")
		class PyAsyncCallHelper(NSObject):
			def initWithArgs_(self, f):
				self.f = f
				self.ret = None
				self.exc = None
				return self
			def call_(self, o):
				try:
					self.ret = self.f()
				except (KeyboardInterrupt,SystemExit) as exc:
					self.exc = exc
				except:
					print "Exception in PyAsyncCallHelper call"
					sys.excepthook(*sys.exc_info())					
	except Exception:
		PyAsyncCallHelper = objc.lookUpClass("PyAsyncCallHelper") # already defined earlier

	helper = PyAsyncCallHelper.alloc().initWithArgs_(f)
	helper.performSelectorOnMainThread_withObject_waitUntilDone_(helper.call_, None, wait)
	if wait and helper.exc:
		raise helper.exc
	return helper.ret
예제 #2
0
    def __init__(self, driver_name="DMX Bridge", universe=0):
        """ midi->dmx bridge
        :param driver_name:  The midi name of the bridge. This will
                      show up in Logic
        :param universe:    The DMX universe to connect to
        """

        self.driver_name = driver_name
        self.appname = "{} - {}".format(__appname__, driver_name)
        # initialize a default dmx frame

        self.midi_source = MIDIDestination(driver_name)

        self.frame = [0] * 255
        self.universe = universe

        # this is the starting note for all midi channels
        self.note_offset = 24

        # this is the number of dmx channels per midi channel
        # each midi channel will support 32 notes. This will allow
        # 16 fixtures via 16 midi channels.
        self.dmx_offset = 32

        # MacOS X related stuff

        self.NSUserNotification = objc.lookUpClass('NSUserNotification')
        self.NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')

        self.dmx_wrapper = None
        self.dmx_client = None
        self.dmx_tick = 100
        self.midi_tick = 10
        super(Midi2Dmx, self).__init__()
예제 #3
0
    def testNullTerminated(self):
        o = OC_MetaDataTest.new()

        v = o.makeStringArray_((b"hello", b"world", b"there"))
        self.assertEqual(len(v), 3)
        self.assertEqual(list(v), ["hello", "world", "there"])
        self.assertIsInstance(v, objc.lookUpClass("NSArray"))
        self.assertIsInstance(v[0], unicode)

        NSObject = objc.lookUpClass('NSObject')
        p, q, r = NSObject.new(), NSObject.new(), NSObject.new()
        v = o.makeObjectArray_((p, q, r))
        self.assertEqual(len(v), 3)
        self.assertIs(v[0], p)
        self.assertIs(v[1], q)
        self.assertIs(v[2], r)


        v = o.makeStringArray_(())
        self.assertEqual(len(v), 0)

        self.assertRaises(ValueError, o.makeStringArray_, [1,2])
        self.assertRaises(ValueError, o.makeStringArray_, objc.NULL)

        v = o.nullStringArray_(objc.NULL)
        self.assertEqual(v, None)
    def __init__(self):
        if self.NSUSERDEFAULTS_SUITE is not None:
            self._user_defaults = objc.lookUpClass('NSUserDefaults').alloc().initWithSuiteName_(self.NSUSERDEFAULTS_SUITE)
        else:
            self._user_defaults = objc.lookUpClass('NSUserDefaults').standardUserDefaults()

        super(NSUserDefaultsConfig, self).__init__()
예제 #5
0
파일: utils.py 프로젝트: etel/music-player
def do_in_mainthread(f, wait=True):
	from AppKit import NSThread
	if NSThread.isMainThread():
		return f()

	try:
		NSObject = objc.lookUpClass("NSObject")
		class PyAsyncCallHelper(NSObject):
			def initWithArgs_(self, f):
				self.f = f
				self.ret = None
				self.exc = None
				return self
			def call_(self, o):
				try:
					self.ret = self.f()
				except (KeyboardInterrupt,SystemExit) as exc:
					self.exc = exc
				except:
					print "Exception in PyAsyncCallHelper call"
					sys.excepthook(*sys.exc_info())					
	except:
		PyAsyncCallHelper = objc.lookUpClass("PyAsyncCallHelper") # already defined earlier

	helper = PyAsyncCallHelper.alloc().initWithArgs_(f)
	helper.performSelectorOnMainThread_withObject_waitUntilDone_(helper.call_, None, wait)
	if wait and helper.exc:
		raise helper.exc
	return helper.ret
예제 #6
0
파일: gui.py 프로젝트: svn2github/Xpra
def register_URL_handler(handler):
    log("register_URL_handler(%s)", handler)
    import objc         #@UnresolvedImport
    NSAppleEventManager = objc.lookUpClass('NSAppleEventManager')
    NSObject = objc.lookUpClass('NSObject')

    class GURLHandler(NSObject):
        def handleEvent_withReplyEvent_(self, event, reply_event):
            log("GURLHandler.handleEvent")
            url = event.descriptorForKeyword_(fourCharToInt('----')).stringValue()
            log("URL=%s", url)
            handler(url.encode())

    # A helper to make struct since cocoa headers seem to make
    # it impossible to use kAE*
    import struct
    fourCharToInt = lambda code: struct.unpack('>l', code)[0]

    urlh = GURLHandler.alloc()
    urlh.init()
    urlh.retain()
    manager = NSAppleEventManager.sharedAppleEventManager()
    manager.setEventHandler_andSelector_forEventClass_andEventID_(
        urlh, 'handleEvent:withReplyEvent:',
        fourCharToInt('GURL'), fourCharToInt('GURL')
        )
예제 #7
0
    def testNullTerminated(self):

        v = makeStringArray_(("hello", "world", "there"))
        self.assertEquals(len(v), 3)
        self.assertEquals(list(v), [u"hello", u"world", u"there"])
        self.assert_( isinstance(v, objc.lookUpClass("NSArray")) )
        self.assert_( isinstance(v[0], unicode) )

        NSObject = objc.lookUpClass('NSObject')
        p, q, r = NSObject.new(), NSObject.new(), NSObject.new()
        v = makeObjectArray_((p, q, r))
        self.assertEquals(len(v), 3)
        self.assert_( v[0] is p )
        self.assert_( v[1] is q )
        self.assert_( v[2] is r )


        v = makeStringArray_(())
        self.assertEquals(len(v), 0)

        self.assertRaises(ValueError, makeStringArray_, [1,2])
        self.assertRaises(ValueError, makeStringArray_, objc.NULL)

        v = nullStringArray_(objc.NULL)
        self.assertEquals(v, None)
예제 #8
0
    def test_kvc_helper(self):
        o = objc.lookUpClass('NSURL').URLWithString_('http://www.python.org/')
        self.assertEqual(o.host(), 'www.python.org')

        self.assertEqual(o._.host, 'www.python.org')
        self.assertEqual(o._['host'], 'www.python.org')
        self.assertRaises(TypeError, lambda: o._[42])
        self.assertEqual(repr(o._), '<KVC accessor for %r>'%(o,))
        self.assertRaises(AttributeError, getattr, o._, 'nosuchattr')
        self.assertRaises(AttributeError, getattr, o._, '')
        self.assertRaises(TypeError, o._.__getitem__, 42)

        o = objc.lookUpClass('NSMutableDictionary').dictionary()
        o._.key1 = 1
        o._['key2'] = 2

        self.assertEqual(o, {'key1': 1, 'key2': 2 })

        # At least on OSX 10.11 the KVC accessor for NSDictionary returns
        # nil for non-existing keys.
        #self.assertRaises(AttributeError, getattr, o._, 'nosuchattr')
        self.assertRaises(TypeError, o._.__setitem__, 42, 1)

        o = OC_WithHash.alloc().initWithHash_(1)
        self.assertRaises(IndexError, getattr, o._, 'someKey')
        self.assertRaises(KeyError, getattr, o._, 'someOtherKey')
예제 #9
0
    def testNullTerminated(self):
        o = OC_MetaDataTest.new()

        m = o.methodForSelector_('makeStringArray:')

        v = m(o, ("hello", "world", "there"))
        self.assertEquals(len(v), 3)
        self.assertEquals(list(v), [u"hello", u"world", u"there"])
        self.assert_( isinstance(v, objc.lookUpClass("NSArray")) )
        self.assert_( isinstance(v[0], unicode) )

        m = o.methodForSelector_('makeObjectArray:')

        NSObject = objc.lookUpClass('NSObject')
        p, q, r = NSObject.new(), NSObject.new(), NSObject.new()
        v = m(o, (p, q, r))
        self.assertEquals(len(v), 3)
        self.assert_( v[0] is p )
        self.assert_( v[1] is q )
        self.assert_( v[2] is r )

        m = o.methodForSelector_('makeStringArray:')

        v = m(o, ())
        self.assertEquals(len(v), 0)

        self.assertRaises(ValueError, m, o, [1,2])
        self.assertRaises(ValueError, m, o, objc.NULL)

        m = o.methodForSelector_('nullStringArray:')
        v = m(o, objc.NULL)
        self.assertEquals(v, None)
예제 #10
0
def notify(title, subtitle, info_text, delay=0, sound=False, userInfo={}):
    """ Python method to show a desktop notification on Mountain Lion. Where:
        title: Title of notification
        subtitle: Subtitle of notification
        info_text: Informative text of notification
        delay: Delay (in seconds) before showing the notification
        sound: Play the default notification sound
        userInfo: a dictionary that can be used to handle clicks in your
                  app's applicationDidFinishLaunching:aNotification method
    """
    from Foundation import NSDate
    from objc import lookUpClass

    NSUserNotification = lookUpClass('NSUserNotification')
    NSUserNotificationCenter = lookUpClass('NSUserNotificationCenter')

    notification = NSUserNotification.alloc().init()
    notification.setTitle_(title)
    notification.setSubtitle_(subtitle)
    notification.setInformativeText_(info_text)
    notification.setUserInfo_(userInfo)
    if sound:
        notification.setSoundName_("NSUserNotificationDefaultSoundName")
    notification.setDeliveryDate_(NSDate.dateWithTimeInterval_sinceDate_(delay, NSDate.date()))
    NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(notification)
예제 #11
0
def notify(title, message, retcode=None):
    """
    adapted from https://gist.github.com/baliw/4020619
    """
    try:
        import Foundation
        import objc
    except ImportError:
        import sys
        import logging

        logger = logging.getLogger(__name__)
        if sys.platform.startswith('darwin') and hasattr(sys, 'real_prefix'):
            logger.error(
                "Using ntfy with the MacOS Notification Center doesn't "
                "work within a virtualenv")
            sys.exit(1)
        else:
            raise

    NSUserNotification = objc.lookUpClass('NSUserNotification')
    NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')

    notification = NSUserNotification.alloc().init()
    notification.setTitle_(title)
    if message is not None:
        notification.setInformativeText_(message)
    notification.setDeliveryDate_(Foundation.NSDate.date())

    NSUserNotificationCenter.defaultUserNotificationCenter()\
        .scheduleNotification_(notification)
예제 #12
0
    def ping(self, expr, out, exception=None):
        try:
            import Foundation, AppKit, objc
        except ImportError:
            raise Exception("Could not import Foundation/AppKit/objc -- maybe"
                "you're not on OS X 10.8+")

        NSUserNotification = objc.lookUpClass('NSUserNotification')
        NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')

        notification = NSUserNotification.alloc().init()
        if exception:
            notification.setTitle_('%s in iPython Task' 
                % str(exception.__class__.__name__))
            notification.setInformativeText_(str(exception)) 
        else:
            notification.setTitle_('iPython Task Complete')
            notification.setInformativeText_(out) 
        notification.setSubtitle_(expr.split('\n')[0])
        notification.setUserInfo_({})
        if self.sound:
            notification.setSoundName_('NSUserNotificationDefaultSoundName')

        NSUserNotificationCenter\
            .defaultUserNotificationCenter()\
            .scheduleNotification_(notification)

        return None
예제 #13
0
 def run_browser_window_(self,filename,browser,window):
     
     self.DicomStudy = objc.lookUpClass("DicomStudy") # XXX would prefer to do these in init, but not sure init is ever called
     self.DCMObject = objc.lookUpClass("DCMObject")
     
     self.filename = filename
     self.browser  = browser
     self.window   = window
     
     self.database = OpyrixDatabase(self)
     
     sys.stdout = OpyrixOutput(self)
     sys.stderr = sys.stdout
     
     #print ">>> OpyrixScript::run_browser_window_"
     
     try:
         return execfile(filename,{"database":self.database,
                         "OpyrixMetaDataStudy":OpyrixMetaDataStudy,
                         "OpyrixMetaDataSeries":OpyrixMetaDataSeries,
                         "OpyrixMetaDataImageMRI":OpyrixMetaDataImageMRI,
                         "OpyrixServer":OpyrixServer,
                         "OpyrixQuery":OpyrixQuery,
                         "OpyrixStopScript":OpyrixStopScript})
     except OpyrixStopScript as e:
         print ">>> Stopped script during execution"
         return 1
     except Exception as e:
         print ">>> Caught an exception during execution:"
         traceback.print_exc()
         return 1
예제 #14
0
def _classExists(className):
    """Return True if a class exists in the Obj-C runtime."""
    try:
        objc.lookUpClass(className)
    except objc.error:
        return 0
    else:
        return 1
예제 #15
0
    def testClasses(self):
        self.assert_( hasattr(SearchKit, 'SKDocumentRef') )
        self.assert_( issubclass(SearchKit.SKDocumentRef, objc.lookUpClass('NSCFType')) )
        self.assert_( SearchKit.SKDocumentRef is not objc.lookUpClass('NSCFType') )

        self.assert_( hasattr(SearchKit, 'SKIndexRef') )
        self.assert_( issubclass(SearchKit.SKIndexRef, objc.lookUpClass('NSCFType')) )
        self.assert_( SearchKit.SKIndexRef is not objc.lookUpClass('NSCFType') )
예제 #16
0
    def init(self):
        self = super(MountainLionNotification, self).init()
        if self is None: return None

        # Get objc references to the classes we need.
        self.NSUserNotification = objc.lookUpClass('NSUserNotification')
        self.NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')

        return self
예제 #17
0
    def testClassList(self):
        ###! This test should probably be moved down to the Foundation test suite...

        NSObject = objc.lookUpClass('NSObject')
        NSException = objc.lookUpClass('NSException')
        NSMutableArray = objc.lookUpClass('NSMutableArray')

        self.assert_(NSObject in objc.getClassList(), "getClassList() does not appear to contain NSObject class")
        self.assert_(NSException in objc.getClassList(), "getClassList() does not appear to contain NSException class")
        self.assert_(NSMutableArray in objc.getClassList(), "getClassList() does not appear to contain NSMutableArray class")
예제 #18
0
    def testClassList(self):
        ###! This test should probably be moved down to the Foundation test suite...

        NSObject = objc.lookUpClass('NSObject')
        NSException = objc.lookUpClass('NSException')
        NSMutableArray = objc.lookUpClass('NSMutableArray')

        self.assertIn(NSObject, objc.getClassList())
        self.assertIn(NSException, objc.getClassList())
        self.assertIn(NSMutableArray, objc.getClassList())
예제 #19
0
 def __init__(self):
     # It's only possible to send notifications if we have a bundle
     # identifier set. This happens by default if using Python
     # installed as a Framework (e.g. the system Python), but isn't
     # set in a virtualenv.
     NSBundle.mainBundle().infoDictionary().setdefault(
         "CFBundleIdentifier", "org.4pisky.tools")
     self.NSUserNotification = lookUpClass("NSUserNotification")
     NCenter = lookUpClass("NSUserNotificationCenter")
     self.center = NCenter.defaultUserNotificationCenter()
예제 #20
0
파일: debug_init.py 프로젝트: remear/rivenx
def _load_globals():
    global world, renderer, engine, archive_manager, load_notification_handler
    world = objc.lookUpClass('RXWorld').sharedWorld()
    if world:
        renderer = world.cardRenderer()
    if renderer:
        engine = renderer.scriptEngine()
    archive_manager = objc.lookUpClass('RXArchiveManager').sharedArchiveManager()

    if load_notification_handler:
        del load_notification_handler
예제 #21
0
파일: homebrew.py 프로젝트: k3rn/dotFiles
def notify(title, subtitle, info_text, delay=0, userInfo={}):
    NSUserNotification = objc.lookUpClass("NSUserNotification")
    NSUserNotificationCenter = objc.lookUpClass("NSUserNotificationCenter")

    notification = NSUserNotification.alloc().init()
    notification.setTitle_(title)
    notification.setSubtitle_(subtitle)
    notification.setInformativeText_(info_text)
    notification.setUserInfo_(userInfo)
    notification.setDeliveryDate_(Foundation.NSDate.dateWithTimeInterval_sinceDate_(delay, Foundation.NSDate.date()))
    NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(notification)
예제 #22
0
    def test_assert_cftype(self):
        self.assertRaises(AssertionError, self.assertIsCFType, long)
        self.assertRaises(AssertionError, self.assertIsCFType, objc.lookUpClass('NSCFType'))

        self.assertIsCFType(objc.lookUpClass('NSObject'))
        #self.assertRaises(AssertionError, self.assertIsCFType, objc.lookUpClass('NSObject'))

        class OC_OPAQUE_TEST_1 (objc.lookUpClass('NSCFType')): pass
        try:
            self.assertIsCFType(OC_OPAQUE_TEST_1)
        except AssertionError:
            self.fail("CFType subclass not recognized as CFType")
예제 #23
0
    def test_creation(self):
        NSData = objc.lookUpClass('NSData')
        NSMutableData = objc.lookUpClass('NSMutableData')

        data = NSData(b'hello')
        data2 = NSMutableData(b'moon')

        self.assertEqual(bytes(data), b'hello')
        self.assertEqual(bytes(data2), b'moon')

        self.assertIsInstance(data, NSData)
        self.assertIsInstance(data2, NSMutableData)
예제 #24
0
def notify(self, title, subtitle, text, url):
    NSUserNotification = objc.lookUpClass('NSUserNotification')
    NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
    notification = NSUserNotification.alloc().init()
    notification.setTitle_(str(title))
    notification.setSubtitle_(str(subtitle))
    notification.setInformativeText_(str(text))
    notification.setSoundName_("NSUserNotificationDefaultSoundName")
    notification.setHasActionButton_(True)
    notification.setOtherButtonTitle_("View")
    notification.setUserInfo_({"action":"open_url", "value":url})
    NSUserNotificationCenter.defaultUserNotificationCenter().setDelegate_(self)
    NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(notification)
예제 #25
0
def _setup():
    NSArray = _objc.lookUpClass('NSArray')
    NSMutableArray = _objc.lookUpClass('NSMutableArray')

    def CFArrayCreate(allocator, values, numvalues, callbacks):
        assert callbacks is None
        return NSArray.alloc().initWithArray_(values[:numvalues])

    def CFArrayCreateMutable(allocator, capacity, callbacks):
        assert callbacks is None
        return NSMutableArray.alloc().init()

    return CFArrayCreate, CFArrayCreateMutable
 def _notify(self, **kwargs):
     NSUserNotification = objc.lookUpClass('NSUserNotification')
     NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
     notification = NSUserNotification.alloc().init()
     notification.setTitle_(kwargs.get('title').encode('utf-8'))
     #notification.setSubtitle_(str(subtitle))
     notification.setInformativeText_(kwargs.get('message').encode('utf-8'))
     notification.setSoundName_("NSUserNotificationDefaultSoundName")
     #notification.setHasActionButton_(False)
     #notification.setOtherButtonTitle_("View")
     #notification.setUserInfo_({"action":"open_url", "value":url})
     NSUserNotificationCenter.defaultUserNotificationCenter().setDelegate_(self)
     NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(notification)
예제 #27
0
파일: douban.py 프로젝트: fusky/douban.fm
 def send_OS_X_notify(self, title, content, img_path):
     NSUserNotification = objc.lookUpClass('NSUserNotification')
     NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
     NSImage = objc.lookUpClass('NSImage')
     notification = NSUserNotification.alloc().init()
     notification.setTitle_(title.decode('utf-8'))
     notification.setSubtitle_('')
     notification.setInformativeText_(content.decode('utf-8'))
     notification.setUserInfo_({})
     image = NSImage.alloc().initWithContentsOfFile_(img_path)
     notification.setContentImage_(image)
     notification.setSoundName_("NSUserNotificationDefaultSoundName")
     notification.setDeliveryDate_(Foundation.NSDate.dateWithTimeInterval_sinceDate_(0, Foundation.NSDate.date()))
     NSUserNotificationCenter.defaultUserNotificationCenter().scheduleNotification_(notification)
예제 #28
0
    def dont_testNSString(self):
        # This would always fail, NSStrings get a new proxy everytime
        # they cross the bridge, otherwise it would be unnecessarily hard
        # to get at the current value of NSMutableStrings.

        container = OC_TestIdentity.alloc().init()

        cls = objc.lookUpClass("NSObject")
        container.setStoredObjectToResultOf_on_("description", cls)
        self.assertFetchingTwice(container, "string")

        cls = objc.lookUpClass("NSMutableString")
        container.setStoredObjectToResultOf_on_("new", cls)
        self.assertFetchingTwice(container, "mutable string")
예제 #29
0
def notify(title, subtitle=None):
    """Display a NSUserNotification on Mac OS X >= 10.8"""
    NSUserNotification = objc.lookUpClass('NSUserNotification')
    NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
    if not NSUserNotification or not NSUserNotificationCenter:
        return

    notification = NSUserNotification.alloc().init()
    notification.setTitle_(str(title))
    if subtitle:
        notification.setSubtitle_(str(subtitle))

    notification_center = NSUserNotificationCenter.defaultUserNotificationCenter()
    notification_center.deliverNotification_(notification)
예제 #30
0
    def testTollFree(self):
        obj = OC_TestCoreFoundation.today()

        self.assert_( CFDateRef, objc.lookUpClass("NSDate") ) 
        self.assert_( isinstance(obj, CFDateRef) )

        v = OC_TestCoreFoundation.formatDate_(obj)
        self.assert_( isinstance(v, unicode) )

        formatter = objc.lookUpClass("NSDateFormatter").new()
        formatter.setDateStyle_(OC_TestCoreFoundation.shortStyle())
        formatter.setTimeStyle_(OC_TestCoreFoundation.shortStyle())
        formatter.setLocale_(objc.lookUpClass("NSLocale").currentLocale())
        v2 = formatter.stringForObjectValue_(obj)
예제 #31
0
 def testNSDecimalNumber(self):
     container = OC_TestIdentity.alloc().init()
     cls = objc.lookUpClass("NSDecimalNumber")
     container.setStoredObjectToResultOf_on_("zero", cls)
     v = container.storedObject()
     self.assertTrue(container.isSameObjectAsStored_(v), repr(v))
예제 #32
0
import Foundation
import objc
import AppKit
import sys

NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')


def notify(title, subtitle, info_text, delay=0, sound=False, userInfo={}):
    notification = NSUserNotification.alloc().init()
    notification.setTitle_(title)
    notification.setSubtitle_(subtitle)
    notification.setInformativeText_(info_text)
    notification.setUserInfo_(userInfo)
    if sound:
        notification.setSoundName_("NSUserNotificationDefaultSoundName")
    notification.setDeliveryDate_(
        Foundation.NSDate.dateWithTimeInterval_sinceDate_(
            delay, Foundation.NSDate.date()))
    NSUserNotificationCenter.defaultUserNotificationCenter(
    ).scheduleNotification_(notification)


notify("homebrew", "update", "update your f*****g things")
sys.stdout.write("Notification sent...\n")
예제 #33
0
import objc
from PyObjCTools.TestSupport import TestCase, main

# try:
#    from  Foundation import NSRange
#
#    _C_NSRange = NSRange.__typestr__
#
# except ImportError:
if 1:
    if sys.maxsize > 2**32:
        _C_NSRange = b"{_NSRange=QQ}"
    else:
        _C_NSRange = b"{_NSRange=II}"

NSObject = objc.lookUpClass("NSObject")


class TestBasicDescriptors(TestCase):

    # IBOutlet is tested in test_ivar

    def test_ibaction(self):
        @objc.IBAction
        def myAction_(self, sender):
            return 1

        self.assertIsInstance(myAction_, objc.selector)
        self.assertEqual(myAction_.signature, b"v@:@")
        self.assertEqual(myAction_.selector, b"myAction:")
        self.assertFalse(myAction_.isClassMethod)
예제 #34
0
from PyObjCTools.TestSupport import *
import objc
import sys

# Most useful systems will at least have 'NSObject'.
#NSObject = objc.lookUpClass('NSObject')

# Use a class that isn't used in the rest of the testsuite,
# should write a native class for this! NSPortCoder
BaseName = 'NSPortCoder'
BaseClass = objc.lookUpClass(BaseName)

if sys.maxint >= 2 ** 32:
    # -poseAsClass: is not supported in 64-bit mode (the functionality is 
    # not present in the 64-bit runtime and will never be because it 
    # conflicts with new functionality such as non-fragile class layouts)
    pass

else:
    class TestPosing(TestCase):
        def testPosing(self):

            class PoseClass(BaseClass):
                __slots__ = ()  # Don't add instance variables, not even __dict__
                def testPosingMethod(self):
                    return u"<PoseClass instance>"


            PoseClass.poseAsClass_(BaseClass)

            # BaseClass still refers to the old class, if we look it up again
예제 #35
0
import objc
from PyObjCTools.TestSupport import *

NSObject = objc.lookUpClass('NSObject')


class TestBasicIMP(TestCase):
    # Test the basic functionality of IMP's. Imp's are basically unbound
    # selectors if you look at the interface. The implementation refers to
    # the actual functions that implements the method for calling the IMP
    # instead of passing through the usual message sending machinery.
    #
    def testIMPType(self):
        self.assertHasAttr(objc, "IMP")

    def testAlloc(self):
        cls = NSObject
        m = cls.pyobjc_classMethods.methodForSelector_("alloc")
        self.assertIsInstance(m, objc.IMP)
        self.assertTrue(m.__metadata__()['classmethod'])
        self.assertEqual(
            m.__metadata__()['retval']['already_retained'],
            cls.alloc.__metadata__()['retval']['already_retained'])
        self.assertEqual(m.selector, b'alloc')

        o = m(cls).init()
        self.assertIsInstance(o, cls)

    def testInit1(self):
        cls = NSObject
        m = cls.instanceMethodForSelector_("init")
예제 #36
0
import objc
LineNumberNSRulerView = objc.lookUpClass("GSLineNumberView")
'''

from Foundation import NSInvocation, NSString, NSMakeRange, NSMaxRange, NSLocationInRange, NSNotFound, NSMakeRect, NSMinY, NSWidth, NSHeight
from AppKit import NSRulerView, NSMiniControlSize, NSTextView, NSNotificationCenter, \
    NSFontAttributeName, NSForegroundColorAttributeName, NSTextStorageDidProcessEditingNotification, \
    NSFont, NSColor, NSBezierPath, NSRectFill
import math
from objc import super


"""
Based/translated from NoodleLineNumberView
http://www.noodlesoft.com/blog/2008/10/05/displaying-line-numbers-with-nstextview/
"""


class LineNumberNSRulerView(NSRulerView):

    DEFAULT_THICKNESS = 22.
    RULER_MARGIN = 5.

    def init(self):
        self = super(LineNumberNSRulerView, self).init()
        self._font = NSFont.labelFontOfSize_(NSFont.systemFontSizeForControlSize_(NSMiniControlSize))
        self._textColor = NSColor.colorWithCalibratedWhite_alpha_(.42, 1)
        self._rulerBackgroundColor = None

        self._lineIndices = None
        return self
예제 #37
0
"""
Test locking objects and interaction with @synchronized() statements

These tests take an annoyingly long time to ensure that we'd hit a race condition when
locking doesn't actually lock. It should be possible to find a faster mechanism for this.
"""
import threading
import time

import objc
from PyObjCTest.locking import OC_LockTest
from PyObjCTools.TestSupport import TestCase, main

NSAutoreleasePool = objc.lookUpClass("NSAutoreleasePool")


class OtherThread(threading.Thread):
    def __init__(self, obj):
        self.obj = obj

        threading.Thread.__init__(self)

    def run(self):
        pool = NSAutoreleasePool.alloc().init()

        lck = objc.object_lock(self.obj)

        for i in range(6):
            time.sleep(0.05)
            lck.lock()
            if self.obj.isLocked():
예제 #38
0
파일: build.py 프로젝트: xiaoshayun2/python
DefaultProjectDir = "/Users/virgil/Documents/Epub1/epub.xcodeproj"

#ipa 文件输出的文件夹
OutPutDir = "/Users/virgil/Documents/Archive/"

#FTP 设置
FTPServer = "10.38.178.77"
Port = "21"
UploadDir ="/Fred/"

IPA_Extentsion = ".ipa"
ProjectExtentsion =".xcodeproj"
ProjectFileName = "project.pbxproj"
BuildReleaseDir = "build/Release-iphoneos/"

NSUserNotification = objc.lookUpClass('NSUserNotification')
NSUserNotificationCenter = objc.lookUpClass('NSUserNotificationCenter')
NSDictionary = objc.lookUpClass('NSDictionary')
NSPasteboard = objc.lookUpClass('NSPasteboard')

def notify(title, subtitle, info_text, delay=0, sound=False, userInfo={}):
  """ Python method to show a desktop notification on Mountain Lion. Where:
        title: Title of notification
        subtitle: Subtitle of notification
        info_text: Informative text of notification
        delay: Delay (in seconds) before showing the notification
        sound: Play the default notification sound
        userInfo: a dictionary that can be used to handle clicks in your
                  app's applicationDidFinishLaunching:aNotification method
  """
  notification = NSUserNotification.alloc().init()
예제 #39
0
import objc
from PyObjCTest.testbndl import OC_TestClass2
from PyObjCTools.TestSupport import TestCase, main

from collections import UserDict as IterableUserDict, UserList
import collections.abc

NSMutableArray = objc.lookUpClass("NSMutableArray")
NSMutableDictionary = objc.lookUpClass("NSMutableDictionary")


def classOfProxy(value):
    return OC_TestClass2.classOfObject_(value)


class TestBridges(TestCase):
    # NOTE: the two "register" functions from objc._bridges aren't
    # tested explictly, but the tests in this class do verify that
    # the default registrations (which are made through those two
    # functions) work properly.

    def test_range(self):
        v = range(0, 10)
        self.assertIsSubclass(classOfProxy(v), NSMutableArray)

    def test_user_collections(self):
        # Note: Not "UserDict" because UserDict doesn't implement
        # __iter__ and hence isn't a collections.abc.Mapping, and doesn't
        # implement enough API to implement the NSDictionary interface.
        v = IterableUserDict()
        self.assertIsSubclass(classOfProxy(v), NSMutableDictionary)
예제 #40
0
        class Number(objc.lookUpClass("NSObject")):
            def objCType(self):
                return objc._C_INT

            def longValue(self):
                return 42
예제 #41
0
NOTE: Decimal conversion is not tested, the required proxy is part of
the Foundation bindings :-(
"""
from __future__ import unicode_literals
import sys, os
from PyObjCTools.TestSupport import *
from PyObjCTest.fnd import NSNumber, NSNumberFormatter
from PyObjCTest.pythonnumber import OC_TestNumber
import objc

if sys.version_info[0] == 3:
    unicode = str
    long = int

OC_PythonNumber = objc.lookUpClass("OC_PythonNumber")
try:
    NSCFNumber = objc.lookUpClass("__NSCFNumber")
except objc.error:
    NSCFNumber = objc.lookUpClass("NSCFNumber")

NSOrderedAscending = -1
NSOrderedSame = 0
NSOrderedDescending = 1


class TestNSNumber(TestCase):
    # These testcases check the behaviour of NSNumber, these
    # are mostly here to verify that NSNumbers behave as
    # we expect them to.
예제 #42
0
 def getDate(querydate):
     DCMCalendarDate = objc.lookUpClass("DCMCalendarDate")
     return DCMCalendarDate.queryDate_(querydate)
예제 #43
0
"""
Minimal tests for sequence proxies

NOTE: this file is very, very incomplete and just tests copying at the moment.
"""
import sys
from PyObjCTools.TestSupport import *
from PyObjCTest.fnd import NSArray, NSMutableArray, NSPredicate, NSObject, NSNull
from PyObjCTest.pythonset import OC_TestSet
import objc

OC_PythonArray = objc.lookUpClass("OC_PythonArray")
OC_BuiltinPythonArray = objc.lookUpClass("OC_BuiltinPythonArray")


class BasicSequenceTests:
    # Tests for sets that don't try to mutate the set.
    # Shared between tests for set() and frozenset()
    seqClass = None

    def testProxyClass(self):
        # Ensure that the right class is used to proxy sets
        self.assertIs(OC_TestSet.classOf_(self.seqClass()), OC_BuiltinPythonArray)

    def testMutableCopy(self):

        s = self.seqClass(range(20))
        o = OC_TestSet.set_mutableCopyWithZone_(s, None)
        self.assertEqual(list(s), o)
        self.assertIsNot(s, o)
        self.assertIsInstance(o, list)
예제 #44
0
def CFSTR(strval):
    return _objc.lookUpClass('NSString').stringWithString_(strval)
예제 #45
0
from PyObjCTools.TestSupport import *
import objc

NSObject = objc.lookUpClass("NSObject")
NSSortDescriptor = objc.lookUpClass("NSSortDescriptor")

objc.registerMetaDataForSelector(b"NSObject", b"selector",
                                 dict(retval=dict(type=objc._C_VOID)))


class MetadataInheritanceHelper(NSObject):
    def selector(self):
        return 1


class TestMetadataInheritance(TestCase):

    # These tests that PyObjC's signatures overrides don't
    # kick in when the new signature is incompatible with
    # the native signature.
    def testPythonMeta(self):
        o = MetadataInheritanceHelper.alloc().init()
        self.assertResultHasType(o.selector, objc._C_VOID)

    def testObjCMeta(self):
        o = NSSortDescriptor.alloc().init()
        self.assertResultHasType(o.selector, objc._C_SEL)


if __name__ == "__main__":
    main()
예제 #46
0
import copy

import objc
from PyObjCTest.copying import OC_CopyBase, OC_CopyHelper
from PyObjCTools.TestSupport import TestCase, main

NSObject = objc.lookUpClass("NSObject")
NSAutoreleasePool = objc.lookUpClass("NSAutoreleasePool")


def funcattr(**kwds):
    def annotate(func):
        for k, v in kwds.items():
            setattr(func, k, v)
        return func

    return annotate


class OC_TestCopy1(NSObject):
    def init(self):
        self = objc.super(OC_TestCopy1, self).init()
        if self is not None:
            self.x = 1
            self.y = 2
        return self

    def modify(self):
        self.x = 42
        self.y = 24
        self.z = 0
예제 #47
0
        class TestSpecialProperty(objc.lookUpClass("NSObject")):
            myprop = specialproperty()

            self.assertEqual(myprop.name, None)
예제 #48
0
class BlocksCompletion(objc.lookUpClass("NSObject")):
    def callWithCompletion_(self, completion):
        completion("hello")
        completion("world")
예제 #49
0
from AppKit import NSRunAlertPanel, NSAlternateKeyMask, NSEvent, NSKeyDown, NSFlagsChanged, NSControlKeyMask, MessageViewer
from Foundation import NSLog
from quotefix.utils import swizzle
from quotefix.attribution import CustomizedAttribution
from quotefix.messagetypes import *
from objc import Category, lookUpClass
from logger import logger
import re, traceback, objc

MailApp = lookUpClass('MailApp')


class MailApp(Category(MailApp)):
    @classmethod
    def registerQuoteFixApplication(cls, app):
        cls.app = app

    @swizzle(MailApp, 'sendEvent:')
    def sendEvent(self, original, event):
        if not hasattr(self, 'app'):
            original(self, event)
            return

        # Keep track of an active Opt key
        if event.type() == NSFlagsChanged:
            flags = event.modifierFlags()
            self.app.toggle_key_active = (
                flags & NSAlternateKeyMask) and not (flags & NSControlKeyMask)

        # Handle reply/reply-all (XXX: won't work if you have assigned a different shortcut key to these actions)
        if self.app.toggle_key_active and event.type(
예제 #50
0
        def testObject(self):
            container = OC_TestIdentity.alloc().init()

            cls = objc.lookUpClass("Object")
            container.setStoredObjectAnInstanceOfClassic_(cls)
            self.assertFetchingTwice(container, "object")
예제 #51
0
__all__ = ('object_property', 'bool_property', 'array_property',
           'set_property', 'dict_property')

from objc import ivar, selector, _C_ID, _C_NSBOOL, _C_BOOL, NULL, _C_NSUInteger
from objc import lookUpClass
import collections
from copy import copy as copy_func
import sys

NSSet = lookUpClass('NSSet')
NSObject = lookUpClass('NSObject')

if sys.version_info[0] == 2:  # pragma: no 3.x cover
    range = xrange

    def _str(value):
        return value

else:  # pragma: no 2.x cover
    long = int

    def _str(value):
        return value.decode('ascii')


def attrsetter(prop, name, copy):
    if copy:

        def func(self, value):
            if isinstance(value, NSObject):
                setattr(self, name, value.copy())
예제 #52
0
from PyObjCTools.TestSupport import *
from test import list_tests, seq_tests
import objc
import sys
import operator

# Import some of the stdlib tests
from test import mapping_tests

NSArray = objc.lookUpClass('NSArray')
NSMutableArray = objc.lookUpClass('NSMutableArray')


class ArrayTests(seq_tests.CommonTest):
    type2test = NSArray

    def test_from_iterator(self):
        a = NSArray(i for i in range(5))
        self.assertEqual(a, NSArray([0, 1, 2, 3, 4]))

    def test_pyobjc_copy(self):
        a = NSArray()
        b = a.copy()
        self.assertEqual(a, b)
        self.assertIsInstance(b, NSArray)

        a = NSArray([0])
        b = a.copy()
        self.assertEqual(a, b)
        self.assertIsInstance(b, NSArray)
예제 #53
0
 def lookUpClass(name):
     try:
         return objc.lookUpClass(name)
     except objc.nosuchclass_error:
         return None
예제 #54
0
See the Cocoa documentation on the Apple developer website for more
information on Key-Value coding. The protocol is basicly used to enable
weaker coupling between the view and model layers.
"""

__all__ = ("getKey", "setKey", "getKeyPath", "setKeyPath")

import objc
import types
from itertools import imap
try:
    set
except NameError:
    from sets import Set as set

if objc.lookUpClass('NSObject').alloc().init().respondsToSelector_(
        'setValue:forKey:'):
    SETVALUEFORKEY = 'setValue_forKey_'
    SETVALUEFORKEYPATH = 'setValue_forKeyPath_'
else:
    SETVALUEFORKEY = 'takeValue_forKey_'
    SETVALUEFORKEYPATH = 'takeValue_forKeyPath_'


def keyCaps(s):
    return s[:1].capitalize() + s[1:]


# From http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/393090
# Title: Binary floating point summation accurate to full precision
# Version no: 2.2
예제 #55
0
    def testFunctions(self):
        self.assertResultIsCFRetained(AddressBook.ABPickerCreate)

        ref = AddressBook.ABPickerCreate()

        try:
            self.assertIsInstance(
                ref,
                (AddressBook.ABPickerRef,
                 objc.lookUpClass("ABPeoplePickerCAdapter")),
            )

        except objc.error:
            self.assertIsInstance(ref, AddressBook.ABPickerRef)

        AddressBook.ABPickerSetFrame(ref, ((90, 100), (200, 400)))
        r = AddressBook.ABPickerGetFrame(ref, None)
        self.assertIsInstance(r, AddressBook.NSRect)
        self.assertEqual(r, ((90, 100), (200, 400)))

        self.assertResultHasType(AddressBook.ABPickerIsVisible, objc._C_BOOL)
        r = AddressBook.ABPickerIsVisible(ref)
        self.assertIsInstance(r, bool)
        self.assertTrue(r is False)

        self.assertArgHasType(AddressBook.ABPickerSetVisibility, 1,
                              objc._C_BOOL)
        AddressBook.ABPickerSetVisibility(ref, True)

        r = AddressBook.ABPickerIsVisible(ref)
        self.assertTrue(r is True)

        AddressBook.ABPickerSetVisibility(ref, False)

        r = AddressBook.ABPickerIsVisible(ref)
        self.assertTrue(r is False)

        r = AddressBook.ABPickerGetAttributes(ref)
        self.assertIsInstance(r, int)

        r = AddressBook.ABPickerChangeAttributes(
            ref, AddressBook.kABPickerAllowMultipleSelection, 0)
        self.assertTrue(r is None)

        AddressBook.ABPickerAddProperty(ref, AddressBook.kABFirstNameProperty)
        AddressBook.ABPickerAddProperty(ref, AddressBook.kABLastNameProperty)
        AddressBook.ABPickerRemoveProperty(ref,
                                           AddressBook.kABFirstNameProperty)

        v = AddressBook.ABPickerCopyProperties(ref)
        self.assertIsInstance(v, AddressBook.NSArray)

        # Disable detailed testing, the RemoveProperties function
        # doesn't actually remove. See radar #7999195.
        # self.assertEqual(tuple(v), (AddressBook.kABLastNameProperty,))

        AddressBook.ABPickerSetColumnTitle(ref, "Achternaam",
                                           AddressBook.kABLastNameProperty)
        v = AddressBook.ABPickerCopyColumnTitle(
            ref, AddressBook.kABLastNameProperty)
        self.assertResultIsCFRetained(AddressBook.ABPickerCopyColumnTitle)
        self.assertEqual(v, "Achternaam")

        AddressBook.ABPickerSetDisplayedProperty(
            ref, AddressBook.kABLastNameProperty)
        v = AddressBook.ABPickerCopyDisplayedProperty(ref)
        self.assertResultIsCFRetained(
            AddressBook.ABPickerCopyDisplayedProperty)
        self.assertIsInstance(v, str)

        v = AddressBook.ABPickerCopySelectedGroups(ref)
        self.assertIsInstance(v, AddressBook.NSArray)

        v = AddressBook.ABPickerCopySelectedRecords(ref)
        self.assertIsInstance(v, AddressBook.NSArray)

        v = AddressBook.ABPickerCopySelectedIdentifiers(
            ref, AddressBook.ABGetMe(AddressBook.ABGetSharedAddressBook()))
        if v is not None:
            self.assertIsInstance(v, AddressBook.NSArray)

        v = AddressBook.ABPickerCopySelectedValues(ref)
        self.assertIsInstance(v, AddressBook.NSArray)

        grp = AddressBook.ABCopyArrayOfAllGroups(
            AddressBook.ABGetSharedAddressBook())[0]
        usr = AddressBook.ABGetMe(AddressBook.ABGetSharedAddressBook())

        AddressBook.ABPickerSelectGroup(ref, grp, True)
        self.assertArgHasType(AddressBook.ABPickerSelectGroup, 2, objc._C_BOOL)

        AddressBook.ABPickerSelectRecord(ref, usr, False)
        self.assertArgHasType(AddressBook.ABPickerSelectRecord, 2,
                              objc._C_BOOL)

        AddressBook.ABPickerSelectIdentifier(
            ref, usr, "Last",
            False)  # AddressBook.ABRecordCopyUniqueId(usr), False)
        self.assertArgHasType(AddressBook.ABPickerSelectIdentifier, 3,
                              objc._C_BOOL)

        AddressBook.ABPickerDeselectIdentifier(ref, usr, "Last")

        AddressBook.ABPickerDeselectGroup(ref, grp)
        AddressBook.ABPickerDeselectRecord(ref, usr)

        AddressBook.ABPickerDeselectAll(ref)

        AddressBook.ABPickerClearSearchField(ref)

        if 0:
            # These are annoying, don't actually call
            AddressBook.ABPickerEditInAddressBook(ref)
            AddressBook.ABPickerSelectInAddressBook(ref)
        else:
            AddressBook.self.assertResultHasType(
                AddressBook.ABPickerEditInAddressBook, objc._C_VOID)
            AddressBook.self.assertResultHasType(
                AddressBook.ABPickerSelectInAddressBook, objc._C_VOID)

        r = AddressBook.ABPickerGetDelegate(ref)

        AddressBook.ABPickerSetDelegate
예제 #56
0
    def decorator(func):
        old_IMP = cls.instanceMethodForSelector_(SEL)

        def wrapper(self, *args, **kwargs):
            return func(self, old_IMP, *args, **kwargs)

        new_IMP = objc.selector(wrapper,
                                selector=old_IMP.selector,
                                signature=old_IMP.signature)
        objc.classAddMethod(cls, SEL, new_IMP)
        return wrapper

    return decorator


@swizzle(objc.lookUpClass('NSBundle'), b'bundleIdentifier')
def swizzled_bundleIdentifier(self, original):
    """Swizzle [NSBundle bundleIdentifier] to make NSUserNotifications
    work.

    To post NSUserNotifications OS X requires the binary to be packaged
    as an application bundle. To circumvent this restriction, as it would
    be difficult (impossible?) to implement in an Alfred Extension,
    we modify `bundleIdentifier` to return a fake bundle identifier.

    Original idea for this approach by Norio Numura:
        https://github.com/norio-nomura/usernotification
    """
    # Return Alfred's bundle identifier to display the Alfred.app logo.
    if 'Alfred 2' in os.getcwd():
        return 'com.runningwithcrayons.Alfred-2'
예제 #57
0
from PyObjCTools.TestSupport import *
import objc
import sys

NSObject = objc.lookUpClass("NSObject")
# _NSZombie = objc.lookUpClass('_NSZombie')
NSProxy = objc.lookUpClass("NSProxy")


class MethodAccessTest(TestCase):
    def testObjCObject(self):
        # Trying to access the methods of objc.objc_object should not
        # crash the interpreter.
        self.assertRaises(AttributeError, getattr,
                          objc.objc_object.pyobjc_classMethods, "func_code")
        self.assertRaises(
            AttributeError,
            getattr,
            objc.objc_object.pyobjc_instanceMethods,
            "func_code",
        )

    def testNSProxyStuff(self):
        # NSProxy is incompatitble with pyobjc_{class,instance}Methods, but
        # this should not crash the interpreter
        self.assertRaises(AttributeError, getattr,
                          NSProxy.pyobjc_instanceMethods, "foobar")
        self.assertRaises(AttributeError, getattr, NSProxy.pyobjc_classMethods,
                          "foobar")
        self.assertRaises(AttributeError, getattr, NSProxy, "foobar")
예제 #58
0
Tests for the proxy of Python sets
"""
import sys
from PyObjCTools.TestSupport import *
from PyObjCTest.fnd import NSSet, NSMutableSet, NSPredicate, NSObject, NSNull
from PyObjCTest.pythonset import OC_TestSet
import objc

import os

if sys.version_info[0] == 3:
    unicode = str

onLeopard = int(os.uname()[2].split('.')[0]) >= 9

OC_PythonSet = objc.lookUpClass("OC_PythonSet")
OC_BuiltinPythonSet = objc.lookUpClass("OC_BuiltinPythonSet")


class OC_SetPredicate(NSPredicate):
    # A simple test predicate class
    def initWithFunction_(self, pred):
        self = objc.super(OC_SetPredicate, self).init()
        if self is None:
            return None

        self.pred = pred
        return self

    def evaluateWithObject_(self, object):
        return self.pred(object)
예제 #59
0
    def testNSDecimalNumber(self):
        container = OC_TestIdentity.alloc().init()

        cls = objc.lookUpClass("NSDecimalNumber")
        container.setStoredObjectToResultOf_on_("zero", cls)
        self.assertFetchingTwice(container, "decimal")
예제 #60
0
"""
Tests if NSSet conforms to the interface of the python type set()

This is a port of the set tests from the Python stdlib for 3.2
"""
import collections.abc
import operator
import test.test_set
from test.test_set import PassThru, check_pass_thru

import objc
from PyObjCTools.TestSupport import TestCase, onlyIf

NSSet = objc.lookUpClass("NSSet")
NSMutableSet = objc.lookUpClass("NSMutableSet")


test.test_set.empty_set = NSMutableSet()


class TestPyObjCSet(TestCase):
    def test_reverse_operator(self):
        class MySet(collections.abc.Set):
            def __init__(self, init=()):
                self._value = list(init)

            def __iter__(self):
                return iter(self._value)

            def __contains__(self, value):
                return value in self._value