def example1():

    "creation of a new file using manual, step-by-step procedure"
    
    f = new()
    own = makeOwner(f,"Yorik van Havre")
    plac = makePlacement(f)
    grep = makeContext(f,plac)
    proj = makeProject(f,grep,own)
    site = makeSite(f,proj,own)
    bldg = makeBuilding(f,site,own)
    stor = makeStorey(f,bldg,own)
    poly = makePolyline(f,[(0,0,0),(0,200,0),(5000,200,0),(5000,0,0),(0,0,0)])
    solid = makeExtrusion(f,poly,(0,0,3500))
    wall = makeWall(f,stor,own,grep,solid)
    poly2 = makePolyline(f,[(0,200,0),(0,2000,0),(200,2000,0),(200,200,0),(0,200,0)])
    solid2 = makeExtrusion(f,poly2,(0,0,3500))
    wall2 = makeWall(f,stor,own,grep,solid2)
    poly3 = makePolyline(f,[(0,2000,0),(0,2200,0),(5000,2200,0),(5000,2000,0),(0,2000,0)])
    solid3 = makeExtrusion(f,poly3,(0,0,3500))
    wall3 = makeWall(f,stor,own,grep,solid3)
    poly4 = makePolyline(f,[(5000,200,0),(5000,2000,0),(4800,2000,0),(4800,200,0),(5000,200,0)])
    solid4 = makeExtrusion(f,poly4,(0,0,3500))
    wall4 = makeWall(f,stor,own,grep,solid4)
    relate(f,stor,own,[wall,wall2,wall3,wall4])
    f.write("/home/yorik/test1.ifc")
    
    print dir(f)
    print f.by_type("IfcWallStandardCase")
    w = f.by_type("IfcWallStandardCase")[0]
    print w
    print dir(w)
    print w.is_a("IfcWallStandardCase")
    def test_frozen(self):
        with captured_stdout() as stdout:
            try:
                import __hello__
            except ImportError as x:
                self.fail("import __hello__ failed:" + str(x))
            self.assertEqual(__hello__.initialized, True)
            expect = set(self.module_attrs)
            expect.add('initialized')
            self.assertEqual(set(dir(__hello__)), expect)
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        with captured_stdout() as stdout:
            try:
                import __phello__
            except ImportError as x:
                self.fail("import __phello__ failed:" + str(x))
            self.assertEqual(__phello__.initialized, True)
            expect = set(self.package_attrs)
            expect.add('initialized')
            if not "__phello__.spam" in sys.modules:
                self.assertEqual(set(dir(__phello__)), expect)
            else:
                expect.add('spam')
                self.assertEqual(set(dir(__phello__)), expect)
            self.assertEqual(__phello__.__path__, [__phello__.__name__])
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        with captured_stdout() as stdout:
            try:
                import __phello__.spam
            except ImportError as x:
                self.fail("import __phello__.spam failed:" + str(x))
            self.assertEqual(__phello__.spam.initialized, True)
            spam_expect = set(self.module_attrs)
            spam_expect.add('initialized')
            self.assertEqual(set(dir(__phello__.spam)), spam_expect)
            phello_expect = set(self.package_attrs)
            phello_expect.add('initialized')
            phello_expect.add('spam')
            self.assertEqual(set(dir(__phello__)), phello_expect)
            self.assertEqual(stdout.getvalue(), 'Hello world!\n')

        try:
            import __phello__.foo
        except ImportError:
            pass
        else:
            self.fail("import __phello__.foo should have failed")

            try:
                import __phello__.foo
            except ImportError:
                pass
            else:
                self.fail("import __phello__.foo should have failed")

        del sys.modules['__hello__']
        del sys.modules['__phello__']
        del sys.modules['__phello__.spam']
Beispiel #3
0
    def __init__(self, fn="depthFirstSearch", prob="PositionSearchProblem", heuristic="nullHeuristic"):
        # Warning: some advanced Python magic is employed below to find the right functions and problems

        # Get the search function from the name and heuristic
        if fn not in dir(search):
            raise AttributeError, fn + " is not a search function in search.py."
        func = getattr(search, fn)
        if "heuristic" not in func.func_code.co_varnames:
            print ("[SearchAgent] using function " + fn)
            self.searchFunction = func
        else:
            if heuristic in dir(searchAgents):
                heur = getattr(searchAgents, heuristic)
            elif heuristic in dir(search):
                heur = getattr(search, heuristic)
            else:
                raise AttributeError, heuristic + " is not a function in searchAgents.py or search.py."
            print ("[SearchAgent] using function %s and heuristic %s" % (fn, heuristic))
            # Note: this bit of Python trickery combines the search algorithm and the heuristic
            self.searchFunction = lambda x: func(x, heuristic=heur)

        # Get the search problem type from the name
        if prob not in dir(searchAgents) or not prob.endswith("Problem"):
            raise AttributeError, prob + " is not a search problem type in SearchAgents.py."
        self.searchType = getattr(searchAgents, prob)
        print ("[SearchAgent] using problem type " + prob)
def example2():
    
    "creation of a new file using advanced IfcDocument object"
    
    ifc = IfcDocument("/home/yorik/test2.ifc")
    ifc.Name = "Test Project"
    ifc.Owner = "Yorik van Havre"
    ifc.Organization = "FreeCAD"
    w1 = ifc.addWall( ifc.addExtrudedPolyline([(0,0,0),(0,200,0),(5000,200,0),(5000,0,0),(0,0,0)], (0,0,3500)) )
    ifc.addWall( ifc.addExtrudedPolyline([(0,200,0),(0,2000,0),(200,2000,0),(200,200,0),(0,200,0)],(0,0,3500)) )
    ifc.addWall( ifc.addExtrudedPolyline([(0,2000,0),(0,2200,0),(5000,2200,0),(5000,2000,0),(0,2000,0)],(0,0,3500)) )
    ifc.addWall( ifc.addExtrudedPolyline([(5000,200,0),(5000,2000,0),(4800,2000,0),(4800,200,0),(5000,200,0)],(0,0,3500)) )
    ifc.addWall( ifc.addFacetedBrep([[[(0,0,0),(100,0,0),(100,-1000,0),(0,-1000,0)]],
                                    [[(0,0,0),(100,0,0),(100,0,1000),(0,0,1000)]],
                                    [[(0,0,0),(0,0,1000),(0,-1000,1000),(0,-1000,0)]],
                                    [[(0,-1000,0),(0,-1000,1000),(100,-1000,1000),(100,-1000,0)]],
                                    [[(100,-1000,0),(100,-1000,1000),(100,0,1000),(100,0,0)]],
                                    [[(0,0,1000),(0,-1000,1000),(100,-1000,1000),(100,0,1000)]]]) )
    ifc.addStructure( "IfcColumn", ifc.addExtrudedPolyline([(0,0,0),(0,-200,0),(-500,-200,0),(-500,0,0),(0,0,0)], (0,0,3500)) )
    ifc.addWindow( "IfcDoor", 200, 200, ifc.addExtrudedPolyline([(200,200,0),(200,400,0),(400,400,0),(400,200,0),(200,200,0)], (0,0,200)), w1 )
    ifc.write()
    
    print dir(ifc._fileobject)
    print ifc._fileobject.by_type("IfcDoor")
    w = ifc._fileobject.by_type("IfcDoor")[0]
    print w
    print dir(w)
    print w.is_a("IfcDoor")
    for i in range(w.get_argument_count()):
        print i,": ",w.get_argument_name(i)," : ",w.get_argument(i)
Beispiel #5
0
    def expose(self, name, new_name=None, position=-1):
        """Expose an attribute from a filter of the minipeline.

        Once called, the pipeline instance has a new Set/Get set of methods to
        access directly the corresponding method of one of the filter of the
        pipeline.
        Ex: p.expose( "Radius" )
                p.SetRadius( 5 )
                p.GetRadius( 5 )
        By default, the attribute usable on the pipeline instance has the same
        name than the one of the filter, but it can be changed by providing a
        value to new_name.
        The last filter of the pipeline is used by default, but another one may
        be used by giving its position.
        Ex: p.expose("Radius", "SmoothingNeighborhood", 2)
            p.GetSmoothingNeighborhood()
        """
        if new_name is None:
            new_name = name
        src = self.filters[position]
        ok = False
        set_name = "Set" + name
        if set_name in dir(src):
            setattr(self, "Set" + new_name, getattr(src, set_name))
            ok = True
        get_name = "Get" + name
        if get_name in dir(src):
            setattr(self, "Get" + new_name, getattr(src, get_name))
            ok = True
        if not ok:
            raise RuntimeError(
                "No attribute %s at position %s." %
                (name, position))
def obTex(ob, active, context):
    if 'texspace_location' in dir(ob.data) and 'texspace_location' in dir(
       active.data):
        ob.data.texspace_location[:] = active.data.texspace_location[:]
    if 'texspace_size' in dir(ob.data) and 'texspace_size' in dir(active.data):
        ob.data.texspace_size[:] = active.data.texspace_size[:]
    return('INFO', "texture space copied")
    def __init__(self, fn='depthFirstSearch', prob='PositionSearchProblem', heuristic='nullHeuristic'):
        # Warning: some advanced Python magic is employed below to find the right functions and problems

        # Get the search function from the name and heuristic
        if fn not in dir(search):
            raise AttributeError, fn + ' is not a search function in search.py.'
        func = getattr(search, fn)
        if 'heuristic' not in func.func_code.co_varnames:
            print('[SearchAgent] using function ' + fn)
            self.searchFunction = func
        else:
            if heuristic in globals().keys():
                heur = globals()[heuristic]
            elif heuristic in dir(search):
                heur = getattr(search, heuristic)
            else:
                raise AttributeError, heuristic + ' is not a function in searchAgents.py or search.py.'
            print('[SearchAgent] using function %s and heuristic %s' % (fn, heuristic))
            # Note: this bit of Python trickery combines the search algorithm and the heuristic
            self.searchFunction = lambda x: func(x, heuristic=heur)

        # Get the search problem type from the name
        if prob not in globals().keys() or not prob.endswith('Problem'):
            raise AttributeError, prob + ' is not a search problem type in SearchAgents.py.'
        self.searchType = globals()[prob]
        print('[SearchAgent] using problem type ' + prob)
Beispiel #8
0
def test_sftp_client(psftp):
    '''test for access to the underlying, active sftpclient'''
    # with pysftp.Connection(**SFTP_PUBLIC) as sftp:
    #     assert 'normalize' in dir(sftp.sftp_client)
    #     assert 'readlink' in dir(sftp.sftp_client)
    assert 'normalize' in dir(psftp.sftp_client)
    assert 'readlink' in dir(psftp.sftp_client)
def sciopero_scraper():
    """
    This function is used to generate the requests for URL containing data.
    It's a generator which returns always a sciopero dict, with at least its id.
    """
    min_id, max_id = find_id_range()
    #print max_id

    print 'scraping from %d to %d' % (min_id, max_id)

    for i in xrange(min_id, max_id):
        try:
            resp = requests.get(sciopero_prefix % str(i))
        except Exception as e:
            print type(e)
            print e
            print dir(e)
            exit()
        print "Sleeping for %s seconds (requests)" % (SLEEP_TIME or 0)
        time.sleep(SLEEP_TIME or 0)

        if resp.status_code == 500 or 'HTTP Status 500' in resp.text:
            continue
        
        #print '%s%s' % (sciopero_prefix, str(i))
        yield parse_sciopero(resp.content, i)
Beispiel #10
0
def show_depth():
    global threshold
    global current_depth

    depth, timestamp = freenect.sync_get_depth()
    depth = 255 * np.logical_and(depth >= current_depth - threshold, depth <= current_depth + threshold)
    depth = depth.astype(np.uint8)
    image = cv.CreateImageHeader((depth.shape[1], depth.shape[0]), cv.IPL_DEPTH_8U, 1)
    cv.SetData(image, depth.tostring(), depth.dtype.itemsize * depth.shape[1])
    cv.ShowImage("Depth", image)

    print "depth:", type(depth), dir(depth)
    print ""

    print "image:", type(image), dir(image)
    print ""

    x = cv.CreateMat(image.height, image.width, cv.IPL_DEPTH_8U)
    cv.Convert(image, x)

    smaller = cv.CreateMat(image.height / 10, image.width / 10, cv.IPL_DEPTH_8U)
    print "smaller:", type(smaller), dir(smaller)
    print ""

    cv.Resize(image, smaller)
    cv.ShowImage("Reduced", smaller)
Beispiel #11
0
  def test_strategies_names_introspection(self):
    sd = StrategyDict()
    sd.strategy("first", "abc")(lambda val: "abc" + val)
    sd.strategy("second", "def")(lambda val: "def" + val) # Neglect 2nd name
    sd.strategy("third", "123")(lambda val: "123" + val) # Neglect 2nd name

    # Nothing new here: strategies do what they should...
    assert sd("x") == "abcx"
    assert sd.default("p") == "abcp"

    assert sd.first("w") == "abcw" == sd["first"]("w")
    assert sd.second("zsc") == "defzsc" == sd["second"]("zsc")
    assert sd.third("blah") == "123blah" == sd["third"]("blah")

    assert sd.abc("y") == "abcy" == sd["abc"]("y")
    assert sd["def"]("few") == "deffew"
    assert sd["123"]("lots") == "123lots"

    # Valid names for attributes
    all_names = {"first", "second", "third", "abc", "def", "123"}
    assert all(name in dir(sd) for name in all_names)
    assert all(name in vars(sd) for name in all_names)
    assert "default" in dir(sd)
    assert "default" in vars(sd)
    all_keys_tuples = sd.keys()
    all_keys = reduce(operator.concat, all_keys_tuples)
    assert set(all_keys) == all_names # Default not in keys
    assert set(all_keys_tuples) == {("first", "abc"),
                                    ("second", "def"),
                                    ("third", "123")}

    # First name is the __name__
    assert sd["abc"].__name__ == "first"
    assert sd["def"].__name__ == "second"
    assert sd["123"].__name__ == "third"
def find_unit(quantity):
    """
    Return a list of matching units names.
    if quantity is a string -- units containing the string `quantity`
    if quantity is a unit -- units having matching base units

    Examples
    ========

    >>> from sympy.physics import units as u
    >>> u.find_unit('charge')
    ['charge']
    >>> u.find_unit(u.charge)
    ['C', 'charge', 'coulomb', 'coulombs']
    >>> u.find_unit('volt')
    ['volt', 'volts', 'voltage']
    >>> u.find_unit(u.inch**3)[:5]
    ['l', 'cl', 'dl', 'ml', 'liter']
    """
    import sympy.physics.units as u
    rv = []
    if isinstance(quantity, str):
        rv = [i for i in dir(u) if quantity in i]
    else:
        units = quantity.as_coeff_Mul()[1]
        for i in dir(u):
            try:
                if units == eval('u.' + i).as_coeff_Mul()[1]:
                    rv.append(str(i))
            except Exception:
                pass
    return sorted(rv, key=len)
Beispiel #13
0
def convert_dir( fill = None, dirname = '.', stroke = None, strokeWidth = None, dest = None):


    files = [ f for f in os.listdir(dirname) if f[-3:] == 'svg']
    print "{0} SVG Files: ".format(len(files))
    print '\n'.join(files)
                                 
    print "Converting fill to: {0}{1}{2}"\
        .format(fill,
                ", stroke to {0}".format(stroke) if stroke else '',
                ", strokeWidth to {0}".format(strokeWidth) if strokeWidth else '') 


    if dest == None:
        dest = ("{0}-fill{1}{2}"\
                .format(fill,
                        "-{0}-stroke".format(stroke) if stroke else '',
                        "-{0}-width".format(strokeWidth) if strokeWidth else '') )
    
    if not os.path.isdir(dest):
        os.mkdir(dest)

    for f in files:
        tree = svgparser.parse(os.path.join(dirname,f))
        elts = svgu.list_elements(tree)
        for e in elts:
            
            if 'set_fill' in dir(e) and fill:
                e.set_fill(fill)
            if 'set_stroke' in dir(e) and stroke:
                e.set_stroke(stroke)
            if 'set_stroke_width' in dir(e) and strokeWidth:
                e.set_stroke_width("{0}px".format(strokeWidth))
        out = os.path.join(dest, f)
        tree.save(out)
Beispiel #14
0
def profile(request, next=SNAP_PREFIX):
    '''
    Allow user to edit his/her profile.  Requires login.

    There are several newforms bugs that affect this.  See
        http://code.google.com/p/snapboard/issues/detail?id=7

    We'll use generic views to get around this for now.
    '''
    if COOKIE_SNAP_PROFILE_KEY in request.session:
        # reset any cookie variables
        request.session[COOKIE_SNAP_PROFILE_KEY] = {}
    
    try:
        userdata = SnapboardProfile.objects.get(user=request.user)
    except:
        userdata = SnapboardProfile(user=request.user)
        userdata.save()
    print dir(RequestContext(request).dicts)
    from django.views.generic.create_update import update_object
    return update_object(request,
            model=SnapboardProfile, object_id=userdata.id,
            template_name='snapboard/profile.html',
            post_save_redirect=next
            )
Beispiel #15
0
def get_config(config_path):
    __import__('errbot.config-template')  # - is on purpose, it should not be imported normally ;)
    template = sys.modules['errbot.config-template']
    config_fullpath = config_path
    if not path.exists(config_fullpath):
        log.error(
            'I cannot find the file %s \n'
            '(You can change this path with the -c parameter see --help)' % config_path
        )
        log.info(
            'You can use the template %s as a base and copy it to %s. \nYou can then customize it.' % (
                path.dirname(template.__file__) + sep + 'config-template.py', config_path + sep)
        )
        exit(-1)

    # noinspection PyBroadException
    try:
        config = __import__(path.splitext(path.basename(config_fullpath))[0])

        diffs = [item for item in set(dir(template)) - set(dir(config)) if not item.startswith('_')]
        if diffs:
            log.error('You are missing configs defined from the template :')
            for diff in diffs:
                log.error('Missing config : %s' % diff)
            exit(-1)
    except Exception as _:
        log.exception('I could not import your config from %s, please check the error below...' % config_fullpath)
        exit(-1)
    log.info('Config check passed...')
    return config
Beispiel #16
0
def test_dir():
    t = TableSymbol('t', '{name: string, amount: int, dt: datetime}')
    assert 'day' in dir(t.dt)
    assert 'mean' not in dir(t.dt)
    assert 'mean' in dir(t.amount)
    assert 'like' not in dir(t[['amount', 'dt']])
    assert 'any' not in dir(t.name)
Beispiel #17
0
 def test_usage(self):
     gen = (i for i in range(3))
     lazy_list = lazyutils.LazyKit(lambda: list(gen))
     self.assertEqual(next(gen), 0)
     self.assertEqual(lazy_list[1], 1)  # pylint: disable=unsubscriptable-object
     self.assertEqual(lazy_list[2], 2)  # pylint: disable=unsubscriptable-object
     self.assertSetEqual(set(dir([])) - set(dir(lazy_list)), set())
Beispiel #18
0
def main():
    """
    Create a client, parse the arguments received on the command line, and
    call the appropriate method on the client.
    """
    cli = DeisClient()
    args = docopt(__doc__, version='Deis CLI {}'.format(__version__),
                  options_first=True)
    cmd = args['<command>']
    cmd, help_flag = parse_args(cmd)
    # print help if it was asked for
    if help_flag:
        if cmd != 'help':
            if cmd in dir(cli):
                print trim(getattr(cli, cmd).__doc__)
                return
        docopt(__doc__, argv=['--help'])
    # re-parse docopt with the relevant docstring
    if cmd in dir(cli):
        docstring = trim(getattr(cli, cmd).__doc__)
        if 'Usage: ' in docstring:
            args.update(docopt(docstring))
    # find the method for dispatching
    if hasattr(cli, cmd):
        method = getattr(cli, cmd)
    else:
        raise DocoptExit('Found no matching command')
    # dispatch the CLI command
    try:
        method(args)
    except EnvironmentError:
        print 'Could not find git remote for deis'
        raise DocoptExit()
Beispiel #19
0
 def dir_only_shows_real_keys(self):
     "dir() only shows real keys-as-attrs, not aliases"
     a = Lexicon({'key1': 'val1', 'key2': 'val2'})
     a.alias('myalias', 'key1')
     assert 'key1' in dir(a)
     assert 'key2' in dir(a)
     assert 'myalias' not in dir(a)
Beispiel #20
0
def uniformCostSearch(problem):
    "Search the node of least total cost first. "
    "*** YOUR CODE HERE ***"
    
    closedSet           = set()
    dataStructure       = util.PriorityQueueWithFunction(lambda (path): problem.getCostOfActions(getListOfActions(path)))
    path                = []
    
    pathTuple = () 
    if "startState" in dir(problem):
        nodeCoordStartState = problem.startState
        pathTuple = ((nodeCoordStartState, "", 0), )
    elif "getStartState" in dir(problem):
        nodeCoordStartState = problem.getStartState()
        pathTuple = ((nodeCoordStartState, "", 0), )
    else:
        raise Exception("No recognizable function for getting the Start State")

    dataStructure.push(pathTuple)

    result = findSolution(problem, pathTuple, dataStructure, closedSet)
    
    if result is None:
        raise Exception("No solution exists!")
  
    path = getListOfActions(result)

    #print "[Final Path] [%s] with length %d" % (str(result), len(result))
    #print "Path: %s with length %d" % (str(path), len(path)) 
    return path 
Beispiel #21
0
def aStarSearch(problem, heuristic=nullHeuristic):
    closedSet           = set()
    dataStructure       = util.PriorityQueueWithFunction(getHeuristicFunction(problem, heuristic))
    path                = []
   
    pathTuple = () 
    if "startState" in dir(problem):
        nodeCoordStartState = problem.startState
        pathTuple = ((nodeCoordStartState, "", 0), )
    elif "getStartState" in dir(problem):
        nodeCoordStartState = problem.getStartState()
        pathTuple = ((nodeCoordStartState, "", 0), )
    else:
        raise Exception("No recognizable function for getting the Start State")

    dataStructure.push(pathTuple)

    result = findSolution(problem, pathTuple, dataStructure, closedSet)
    
    if result is None:
        raise Exception("No solution exists!")
  
    path = getListOfActions(result)

    #print "[Final Path] [%s] with length %d" % (str(result), len(result))
    #print "Path: %s with length %d" % (str(path), len(path)) 
    return path 
Beispiel #22
0
def prop(interpeter, stack, scopes, stream):
    val2, val1 = stack.pop().VAL, stack.pop().VAL

    if isinstance(val2, dict):
        if not val2 in val1.keys():
            interpeter.report_error(
                "OOP_ERROR",
                "propof",
                "Property not in object!")
    elif "__all__" in dir(val2):
        if not val2 in val1.__all__:
            interpeter.report_error(
                "OOP_ERROR",
                "propof",
                "Property not in object!")
    elif not val2 in dir(val1):
        interpeter.report_error(
            "OOP_ERROR",
            "propof",
            "Property not in object!")

    if isinstance(val1, types.ModuleType):
        value = val1.__dict__[val2]
    else:
        value = val1[val2]

    tok = interpeter.Token(TYPE='py-obj', VAL=value)
    stack.append(tok)
Beispiel #23
0
 def recommendCompletionsFor(self, word):
     parts = word.split('.')
     if len(parts) > 1:
         # has a . so it must be a module or class or something
         # using eval, which shouldn't normally have side effects
         # unless there's descriptors/metaclasses doing some nasty
         # get magic
         objname = '.'.join(parts[:-1])
         try:
             obj = eval(objname, self.locals)
         except:
             return None, 0
         wordlower = parts[-1].lower()
         if wordlower == '':
             # they just punched in a dot, so list all attributes
             # that don't look private or special
             prefix = '.'.join(parts[-2:])
             check = [
                 (prefix+_method)
                 for _method
                 in dir(obj)
                 if _method[:1] != '_' and _method.lower().startswith(wordlower)
             ]
         else:
             # they started typing the method name
             check = filter(lambda s:s.lower().startswith(wordlower), dir(obj))
     else:
         # no dots, must be in the normal namespaces.. no eval necessary
         check = sets.Set(dir(__builtins__))
         check.update(keyword.kwlist)
         check.update(self.locals)
         wordlower = parts[-1].lower()
         check = filter(lambda s:s.lower().startswith(wordlower), check)
     check.sort()
     return check, 0
    def testRecusiveNesting(self):
        l = []
        d = {1:l}
        i = a_classic_class()
        i.attr = d
        l.append(i)

        buf = self.archiverClass.archivedDataWithRootObject_(l)
        self.assertIsInstance(buf, NSData)
        v = self.unarchiverClass.unarchiveObjectWithData_(buf)

        self.assertEqual(len(v), 1)
        self.assertEqual(dir(v[0]), dir(i))
        self.assertEqual(list(v[0].attr.keys()), [1])

        if self.isKeyed:
            self.assertIs(v[0].attr[1], v)
        else:
            # See 'TestArchiveNative'
            self.assertIsNot(v[0].attr[1], v)

        buf = self.archiverClass.archivedDataWithRootObject_(d)
        self.assertIsInstance(buf, NSData)
        v = self.unarchiverClass.unarchiveObjectWithData_(buf)

        if self.isKeyed:
            self.assertIs(v[1][0].attr, v)
        else:
            # See 'TestArchiveNative'
            self.assertIsNot(v[1][0].attr, v)
Beispiel #25
0
    def test_methods(self):
##        class X(Structure):
##            _fields_ = []

        self.assertIn("in_dll", dir(type(Structure)))
        self.assertIn("from_address", dir(type(Structure)))
        self.assertIn("in_dll", dir(type(Structure)))
Beispiel #26
0
    def __init__(self):
        self.db = Database() # classe database
        self.i2c = 0
        self.getBusValue() # Setta il corretto device
        self.A = {}
        self.P = {}
        self.mBoard = [] # matrive board
        self.mBoard_io = [] # matrice IO
        self.mProg = [] # matrice programma
        self.area_id = ()
        self.dir_root = os.path.dirname(os.path.abspath(__file__))
        self.initialize()

        """
        Example pigpio port
        """
        self.pi = pigpio.pi("localhost", 8888) # Instance host, port
        print dir(self.pi)
        print
        self.pi.write(16, False)
        print self.pi.read(16) # Read status if IO 16
        self.pi.write(16, True) # Write 1 to IO 16
        print self.pi.read(16)

        for n in range(32): # print mode of GPIO: 0 = INPUT  1 = OUTPUT, 2 = ALT5, 3 = ALT4, 4 = ALT0, 5 = ALT1, 6 = ALT2, 7 = ALT3
            print "GPIO n:%s, mode: %s" %(n, self.pi.get_mode(n))
	def toXML(self,name=None):
		""" Method that creates the XML document for the instance of python class.
		    Return a string with the xml document.
		 """
		nameroot = None

		if name == None:
			nameroot = self.__class__.__name__
		else:
			nameroot = name

		xml = '<%s>'%nameroot
		default_attr = dir(type('default',(object,),{}))
		for key in dir(self):
			if default_attr.count(key) > 0:
				continue
			element = findElementFromDict(self.__dict__,key)
			if element == None:
				continue
			if isinstance(element,list):
				for e in element:
					if isinstance(e,ComplexType):
						xml += e.toXML(name=key)
					else:
						xml += '<%s>%s</%s>'%(key,e,key)
			elif isinstance(element,Property):
				xml += '<%s>%s</%s>'%(key,element.value,key)
			elif isinstance(element,ComplexType):
				xml += element.toXML(name=key)
			else:
				xml += '<%s>%s</%s>'%(key,convert(type(element).__name__,element),key)
		xml += '</%s>'%nameroot
		return str(xml)
Beispiel #28
0
 def test_methods(self):
     weaksetmethods = dir(WeakSet)
     for method in dir(set):
         if method == 'test_c_api' or method.startswith('_'):
             continue
         self.assertIn(method, weaksetmethods,
                      "WeakSet missing method " + method)
  def update(self, new_mac, packet, packet_in):
    srcaddr = EthAddr(packet.src)
    dstaddr = EthAddr(packet.dst)
    
    
    log.debug("---------------------------------")
    log.debug(srcaddr)
    log.debug(dstaddr)
    log.debug("MAC Address Store")
    log.debug(self.macStore)
    log.debug("Done")
    log.debug("---------------------------------")
    fm = of.ofp_flow_mod(command=of.OFPFC_MODIFY)
    fm.match = of.ofp_match.from_packet(packet)
    #fm.match.in_port = packet_in.in_port
    #fm.match.dl_dst = new_mac
    fm.actions.append(of.ofp_action_output(port = self.macStore[new_mac]))
    print "dicic"
    print dir(fm)
      #fm.idle_timeout = 10
      #fm.hard_timeout = 30
    log.debug("UPDATING FLOWTABLE ENTRY")
    self.connection.send(fm)
 
      # We wont loose this package, so we forward it
      # to its destination
    self.send_packet(packet_in.buffer_id, packet_in.data, self.macStore[new_mac], packet_in.in_port)
    self.send_packet(packet_in.buffer_id, packet_in.data, self.macStore[new_mac], packet_in.in_port)
    log.debug("-------------Package <"+str(packet_in.buffer_id)+"> forwarded by controller over Port "+str(self.macStore[new_mac]))
Beispiel #30
0
def breadthFirstSearch(problem):
    """
    Search the shallowest nodes in the search tree first.
    """
    "*** YOUR CODE HERE ***"
    closedSet           = set()
    dataStructure       = util.Queue()
    path                = []
   
    pathTuple = () 
    if "startState" in dir(problem):
        nodeCoordStartState = problem.startState
        pathTuple = ((nodeCoordStartState, "", 0), )
    elif "getStartState" in dir(problem):
        nodeCoordStartState = problem.getStartState()
        pathTuple = ((nodeCoordStartState, "", 0), )
    else:
        raise Exception("No recognizable function for getting the Start State")
        
    dataStructure.push(pathTuple)

    result = findSolution(problem, pathTuple, dataStructure, closedSet)
    
    if result is None:
        raise Exception("No solution exists!")
    
    path = getListOfActions(result)

    #print "[Final Path] [%s] with length %d" % (str(result), len(result))
    #print "Path: %s with length %d" % (str(path), len(path)) 
    return path
Beispiel #31
0
import datetime

print(dir(datetime.datetime))
nafisa = datetime.datetime.now()

print(nafisa.day)
Beispiel #32
0
    def mutate(self):
        """
        Perform mutations on each genotype.
        """
        # some simulations do not require mutation, skip this step if so.
        if self.mutation_rate == 0:
            return
        
        abundances = [freq * self.population_size for freq in self.population.vs['frequency']]
        num_mutants = nbinom(n=abundances,
                             p=1-np.exp(-self.mutation_rate))

        self.population.vs['frequency'] = self.population.vs['frequency'] - (num_mutants / self.population_size)

        k = 1
        while(any(num_mutants > 0)):
            new_num_mutants = nbinom(n=num_mutants,
                                     p=gamma(k+1, self.mutation_rate)/gamma(k, self.mutation_rate),
                                     size=len(num_mutants))
            # we want a list of how many mutants will have k mutations for each genotype
            num_k_mutants = nsubtract(num_mutants, new_num_mutants)
            # skip over any count of mutants that is 0
            for name in nnonzero(num_k_mutants):
                if not len(name):
                    continue
                name = name[0]
                num_mutant = num_k_mutants[name]
                # if we have a mutational neighborhood function, it will be MUCH faster
                if k == 1 and '__mutational_neighborhood__' in dir(self.population.vs[0]['genotype']):
                    # get a list of genotypes that are 1 mutation away from the current genotype
                    mutational_neighborhood = self.population.vs[name]['genotype'].__mutational_neighborhood__()
                    # randomly distribute num_mutant amount a list of size=mutational_neighborhood
                    distribution = self.neighborhood_distribution(num_mutant, len(mutational_neighborhood))
                    for dist_index in nnonzero(distribution):
                        dist_index = dist_index[0]
                        mutant_genotype = mutational_neighborhood[dist_index]
                        mutant_count = distribution[dist_index]
                        if mutant_genotype in self.graph_node_to_genotype:
                            self.graph_node_to_genotype[mutant_genotype]['frequency'] += mutant_count / self.population_size
                        else:
                            current_counter = str(next(self.counter))
                            self.population.add_vertex(name=current_counter,
                                                parent=self.population.vs[name]['name'],
                                                frequency=mutant_count/self.population_size,
                                                max_frequency=mutant_count/self.population_size,
                                                genotype=mutant_genotype,
                                                num_mutations=k,
                                                dirty_flag=1)
                            self.graph_node_to_genotype[mutant_genotype] = self.population.vs.find(name=current_counter)
                # if no mutational neighborhood function or k > 1, just call num_mutant mutations
                else:
                    for _ in range(num_mutant):
                        mutant_genotype = self.genotype_deepcopy(self.population.vs[name]['genotype'])
                        # do k mutations on the genotype to get the new mutant
                        for _ in range(k):
                            mutant_genotype.__mutate__()
                        # if this is not a new genotype, update the frequency
                        if mutant_genotype in self.graph_node_to_genotype:
                            self.graph_node_to_genotype[mutant_genotype]['frequency'] += 1 / self.population_size
                        # if it is new, add it to the map and the population
                        else:
                            current_counter = str(next(self.counter))
                            self.population.add_vertex(name=current_counter,
                                                    parent=self.population.vs[name]['name'],
                                                    frequency=1/self.population_size,
                                                    max_frequency=1/self.population_size,
                                                    genotype=mutant_genotype,
                                                    num_mutations=k,
                                                    dirty_flag=1)
                            self.graph_node_to_genotype[mutant_genotype] = self.population.vs.find(name=current_counter)

            k += 1
            num_mutants = new_num_mutants
Beispiel #33
0
# You may not use this work except in compliance with the Licence.
# You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl
"""
Python equivalents of various excel functions.
"""
import functools
import collections
import math
import numpy as np
import schedula as sh
from ..errors import FunctionError, FoundError
from ..tokens.operand import XlError, Error

ufuncs = {
    item: getattr(np, item)
    for item in dir(np) if isinstance(getattr(np, item), np.ufunc)
}


def _replace_empty(x, empty=0):
    if isinstance(x, np.ndarray):
        y = x.ravel().tolist()
        if sh.EMPTY in y:
            y = [empty if v is sh.EMPTY else v for v in y]
            return np.asarray(y, object).reshape(*x.shape)
    return x


def xpower(number, power):
    if number == 0:
        if power == 0:
Beispiel #34
0
def get_Lstar2(pos, date, alpha = 90.,
                  params = None, coord_system='GSM',
                  Bfield = 'Lgm_B_OP77',
                  internal_model = 'Lgm_B_IGRF',
                  LstarThresh = 10.0,  # beyond this Lsimple don't compute Lstar;; not used in get_Lstar2
                  extended_out = False,
                  LstarQuality = 3, 
                  FootpointHeight=100., 
                  Colorize=False, 
                  cverbosity=0, QinDenton=False):    
## void Lgm_ComputeLstarVersusPA( long int Date, double UTC, Lgm_Vector *u, int nAlpha, double *Alpha, int Quality, int Colorize, Lgm_MagEphemInfo *MagEphemInfo ) {

    # setup a datamodel object to hold the answer
    ans = Lstar_Data()

    # change datetime to Lgm Datelong and UTC
    try:
        datelong = Lgm_CTrans.dateToDateLong(date)
        utc = Lgm_CTrans.dateToFPHours(date)
    except AttributeError:
        raise(TypeError("Date must be a datetime object"))
    else:
        ans['Epoch'] = datamodel.dmarray([date])

    # pitch angles to calculate
    if isinstance(alpha, numbers.Real):
        Alpha = numpy.asanyarray([alpha], dtype=float)
    else:
        Alpha = numpy.asanyarray(alpha, dtype=float)

    # required setup
    MagEphemInfo = Lgm_MagEphemInfo.Lgm_MagEphemInfo(len(Alpha), cverbosity)

    # setup a shortcut to MagModelInfo
    mmi = MagEphemInfo.LstarInfo.contents.mInfo.contents
    Lgm_Set_Coord_Transforms( datelong, utc, mmi.c) # dont think mmi.c needs a pointer()

    # setup a shortcut to LstarInfo
    MagEphemInfo.LstarInfo.contents.VerbosityLevel = cverbosity
    MagEphemInfo.LstarQuality = LstarQuality
    MagEphemInfo.LstarInfo.contents.SaveShellLines = False
    MagEphemInfo.LstarInfo.contents.FindShellPmin = extended_out
    MagEphemInfo.LstarInfo.contents.LSimpleMax = 10.0;
    mmi.VerbosityLevel = 0;
    mmi.Lgm_LossConeHeight = FootpointHeight;

    #MagEphemInfo->LstarInfo->mInfo->Bfield        = Lgm_B_T89;
#    mmi.Bfield = Lgm_Wrap.__getattribute__(Bfield)
    Lgm_Wrap.__getattribute__('Lgm_Set_'+Bfield)(MagEphemInfo.LstarInfo.contents.mInfo)
    Lgm_Wrap.__getattribute__('Lgm_Set_'+internal_model+'_InternalModel')(MagEphemInfo.LstarInfo.contents.mInfo)    
    
    MagEphemInfo.nAlpha = len(Alpha)
    #if len(Alpha) > 1 and Bfield == 'Lgm_B_TS04':
    #    raise(NotImplementedError('TS04 is not thread safe!! Can only do 1 PA at a time'))

    for i in range(len(Alpha)):
        MagEphemInfo.Alpha[i] = Alpha[i]
        
    # convert to **GSM**
    if coord_system == 'GSM':
        try:
            Pgsm = Lgm_Vector.Lgm_Vector(*pos)
        except TypeError:
            raise(TypeError("Position must be listlike" ) )
        ans['position']['GSM'] = datamodel.dmarray(pos, attrs={'units':'Re'})
    elif coord_system == 'SM':
        try:
            Psm = Lgm_Vector.Lgm_Vector(*pos)
        except TypeError:
            raise(TypeError("Position must be listlike" ) )
        Pgsm = Lgm_Vector.Lgm_Vector()
        Lgm_Convert_Coords( pointer(Psm), pointer(Pgsm), SM_TO_GSM, mmi.c )
        ans['position']['SM'] = datamodel.dmarray(pos, attrs={'units':'Re'})
        ans['position']['GSM'] = datamodel.dmarray(Pgsm.tolist(), attrs={'units':'Re'})
    else:
        raise(NotImplementedError("Only GSM or SM input currently supported"))
    
## void Lgm_ComputeLstarVersusPA( long int Date, double UTC, Lgm_Vector *u, int nAlpha, 
##                                 double *Alpha, int Quality, int Colorize, Lgm_MagEphemInfo *MagEphemInfo ) {



    if QinDenton:# and Bfield == 'Lgm_B_TS04': # these are the params we will use.
        # Grab the QinDenton data
        # Lgm_get_QinDenton_at_JD( JD, &p, 1 );
        # JD = Lgm_Date_to_JD( Date, UTC, mInfo->c );
        JD = Lgm_Wrap.Lgm_Date_to_JD(datelong, utc, pointer(mmi.c))
        qd_one = Lgm_Wrap.Lgm_QinDentonOne()
        Lgm_Wrap.Lgm_get_QinDenton_at_JD( JD, pointer(qd_one), cverbosity)
        Lgm_Wrap.Lgm_set_QinDenton(pointer(qd_one), pointer(mmi.c))
        
        ans['params'] = dm.SpaceData()
        for att in dir(qd_one):
            if att[0] != '_':
                ans['params'][att] = getattr(qd_one, att)
    else:
        # save params
        ans['params'] = params
        if params == None:
            params = {}
        # step through the params dict and populate MagEphemInfo
        for key in params:
            if key == 'W':
                double6 = c_double*6
                W = double6(*params[key])
                MagEphemInfo.LstarInfo.contents.mInfo.contents.__setattr__(key, W)
            else:
                MagEphemInfo.LstarInfo.contents.mInfo.contents.__setattr__(key, params[key])
    
    Lgm_ComputeLstarVersusPA( ctypes.c_long(datelong), ctypes.c_double(utc), ctypes.pointer(Pgsm), 
                             ctypes.c_int(len(Alpha)), 
                             np.require(Alpha, requirements=['C']).ctypes.data_as(ctypes.POINTER(ctypes.c_double)), 
                             ctypes.c_int(LstarQuality), ctypes.c_int(Colorize), 
                             ctypes.pointer(MagEphemInfo) )

    for ii, pa in enumerate(Alpha):
        if int(pa) == pa:
            pa = int(pa)
        ans[pa] = dm.SpaceData()
        ans[pa]['LHilton'] = MagEphemInfo.LHilton[ii]
        ans[pa]['LMcIlwain'] = MagEphemInfo.LMcIlwain[ii]
        ans[pa]['Lstar'] = MagEphemInfo.Lstar[ii]

        # think in here, there are not owned by pyhton so there is no easy way to free the memory...
        if extended_out:
            ans[pa]['Bmin'] = dm.dmarray(np.zeros([MagEphemInfo.nShellPoints[ii], 3]))
            ans[pa]['I'] = dm.dmarray(np.zeros([MagEphemInfo.nShellPoints[ii]]))
            ans[pa]['Pmin'] = dm.dmarray(np.zeros([MagEphemInfo.nShellPoints[ii], 3]))
            ans[pa]['Bmin'][:, 0] = [val.x for val in MagEphemInfo.Shell_Bmin[ii][0:MagEphemInfo.nShellPoints[ii]]] 
            ans[pa]['Bmin'][:, 1] = [val.y for val in MagEphemInfo.Shell_Bmin[ii][0:MagEphemInfo.nShellPoints[ii]]] 
            ans[pa]['Bmin'][:, 2] = [val.z for val in MagEphemInfo.Shell_Bmin[ii][0:MagEphemInfo.nShellPoints[ii]]] 
            ans[pa]['I'][:] = [val for val in MagEphemInfo.ShellI[ii][0:MagEphemInfo.nShellPoints[ii]]]
            ans[pa]['Pmin'][:, 0] = [val.x for val in MagEphemInfo.Shell_Pmin[ii][0:MagEphemInfo.nShellPoints[ii]]] 
            ans[pa]['Pmin'][:, 1] = [val.y for val in MagEphemInfo.Shell_Pmin[ii][0:MagEphemInfo.nShellPoints[ii]]] 
            ans[pa]['Pmin'][:, 2] = [val.z for val in MagEphemInfo.Shell_Pmin[ii][0:MagEphemInfo.nShellPoints[ii]]] 
        
    return ans
Beispiel #35
0
def _get_methods(class_input):
    """ A rather hacky method to get the methods of a class.
    """
    return [f for f in dir(class_input) 
            if callable(getattr(class_input, f)) and not f.startswith('__')]
Beispiel #36
0
    im = mapnik.Image(m.width, m.height)
    mapnik.render(m, im)
    eq_(get_unique_colors(im), ['rgba(255,255,85,191)'])


def test_background_image_with_alpha_and_background_color_against_composited_control(
):
    m = mapnik.Map(10, 10)
    m.background = mapnik.Color('rgba(255,255,255,.5)')
    m.background_image = '../data/images/yellow_half_trans.png'
    im = mapnik.Image(m.width, m.height)
    mapnik.render(m, im)
    # create and composite the expected result
    im1 = mapnik.Image(10, 10)
    im1.background = mapnik.Color('rgba(255,255,255,.5)')
    im1.premultiply()
    im2 = mapnik.Image(10, 10)
    im2.background = mapnik.Color('rgba(255,255,0,.5)')
    im2.premultiply()
    im1.composite(im2)
    im1.demultiply()
    # compare image rendered (compositing in `agg_renderer<T>::setup`)
    # vs image composited via python bindings
    #raise Todo("looks like we need to investigate PNG color rounding when saving")
    #eq_(get_unique_colors(im),get_unique_colors(im1))


if __name__ == "__main__":
    setup()
    exit(run_all(eval(x) for x in dir() if x.startswith("test_")))
Beispiel #37
0
    _NoTextCoercion, RoleImpl, roles.CompoundElementRole
):
    def _raise_for_expected(self, element, argname=None, resolved=None, **kw):
        if isinstance(element, roles.FromClauseRole):
            if element._is_subquery:
                advice = (
                    "Use the plain select() object without "
                    "calling .subquery() or .alias()."
                )
            else:
                advice = (
                    "To SELECT from any FROM clause, use the .select() method."
                )
        else:
            advice = None
        return super(CompoundElementImpl, self)._raise_for_expected(
            element, argname=argname, resolved=resolved, advice=advice, **kw
        )


_impl_lookup = {}


for name in dir(roles):
    cls = getattr(roles, name)
    if name.endswith("Role"):
        name = name.replace("Role", "Impl")
        if name in globals():
            impl = globals()[name](cls)
            _impl_lookup[cls] = impl
Beispiel #38
0
def print_obj_methods(obj):
    print('----------debug %s---------' % obj)
    print(dir(obj))
def dump(obj):
    for attr in dir(obj):
        if hasattr(obj, attr):
            print("obj.%s = %s" % (attr, getattr(obj, attr)))
Beispiel #40
0
    'KIND': Fore.CYAN,
    'CONT': Style.BRIGHT + Fore.BLACK,
    'VARS': Style.BRIGHT + Fore.MAGENTA,
    'VARS-NAME': Style.NORMAL + Fore.MAGENTA,
    'INTERNAL-FAILURE': Style.BRIGHT + Back.RED + Fore.RED,
    'INTERNAL-DETAIL': Fore.WHITE,
    'SOURCE-FAILURE': Style.BRIGHT + Back.YELLOW + Fore.YELLOW,
    'SOURCE-DETAIL': Fore.WHITE,
    'RESET': Style.RESET_ALL,
}
for name, group in [
    ('', Style),
    ('fore', Fore),
    ('back', Back),
]:
    for key in dir(group):
        OTHER_COLORS['{}({})'.format(name, key) if name else key] = getattr(
            group, key)
CALL_COLORS = {
    'call': Style.BRIGHT + Fore.BLUE,
    'line': Fore.RESET,
    'return': Style.BRIGHT + Fore.GREEN,
    'exception': Style.BRIGHT + Fore.RED,
}
CODE_COLORS = {
    'call': Fore.RESET + Style.BRIGHT,
    'line': Fore.RESET,
    'return': Fore.YELLOW,
    'exception': Fore.RED,
}
MISSING = type('MISSING', (), {'__repr__': lambda _: '?'})()
Beispiel #41
0
def test_main():
    mod = sys.modules[__name__]
    test_support.run_unittest(
        *[getattr(mod, name) for name in dir(mod) if name.startswith('Test')]
    )
def dump_obj(obj):
    for attr in dir(obj):
        logging.debug("    obj.%s = %s" % (attr, getattr(obj, attr)))
    logservice.flush()
Beispiel #43
0
def question3d():
    answerDiscount = 0.95
    answerNoise = 0.3
    answerLivingReward = 0
    return answerDiscount, answerNoise, answerLivingReward
    # If not possible, return 'NOT POSSIBLE'


def question3e():
    answerDiscount = 1
    answerNoise = 0
    answerLivingReward = 10
    return answerDiscount, answerNoise, answerLivingReward
    # If not possible, return 'NOT POSSIBLE'


def question8():
    answerEpsilon = None
    answerLearningRate = None
    return 'NOT POSSIBLE'
    # If not possible, return 'NOT POSSIBLE'


if __name__ == '__main__':
    print 'Answers to analysis questions:'
    import analysis
    for q in [q for q in dir(analysis) if q.startswith('question')]:
        response = getattr(analysis, q)()
        print '  Question %s:\t%s' % (q, str(response))
Beispiel #44
0
    print("""iptest is used to run IronPython tests.

Notes:
- ???

Typical usage would be:
    ipy harness.py interop.net --plan
""")
    sys.exit(0)

#--no_testing
if "--no_testing" in sys.argv:
    options.RUN_TESTS = False
    sys.argv.remove("--no_testing")

#--plan
if "--plan" in sys.argv:
    options.GEN_TEST_PLAN = True
    sys.argv.remove("--plan")

#Do a little post processing
if options.GEN_TEST_PLAN:
    import pydoc

#Dump the flags
l.debug("sys.argv after processing: %s" % str(sys.argv))
l.debug("Command-line options:")
for x in [temp for temp in dir(options) if not temp.startswith("__")]:
    y = eval("options." + x)
    l.debug("\t%s = %s" % (x, y))
l.debug("")
Beispiel #45
0
def has_form_class(model_name):
    from idcops import forms
    name = model_name.capitalize()
    has_add_form = "{}NewForm".format(name) in dir(forms)
    has_edit_form = "{}Form".format(name) in dir(forms)
    return has_add_form or has_edit_form
Beispiel #46
0
# >>> isinstance(d, Dog) and isinstance(d, Animal)
# True
# 但是,d不是Husky类型:
# >>> isinstance(d, Husky)
# False
# 能用type()判断的基本类型也可以用isinstance()判断:
print(isinstance('a', str))
print(isinstance(123, int))
print(isinstance(b'a', bytes))
# 并且还可以判断一个变量是否是某些类型中的一种,比如下面的代码就可以判断是否是list或者tuple:
print(isinstance([1, 2, 3], (list, tuple)))
print(isinstance((1, 2, 3), (list, tuple)))
print('===========================================================')
print('3--------------------使用dir()')
# 如果要获得一个对象的所有属性和方法,可以使用dir()函数,它返回一个包含字符串的list,比如,获得一个str对象的所有属性和方法:
print(dir('ABC'))
# 类似__xxx__的属性和方法在Python中都是有特殊用途的,比如__len__方法返回长度。
# 在Python中,如果你调用len()函数试图获取一个对象的长度,实际上,在len()函数内部,它自动去调用该对象的__len__()方法,所以,下面的代码是等价的:
print(len('ABC'))
print('ABC'.__len__())


# 我们自己写的类,如果也想用len(myObj)的话,就自己写一个__len__()方法:
class MyDog(object):
    def __len__(self):
        return 100


myDog = MyDog()
print(myDog.__len__())
# 剩下的都是普通属性或方法,比如lower()返回小写的字符串:
Beispiel #47
0
green = make_colorizer('darkgreen')
yellow = make_colorizer('darkyellow')
blue = make_colorizer('darkblue')

logger = logging.getLogger(__name__)


class StopRequested(Exception):
    pass


def compact(l):
    return [x for x in l if x is not None]


_signames = dict((getattr(signal, signame), signame) for signame in dir(signal)
                 if signame.startswith('SIG') and '_' not in signame)


def signal_name(signum):
    try:
        if sys.version_info[:2] >= (3, 5):
            return signal.Signals(signum).name
        else:
            return _signames[signum]

    except KeyError:
        return 'SIG_UNKNOWN'
    except ValueError:
        return 'SIG_UNKNOWN'
Beispiel #48
0
def get_forms_names():
    forms = import_string('idcops.forms')
    return dir(forms)
    tokenize(readline, tokeneater=printtoken)
are the same, except instead of generating tokens, tokeneater is a callback
function to which the 5 fields described above are passed as 5 arguments,
each time a new token is found."""

__author__ = 'Ka-Ping Yee <*****@*****.**>'
__credits__ = ('GvR, ESR, Tim Peters, Thomas Wouters, Fred Drake, '
               'Skip Montanaro, Raymond Hettinger')

from itertools import chain
import string, re
from token import *

import token
x = None
__all__ = [x for x in dir(token) if not x.startswith("_")]
__all__ += ["COMMENT", "tokenize", "generate_tokens", "NL", "untokenize"]
del x
del token

COMMENT = N_TOKENS
tok_name[COMMENT] = 'COMMENT'
NL = N_TOKENS + 1
tok_name[NL] = 'NL'
N_TOKENS += 2


def group(*choices):
    return '(' + '|'.join(choices) + ')'

  def construct_model(self,
                      input_tensors=None,
                      prefix='metatrain_',
                      test_num_updates=0):
    """a: training data for inner gradient, b: test data for meta gradient."""

    self.inputa = input_tensors['inputa']
    self.inputb = input_tensors['inputb']
    self.labela = input_tensors['labela']
    self.labelb = input_tensors['labelb']

    with tf.variable_scope('model', reuse=None) as training_scope:
      if 'weights' in dir(self):
        training_scope.reuse_variables()
        weights = self.weights
      else:
        # Define the weights
        self.weights = weights = self.construct_weights()

      # outputbs[i] and lossesb[i] is the output and loss after i+1 gradient
      # updates
      num_updates = max(test_num_updates, FLAGS.num_updates)

      def task_metalearn(inp, reuse=True):
        """Run meta learning."""
        TRAIN = 'train' in prefix  # pylint: disable=invalid-name
        # Perform gradient descent for one task in the meta-batch.
        inputa, inputb, labela, labelb = inp
        task_outputbs, task_lossesb = [], []
        task_msesb = []

        # support_pred and loss, (n_data_per_task, out_dim)
        task_outputa = self.forward(
            inputa, weights, reuse=reuse)  # only not reuse on the first iter
        # labela is (n_data_per_task, out_dim)
        task_lossa = self.loss_func(task_outputa, labela)

        # INNER LOOP (no change with ib)
        grads = tf.gradients(task_lossa, list(weights.values()))
        if FLAGS.stop_grad:
          grads = [tf.stop_gradient(grad) for grad in grads]
        gradients = dict(zip(weights.keys(), grads))
        # theta_pi = theta - alpha * grads
        fast_weights = dict(
            zip(weights.keys(), [
                weights[key] - self.update_lr * gradients[key]
                for key in weights.keys()
            ]))

        # use theta_pi to forward meta-test

        output = self.forward(inputb, weights, reuse=True)
        task_outputbs.append(output)
        # meta-test loss
        task_kl_loss = sum(self.encoder_w.losses)
        task_msesb.append(self.loss_func(output, labelb))
        task_lossesb.append(
            self.loss_func(output, labelb) + self.beta * task_kl_loss)

        def while_body(fast_weights_values):
          """Update params."""
          loss = self.loss_func(
              self.forward(
                  inputa,
                  dict(zip(fast_weights.keys(), fast_weights_values)),
                  reuse=True), labela)
          grads = tf.gradients(loss, fast_weights_values)
          fast_weights_values = [
              v - self.update_lr * g for v, g in zip(fast_weights_values, grads)
          ]
          return fast_weights_values

        fast_weights_values = tf.while_loop(
            lambda _: True,
            while_body,
            loop_vars=[fast_weights.values()],
            maximum_iterations=num_updates - 1,
            back_prop=TRAIN)
        fast_weights = dict(zip(fast_weights.keys(), fast_weights_values))

        output = self.forward(inputb, fast_weights, reuse=True)
        task_outputbs.append(output)
        task_msesb.append(self.loss_func(output, labelb))
        task_lossesb.append(
            self.loss_func(output, labelb) + self.beta * task_kl_loss)
        task_output = [
            task_outputa, task_outputbs, task_lossa, task_lossesb, task_msesb
        ]

        return task_output

      if FLAGS.norm is not None:
        # to initialize the batch norm vars, might want to combine this, and
        # not run idx 0 twice.
        _ = task_metalearn(
            (self.inputa[0], self.inputb[0], self.labela[0], self.labelb[0]),
            False)

      out_dtype = [
          tf.float32, [tf.float32] * 2, tf.float32, [tf.float32] * 2,
          [tf.float32] * 2
      ]
      result = tf.map_fn(task_metalearn, elems=(self.inputa, self.inputb,  \
                                                self.labela, self.labelb), dtype=out_dtype, \
                                                parallel_iterations=FLAGS.meta_batch_size)
      outputas, outputbs, lossesa, lossesb, msesb = result

    ## Performance & Optimization
    if 'train' in prefix:
      # lossesa is length(meta_batch_size)
      self.total_loss1 = tf.reduce_sum(lossesa) / tf.to_float(
          FLAGS.meta_batch_size)
      self.total_losses2 = total_losses2 = [
          tf.reduce_sum(msesb[j]) / tf.to_float(FLAGS.meta_batch_size)
          for j in range(len(msesb))
      ]
      self.total_losses3 = total_losses3 = [
          tf.reduce_sum(lossesb[j]) / tf.to_float(FLAGS.meta_batch_size)
          for j in range(len(lossesb))
      ]
      # after the map_fn
      self.outputas, self.outputbs = outputas, outputbs

      # OUTER LOOP
      if FLAGS.metatrain_iterations > 0:
        optimizer = tf.train.AdamOptimizer(self.meta_lr)
        THETA = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='model')  # pylint: disable=invalid-name
        PHI = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='encoder')  # pylint: disable=invalid-name

        self.gvs_theta = gvs_theta = optimizer.compute_gradients(
            self.total_losses2[-1], THETA)
        metatrain_theta_op = optimizer.apply_gradients(gvs_theta)

        self.gvs_phi = gvs_phi = optimizer.compute_gradients(
            self.total_losses3[-1], PHI)
        metatrain_phi_op = optimizer.apply_gradients(gvs_phi)

        with tf.control_dependencies([metatrain_theta_op, metatrain_phi_op]):
          self.metatrain_op = tf.no_op()

        scale_v = [
            v for v in self.encoder_w.trainable_variables if 'scale' in v.name
        ]
        scale_norm = [tf.reduce_mean(v) for v in scale_v]
        scale_norm = tf.reduce_mean(scale_norm)

        tf.summary.scalar(prefix + 'full_loss', total_losses3[-1])
        tf.summary.scalar(prefix + 'regularizer',
                          total_losses3[-1] - total_losses2[-1])
        tf.summary.scalar(prefix + 'untransformed_scale', scale_norm)

    else:
      self.metaval_total_loss1 = tf.reduce_sum(
          lossesa) / tf.to_float(FLAGS.meta_batch_size)
      self.metaval_total_losses2 = total_losses2 = [
          tf.reduce_sum(msesb[j]) / tf.to_float(FLAGS.meta_batch_size)
          for j in range(len(msesb))
      ]
      self.metaval_total_losses3 = total_losses3 = [
          tf.reduce_sum(lossesb[j]) / tf.to_float(FLAGS.meta_batch_size)
          for j in range(len(lossesb))
      ]

    tf.summary.scalar(prefix + 'Pre-mse', total_losses2[0])
    tf.summary.scalar(prefix + 'Post-mse_' + str(num_updates),
                      total_losses2[-1])
Beispiel #51
0
from math import sqrt
print(sqrt(13689))

import math

everything = dir(math)

print(everything)
Beispiel #52
0
def test_property_generator():
    sampler = Sampler(0)
    properties = [x for x in dir(sampler) if x != "context" and not x.startswith("_") and type(getattr(Sampler, x)) == property]

    for p in properties:
        yield check_property, sampler, p
        #data = eval('(' + obj.get() + ')')
        data = '(' + obj.get() + ')'
    # Show error message if no values found
    #if eval(data).count() == 0:
    #    messagebox.showinfo('Error','No data found')
    # return data
    return data
    

# Left frame
frameLeft = ttk.Frame(root)
frameLeft.pack(side=tk.LEFT, anchor=tk.NW, fill=tk.Y, padx=4, pady=2)

# Combobox to select a data frame
comboboxDataframes = ttk.Combobox(frameLeft)
variables= [var for var in dir() if isinstance(eval(var), pd.core.frame.DataFrame)]
comboboxDataframes['values'] = variables
comboboxDataframes.bind('<Return>',ListColumns)
comboboxDataframes.bind('<<ComboboxSelected>>',ListColumns)
comboboxDataframes.pack(pady=4)

# Properties panel 
frameProperties = ttk.Frame(frameLeft, relief='ridge', borderwidth=4)
frameProperties.pack(side=tk.BOTTOM, anchor=tk.SW, fill=tk.Y, pady=4)

# Properties panel Histogram
frameHistogram = ttk.Frame(frameProperties)
frameHistogram.pack(side=tk.BOTTOM, anchor=tk.SW, fill=tk.Y, pady=4)

labelHistogram = ttk.Label(frameHistogram, text='number of bins:')
labelHistogram.pack(side=tk.TOP, anchor=tk.NW, padx=4, pady=2)
Beispiel #54
0
    def load_methods(self, module, user_modules):
        """
        Read the given user-written py3status class file and store its methods.
        Those methods will be executed, so we will deliberately ignore:
            - private methods starting with _
            - decorated methods such as @property or @staticmethod
            - 'on_click' methods as they'll be called upon a click_event
            - 'kill' methods as they'll be called upon this thread's exit
        """
        if not self.module_class:
            # user provided modules take precedence over py3status provided modules
            if self.module_name in user_modules:
                include_path, f_name = user_modules[self.module_name]
                self._py3_wrapper.log('loading module "{}" from {}{}'.format(
                    module, include_path, f_name))
                self.module_class = self.load_from_file(include_path + f_name)
            # load from py3status provided modules
            else:
                self._py3_wrapper.log(
                    'loading module "{}" from py3status.modules.{}'.format(
                        module, self.module_name))
                self.module_class = self.load_from_namespace(self.module_name)

        class_inst = self.module_class
        if class_inst:

            try:
                # containers have items attribute set to a list of contained
                # module instance names.  If there are no contained items then
                # ensure that we have a empty list.
                if class_inst.Meta.container:
                    class_inst.items = []
            except AttributeError:
                pass

            # module configuration
            mod_config = self.config['py3_config'].get(module, {})

            # process any deprecated configuration settings
            try:
                deprecated = class_inst.Meta.deprecated
            except AttributeError:
                deprecated = None

            if deprecated:

                def deprecation_log(item):
                    # log the deprecation
                    # currently this is just done to the log file as the user
                    # does not need to take any action.
                    if 'msg' in item:
                        msg = item['msg']
                        param = item.get('param')
                        if param:
                            msg = '`{}` {}'.format(param, msg)
                        msg = 'DEPRECATION WARNING: {} {}'.format(
                            self.module_full_name, msg)
                        self._py3_wrapper.log(msg)

                if 'rename' in deprecated:
                    # renamed parameters
                    for item in deprecated['rename']:
                        param = item['param']
                        new_name = item['new']
                        if param in mod_config:
                            if new_name not in mod_config:
                                mod_config[new_name] = mod_config[param]
                                # remove from config
                                del mod_config[param]
                            deprecation_log(item)
                if 'format_fix_unnamed_param' in deprecated:
                    # format update where {} was previously allowed
                    for item in deprecated['format_fix_unnamed_param']:
                        param = item['param']
                        placeholder = item['placeholder']
                        if '{}' in mod_config.get(param, ''):
                            mod_config[param] = mod_config[param].replace(
                                '{}', '{%s}' % placeholder)
                            deprecation_log(item)
                if 'rename_placeholder' in deprecated:
                    # rename placeholders
                    placeholders = {}
                    for item in deprecated['rename_placeholder']:
                        placeholders[item['placeholder']] = item['new']
                        format_strings = item['format_strings']
                        for format_param in format_strings:
                            format_string = mod_config.get(format_param)
                            if not format_string:
                                continue
                            format = Formatter().update_placeholders(
                                format_string, placeholders)
                            mod_config[format_param] = format

                if 'update_placeholder_format' in deprecated:
                    # update formats for placeholders if a format is not set
                    for item in deprecated['update_placeholder_format']:
                        placeholder_formats = item.get('placeholder_formats',
                                                       {})
                        if 'function' in item:
                            placeholder_formats.update(
                                item['function'](mod_config))
                        format_strings = item['format_strings']
                        for format_param in format_strings:
                            format_string = mod_config.get(format_param)
                            if not format_string:
                                continue
                            format = Formatter().update_placeholder_formats(
                                format_string, placeholder_formats)
                            mod_config[format_param] = format
                if 'substitute_by_value' in deprecated:
                    # one parameter sets the value of another
                    for item in deprecated['substitute_by_value']:
                        param = item['param']
                        value = item['value']
                        substitute = item['substitute']
                        substitute_param = substitute['param']
                        substitute_value = substitute['value']
                        if (mod_config.get(param) == value
                                and substitute_param not in mod_config):
                            mod_config[substitute_param] = substitute_value
                            deprecation_log(item)
                if 'function' in deprecated:
                    # parameter set by function
                    for item in deprecated['function']:
                        updates = item['function'](mod_config)
                        for name, value in updates.items():
                            if name not in mod_config:
                                mod_config[name] = value
                if 'remove' in deprecated:
                    # obsolete parameters forcibly removed
                    for item in deprecated['remove']:
                        param = item['param']
                        if param in mod_config:
                            del mod_config[param]
                            deprecation_log(item)

            # apply module configuration
            for config, value in mod_config.items():
                # names starting with '.' are private
                if not config.startswith('.'):
                    setattr(self.module_class, config, value)

            # process any update_config settings
            try:
                update_config = class_inst.Meta.update_config
            except AttributeError:
                update_config = None

            if update_config:
                if 'update_placeholder_format' in update_config:
                    # update formats for placeholders if a format is not set
                    for item in update_config['update_placeholder_format']:
                        placeholder_formats = item.get('placeholder_formats',
                                                       {})
                        format_strings = item['format_strings']
                        for format_param in format_strings:
                            format_string = getattr(class_inst, format_param,
                                                    None)
                            if not format_string:
                                continue
                            format = Formatter().update_placeholder_formats(
                                format_string, placeholder_formats)
                            setattr(class_inst, format_param, format)

            # Add the py3 module helper if modules self.py3 is not defined
            if not hasattr(self.module_class, 'py3'):
                setattr(self.module_class, 'py3', Py3(self))

            # allow_urgent
            # get the value form the config or use the module default if
            # supplied.
            fn = self._py3_wrapper.get_config_attribute
            param = fn(self.module_full_name, 'allow_urgent')
            if hasattr(param, 'none_setting'):
                param = True
            self.allow_urgent = param

            # get the available methods for execution
            for method in sorted(dir(class_inst)):
                if method.startswith('_'):
                    continue
                else:
                    m_type = type(getattr(class_inst, method))
                    if 'method' in str(m_type):
                        params_type = self._params_type(method, class_inst)
                        if method == 'on_click':
                            self.click_events = params_type
                        elif method == 'kill':
                            self.has_kill = params_type
                        elif method == 'post_config_hook':
                            self.has_post_config_hook = True
                        else:
                            # the method_obj stores infos about each method
                            # of this module.
                            method_obj = {
                                'cached_until': time(),
                                'call_type': params_type,
                                'instance': None,
                                'last_output': {
                                    'name': method,
                                    'full_text': ''
                                },
                                'method': method,
                                'name': None
                            }
                            self.methods[method] = method_obj

        # done, log some debug info
        if self.config['debug']:
            self._py3_wrapper.log(
                'module "{}" click_events={} has_kill={} methods={}'.format(
                    module, self.click_events, self.has_kill,
                    self.methods.keys()))
Beispiel #55
0
 def list(self, pattern=None):
     ls = super(K8sPersistentVolume, self).list()
     vols = list(map(lambda x: PersistentVolume(x), ls))
     if pattern is not None:
         vols = list(filter(lambda x: pattern in x.name, vols))
     k8s = []
     for x in vols:
         _types = list(filter(lambda z: z in PersistentVolumeSpec.VOLUME_TYPES_TO_SOURCE_MAP, dir(x.spec)))
         j = K8sPersistentVolume(config=self.config, name=self.name, type=_types[0])
         j.model = x
         k8s.append(j)
     return k8s
Beispiel #56
0
 def __introspect_validation_rules(self):
     rules = [
         '_'.join(x.split('_')[2:]) for x in dir(self)
         if x.startswith('_validate')
     ]
     return tuple(rules)

class jeans:
    def __init__(self, waist, length, color):
        self.waist = waist
        self.length = length
        self.color = color
        self.wearing = False

    def put_on(self):
        print('Putting on {}x{} {} jeans'.format(self.waist, self.length,
                                                 self.color))
        self.wearing = True

    def take_off(self):
        print('Taking off {}x{} {} jeans'.format(self.waist, self.length,
                                                 self.color))
        self.wearing = False


# create and examine a pair of jeans
my_jeans = jeans(31, 32, 'blue')
print(type(my_jeans))
print(dir(my_jeans))

# don and remove the jeans
my_jeans.put_on()
print(my_jeans.wearing)

my_jeans.take_off()
print(my_jeans.wearing)
Beispiel #58
0
def inner(default_project_path):
    sys.path.append(SRC_PATH)
    sys_argv = sys.argv
    PROJECT_PATH = False
    while "--pythonpath" in sys_argv:
        index = sys_argv.index("--pythonpath")
        PROJECT_PATH = os.path.join(os.getcwd(), sys_argv[index + 1])
        sys.path.insert(0, PROJECT_PATH)
        # We prevent the pythonpath to be handled later on by removing it from
        # sys_argv
        sys_argv = sys_argv[:index] + sys_argv[index + 2 :]
    if not PROJECT_PATH:
        PROJECT_PATH = default_project_path
        sys.path.insert(0, PROJECT_PATH)
    os.environ.setdefault("PROJECT_PATH", PROJECT_PATH)
    if "--settings" in sys_argv:
        index = sys_argv.index("--settings")
        SETTINGS_MODULE = sys_argv[index + 1]
    else:
        SETTINGS_MODULE = "configuration"
    mod = False
    # There are three levels of settings, each overiding the previous one:
    # global_settings.py, settings.py and configuration.py
    from django.conf import global_settings as CONFIGURATION
    from base import settings as SETTINGS

    SETTINGS_PATHS = [SETTINGS.__file__]
    for setting in dir(SETTINGS):
        setting_value = getattr(SETTINGS, setting)
        setattr(CONFIGURATION, setting, setting_value)
    try:
        mod = import_module(SETTINGS_MODULE)
    except ModuleNotFoundError:
        SETTINGS_MODULE = None
    if mod:
        SETTINGS_PATHS.append(mod.__file__)
        for setting in dir(mod):
            if setting.isupper():
                setattr(CONFIGURATION, setting, getattr(mod, setting))
    INSTALLED_APPS = CONFIGURATION.BASE_INSTALLED_APPS + list(
        CONFIGURATION.INSTALLED_APPS
    )
    for app in CONFIGURATION.REMOVED_APPS:
        INSTALLED_APPS.remove(app)
    from django.conf import settings

    settings.configure(
        CONFIGURATION,
        SETTINGS_MODULE=SETTINGS_MODULE,
        SETTINGS_PATHS=SETTINGS_PATHS,
        INSTALLED_APPS=INSTALLED_APPS,
        MIDDLEWARE=(
            CONFIGURATION.BASE_MIDDLEWARE + list(CONFIGURATION.MIDDLEWARE)
        ),
    )
    os.environ["TZ"] = settings.TIME_ZONE
    if sys_argv[1] in ["version", "--version"]:
        from base import get_version

        sys.stdout.write(get_version() + "\n")
        return
    from django.core.management import execute_from_command_line

    execute_from_command_line(sys_argv)
Beispiel #59
0
 def __init__(self):
     self._attrs = [
         name for name in dir(_os)
         if not name.startswith('_') and hasattr(self, name)
     ]
Beispiel #60
0
import cv2
import numpy as np

#This will display all the available mouse click events  
events = [i for i in dir(cv2) if 'EVENT' in i]
# print(events)

#This variable we use to store the pixel location
refPt = []

Point_Per = []
#click event function
def click_event(event, x, y, flags, param):
    if event == cv2.EVENT_LBUTTONDOWN:
        print(x,",",y)
        refPt.append([x,y])
        font = cv2.FONT_HERSHEY_SIMPLEX
        strXY = str(x)+", "+str(y)
        Point_Per.append(strXY)
        cv2.putText(img, strXY, (x,y), font, 0.5, (255,255,0), 2)
        cv2.imshow("image", img)


#Here, you need to change the image name and it's path according to your directory
img = cv2.imread(r"C:\Users\aminb\Desktop\FIBO\Image\Moduel_image\test_field.jpg")
cv2.imshow("image", img)

#calling the mouse click event
cv2.setMouseCallback("image", click_event)