def do_volume_create(self, args):
     '''Create volume.'''
     body = self.client.volume_create(
         size=args.size,
         image=args.image,
         desc=args.desc)
     utils.pretty(head='VOLUME|STATUS', body=body)
 def do_image_create(self, args):
     '''Create image.'''
     body = self.client.image_create(
         url=args.url,
         platform=args.platform,
         shared=str(args.shared).lower(),
         desc=args.desc)
     utils.pretty(head='IMAGE|STATUS', body=body)
 def do_image_show(self, args):
     '''Show image.'''
     body = self.client.image_show(image=args.image)
     body = dict(json.loads(body))
     # TODO remove below workaround once image show is ready.
     head = '|'.join(body.keys()).upper()
     body = '|'.join([v.strip() for v in body.values()]).replace(',', '')
     body = '["%s"]' % body
     utils.pretty(head=head, body=body)
Esempio n. 4
0
def init_devices():
  servers = novac.servers.list(detailed=True)
  for srv in servers:
      image_id = srv.image['id']
      if (str(glancec.images.get(image_id)['name']) == pod_images['vnf']['image_name']):
        profile = { 'name': srv.name, 'uuid': srv.id, 'interfaces': srv.addresses }
        utils.pretty(profile)
        update_network_device.add_device(profile)
        update_alarm.add_alarm(srv.name)
def display_summary_tax(summary_taxdata, CGTCalc, taxyear, report):

        """
        taxdata contains a list of tuples
        ## Each tuplue (gbp_disposal_proceeds, gbp_allowable_costs, gbp_gains, gbp_losses, number_disposals,
                commissions, taxes, gbp_gross_profit, gbp_net_profit)



        """

        ## Unpack tuple
        (gbp_disposal_proceeds, gbp_allowable_costs, gbp_gains, gbp_losses, number_disposals,
                gbp_commissions, gbp_taxes, gbp_gross_profit,  abs_quantity, gbp_net_profit) = summary_taxdata

        report.write(star_line())

        report.write("\n\n                Summary for tax year ending 5th April %d \n" % taxyear)
        report.write("\n                              Figures in GBP\n\n")


        if CGTCalc:
            report.write("Disposal Proceeds = %s, Allowable Costs = %s, Disposals = %d \n Year Gains = %s  Year Losses = %s PROFIT = %s\n" % \
                (pretty(gbp_disposal_proceeds), pretty(gbp_allowable_costs),
                 number_disposals, pretty(gbp_gains), pretty(gbp_losses), pretty(gbp_net_profit)))

        else:
            report.write("Gross trading profit %s, Commission paid %s, Taxes paid %s, Net profit %s\n" % \
              (pretty(gbp_gross_profit), pretty(gbp_commissions),
               pretty(gbp_taxes), pretty(gbp_net_profit)))

            report.write("\nNot included: interest paid, interest received, data and other fees, internet connection,...\n hardware, software, books, subscriptions, office space, Dividend income (report seperately)\n\n")

        report.write("\n\n")
def display_summary_tax(summary_taxdata, CGTCalc, taxyear, report):
            
        """
        taxdata contains a list of tuples
        ## Each tuplue (gbp_disposal_proceeds, gbp_allowable_costs, gbp_gains, gbp_losses, number_disposals,
                commissions, taxes, gbp_gross_profit, gbp_net_profit)
    
        
        
        """    

        ## Unpack tuple
        (gbp_disposal_proceeds, gbp_allowable_costs, gbp_gains, gbp_losses, number_disposals,
                gbp_commissions, gbp_taxes, gbp_gross_profit,  abs_quantity, gbp_net_profit) = summary_taxdata

        report.write(star_line())
        
        report.write("\n\n                Summary for tax year ending 5th April %d \n" % taxyear)
        report.write("\n                              Figures in GBP\n\n")


        if CGTCalc:
            report.write("Disposal Proceeds = %s, Allowable Costs = %s, Disposals = %d \n Year Gains = %s  Year Losses = %s PROFIT = %s\n" % \
                (pretty(gbp_disposal_proceeds), pretty(gbp_allowable_costs), 
                 number_disposals, pretty(gbp_gains), pretty(gbp_losses), pretty(gbp_net_profit)))
            
        else:
            report.write("Gross trading profit %s, Commission paid %s, Taxes paid %s, Net profit %s\n" % \
              (pretty(gbp_gross_profit), pretty(gbp_commissions),
               pretty(gbp_taxes), pretty(gbp_net_profit)))
              
            report.write("\nNot included: interest paid, interest received, data and other fees, internet connection,...\n hardware, software, books, subscriptions, office space, Dividend income (report seperately)\n\n")
            
        report.write("\n\n")
 def do_vlan_create(self, args):
     '''Create VLAN.'''
     body = self.client.vlan_create(
         vlan=args.vlan,
         network=args.network,
         netmask=args.netmask,
         gateway=args.gateway,
         start_ip=args.begin,
         end_ip=args.end,
         shared=str(args.shared).lower(),
         use_dhcp=str(args.use_dhcp).lower()
     )
     utils.pretty(head='VLAN|STATUS', body=body)
 def do_vm_create(self, args):
     """Create virtual machine."""
     metadata = {}
     if args.user_data:
         metadata["user_data"] = utils.read_file(args.user_data)
     body = self.client.vm_create(
         image=args.image,
         vlan=args.vlan,
         name=args.name,
         cpu=args.cpu,
         memory=args.memory,
         increase=args.increase,
         metadata=metadata)
     utils.pretty(head="VM|STATUS", body=body)
Esempio n. 9
0
def handle_create(instance_id):
  print ">> Handling Instance_Create Message"
  #Wait for novac to update#
  time.sleep(3)
  servers = novac.servers.list(detailed=True)
  for srv in servers:
    if (instance_id == srv.id):
      image_id = srv.image['id']
      
      if (glancec.images.get(image_id)['name'] == pod_images['vnf']['image_name']):
        print "\t > Detect vSRX creation. Adding Network Devie and Alarm to AppFormix..."
        profile = { 'name': srv.name, 'uuid': srv.id, 'interfaces': srv.addresses }
        utils.pretty(profile)
        update_network_device.add_device(profile)
        update_alarm.add_alarm(srv.name)
Esempio n. 10
0
    def test_pretty_list_of_lists(self):
        import utils
        AAstr = '''a,b,c
d,e,f
g,h,i'''
        AA = [['a', 'b', 'c'], ['d', 'e', 'f'], ['g','h', 'i']]
        self.assertEqual(AAstr, utils.pretty(AA))
Esempio n. 11
0
def reader(port):

    while port.isOpen():
        data = ''
        length = 0

        data = port.read(1)  #blocks here

        if not data:
            continue

        if data == '\x04':  #event pkt
            data = data + port.read(1)  #event opcode, un-needed
            length = port.read(1)  #read byte length
            data = data + length  #append it to stream
            length = ord(length)  #get int

            for i in range(length):
                data = data + port.read(1)  #the rest

            port.last_rx = data
            port.has_data.set()
            if port.socket:
                port.socket.sendall(data)
            if port.debug:
                print "Got:  %s\n" % pretty(port.last_rx)

        else:
            pass  #types 1,2,3 not applicable
Esempio n. 12
0
    def goal_function(self, **args):
        """
        This is the function that the class exports, and that can be plugged
        into the generic SPSA minimizer.

        Mainly we launch the engine match, take the opposite of the score (because
        we want to *maximize* the score but SPSA is a minimizer). Note that we add
        a regulization term, which helps the convexity of the problem.
        """

        # Create the parameter vector
        theta = {}
        for (name, value) in self.THETA_0.items():
            v = args[name]
            theta[name] = v

        # Calculate the regularization term
        regularization = utils.regulizer(utils.difference(theta, self.THETA_0), 0.01, 0.5)

        # Calculate the score of the minimatch
        score = self.launch_engine(theta)

        result = -score + regularization

        print("**args = " + utils.pretty(args))
        print("goal   = " + str(-result))

        return result
Esempio n. 13
0
    def set_parameters_from_string(self, s):
        """
        This is the function to transform the list of parameters, given as a string,
        into a vector for internal usage by the class.

        Example: "QueenValue 10.0  RookValue 6.0 "
                       would be transformed into the following python vector:
                 {'QueenValue': 10.0, 'RookValue': 6.0}
                       this vector will be used as the starting point for the optimizer
        """

        # Parse the string
        s = ' '.join(s.split())
        list = s.split(' ')
        n = len(list)

        # Create the initial vector, and store it in THETA_0
        self.THETA_0 = {}
        for k in range(0 , n // 2):
            name  = list[ 2*k ]
            value = float(list[ 2*k + 1])
            self.THETA_0[name] = value

        # The function also prints and returns THETA_0
        print("read_parameters :  THETA_0 = " + utils.pretty(self.THETA_0))
        return self.THETA_0
Esempio n. 14
0
def reader(port):
    
    while port.isOpen():
        data = ''
        length = 0
        
        data = port.read(1) #blocks here

        if not data:
            continue
        
        if data == '\x04': #event pkt
            data = data + port.read(1) #event opcode, un-needed
            length = port.read(1) #read byte length
            data = data + length #append it to stream
            length = ord(length) #get int

            for i in range(length):
                data = data + port.read(1) #the rest

            port.last_rx = data
            port.has_data.set()
            if port.socket:
                port.socket.sendall(data)
            if port.debug:
                print "Got:  %s\n" % pretty(port.last_rx)
                    
        else:
            pass #types 1,2,3 not applicable
Esempio n. 15
0
    def test_pretty_dict(self):
        import utils
        Dstr = '''color: blue
shape: square
texture: groovy'''
        D = {'shape': 'square', 'texture': 'groovy', 'color': 'blue'}
        self.assertEqual(Dstr, utils.pretty(D))
Esempio n. 16
0
    def test_pretty_list(self):
        import utils
        Astr = '''ennie
meanie
mightie'''
        A = ['ennie', 'meanie', 'mightie']
        self.assertEqual(Astr, utils.pretty(A))
Esempio n. 17
0
    def update(self, flow):
        url = "{0}/flow".format(self.host)
        _label = flow.get('label')

        if _label:
            for realflow in self:
                if realflow.get('label') == _label:
                    _realid = realflow.get('id')

                    # First delete
                    response = requests.delete(
                        url=url + "/{0}".format(_realid),
                        headers={"content-type": "application/json"})

            # Then add
            response = requests.post(
                url=url,
                json=naked(flow),
                headers={"content-type": "application/json"})

            welldone = response.status_code == 200
            return welldone

        else:
            exceptionmsg = "label not in {0}".format(pretty(flow))
            raise KeyError(exceptionmsg)
    def gen_depend_map(self, test_funcs, drop_env=None, start_node=None):
        dep_graph = {}
        if not start_node:
            start_node = Env()
        dep_graph.setdefault(start_node, {})
        nodes = [start_node]
        widgets = ['Processed: ', Counter(), ' nodes (', Timer(), ')']
        LOGGER.info("Start gen depend map...")
        pbar = ProgressBar(widgets=widgets, max_value=100000)
        pbar.start()
        while nodes:
            node = nodes.pop()
            for func in test_funcs:
                new_node = node.gen_transfer_env(func)
                if new_node is None:
                    continue
                if drop_env and len(new_node) > drop_env:
                    continue
                if new_node not in dep_graph.keys():
                    dep_graph.setdefault(new_node, {})
                    nodes.append(new_node)
                data = dep_graph[node]
                data.setdefault(new_node, set())
                data[new_node].add(func)
            pbar.update(len(dep_graph))

        LOGGER.debug(pretty(dep_graph))
        LOGGER.info('Depend map is %d x %d size', len(dep_graph),
                    len(dep_graph))
        self.dep_graph = dep_graph
        if self._use_map:
            self.build_graph_map()
Esempio n. 19
0
    def update(self, flow):
        url = "{0}/flow".format(self.host)
        _label = flow.get('label')    

        if _label:
            for realflow in self:
                if realflow.get('label') == _label:
                    _realid = realflow.get('id')
            
                    # First delete
                    response = requests.delete(
                        url=url+"/{0}".format(_realid),
                        headers={"content-type": "application/json"})
            
            # Then add
            response = requests.post(
                url=url, 
                json=naked(flow),
                headers={"content-type": "application/json"})

            welldone = response.status_code == 200
            return welldone


        else:
            exceptionmsg = "label not in {0}".format(pretty(flow))
            raise KeyError(exceptionmsg)
Esempio n. 20
0
 def __str__(self):
     response = ""
     for flow in self.flows:
         response += "\"{0}\" ({1}) -> {2}\n\n".\
             format(blue(flow.get('label')),\
                 orange(flow.get('id')), 
                 pretty(flow.get('nodes'))
             )
     return response
Esempio n. 21
0
 def __str__(self):
     response = ""
     for flow in self.flows:
         response += "\"{0}\" ({1}) -> {2}\n\n".\
             format(blue(flow.get('label')),\
                 orange(flow.get('id')),
                 pretty(flow.get('nodes'))
             )
     return response
Esempio n. 22
0
def run(program, gas):

    program.gas = gas
    iterations = 0
    os.system("clear")
    while True:
        print("ITER %i\n" % iterations)
        iterations += 1
        pretty(program)
        program = step(program)
        input()
        os.system("clear")
        if program["gas"] == 0:
            break

    pretty(program)
    print("Exiting main (OutOfGas).")
    return program
Esempio n. 23
0
    def run(self):
        '''
            Return a point which is (hopefully) a minimizer of the goal function f,
            starting from point theta0
            Returns:
                the point (as a dict) which is (hopefully) a minimize of 'f'.
        '''
        k = 0
        theta = self.theta0
        while True:
            if self.constraints is not None:
                theta = self.constraints(theta)
            print("theta = " + utils.pretty(theta))
            c_k = self.c / ((k + 1)**self.gamma)
            a_k = self.a / ((k + 1 + self.A)**self.alpha)
            gradient = self.approximate_gradient(theta, c_k)
            #For steepest descent we update via a constant small step in the gradient direction
            mu = -0.01 / max(1.0, utils.norm2(gradient))
            theta = utils.linear_combinaison(1.0, theta, mu, gradient)

            ## For RPROP, we update with information about the sign of the gradients
            theta = utils.linear_combinaison(1.0, theta, -0.01,
                                             self.rprop(theta, gradient))
            #We then move to the point which gives the best average of goal
            (avg_goal, avg_theta) = self.average_best_evals(30)
            theta = utils.linear_combinaison(0.8, theta, 0.2, avg_theta)

            k = k + 1
            if k >= self.max_iter:
                break

            if (k % 100 == 0) or (k <= 1000):
                (avg_goal, avg_theta) = self.average_evaluations(30)
                print("iter = " + str(k))
                print("mean goal (all) = " + str(avg_goal))
                print("mean theta (all) = " + utils.pretty(avg_theta))

                (avg_goal, avg_theta) = self.average_best_evals(30)
                print('mean goal (best) = ' + str(avg_goal))
                print('mean theta (best) = ' + utils.pretty(avg_theta))
            print(
                '-----------------------------------------------------------')
        return theta
Esempio n. 24
0
def writer(port):
    while True:
        rx_data = port.socket.recv(1024)
        if not rx_data:
            break
        port.write(rx_data)
        port.last_tx = rx_data
        if port.debug:
            print "Sent: %s" % pretty(port.last_tx)

    port.socket.close()
Esempio n. 25
0
def writer(port):
    while True:
        rx_data = port.socket.recv(1024)
        if not rx_data:
            break
        port.write(rx_data)
        port.last_tx = rx_data
        if port.debug:
            print "Sent: %s" % pretty(port.last_tx)

    port.socket.close()
Esempio n. 26
0
File: ent.py Progetto: void4/paragon
def run(program, gas, mem=0):

    program.gas = gas
    program.mem = mem
    iterations = 0
    os.system("clear")
    while True:
        print("ITER %i\n" % iterations)
        iterations += 1
        pretty(program)
        program = step(program)
        #input()
        sleep(0.1)
        os.system("clear")
        if program["status"] > 0:  #program["gas"] == 0 or
            break

    pretty(program)
    print("Exiting main (%s)." % STATUS[program.status])
    return program
Esempio n. 27
0
    def rprop(self, theta, gradient):
        #get the previous g of the RPROP algorithm
        if self.rprop_previous_g != {}:
            previous_g = self.rprop_previous_g
        else:
            previous_g = gradient
        #get the previous delta of the RPROP algorithm
        if self.rprop_previous_delta != {}:
            delta = self.rprop_previous_delta
        else:
            delta = gradient
            delta = utils.copy_and_fill(delta, 0.5)

        p = utils.hadamard_product(previous_g, gradient)
        print('gradient = ' + utils.pretty(gradient))
        print('old_g = ' + utils.pretty(previous_g))
        print('p = ' + utils.pretty(p))

        g = {}
        eta = {}
        for (name, value) in p.items():
            if p[name] > 0: eta[name] = 1.1  #building speed
            if p[name] < 0:
                eta[name] = 0.5  #we have passed a local minima :slow down
            if p[name] == 0: eta[name] = 1.0

            delta[name] = eta[name] * delta[name]
            delta[name] = min(50.0, delta[name])
            g[name] = gradient[name]
        print('g = ' + utils.pretty(g))
        print('eta =' + utils.pretty(eta))
        print('delta = ' + utils.pretty(delta))
        #store the current g and delta for the next call of the RPROP algorithm
        self.rprop_previous_g = g
        self.rprop_previous_delta = delta
        #calculate the update for the current RPROP
        s = utils.hadamard_product(delta, utils.sign(g))
        print('sign(g) = ' + utils.pretty(utils.sign(g)))
        print(' s = ' + utils.pretty(s))
        return s
Esempio n. 28
0
 def do_volume_detach(self, args):
     '''Detach volume.'''
     body = self.client.volume_detach(args.volume)
     utils.pretty(head='VM|VOLUME|STATUS', body=body)
Esempio n. 29
0
 def do_volume_delete(self, args):
     '''Delete volume.'''
     body = self.client.volume_delete(args.volume)
     utils.pretty(head='VOLUME|STATUS', body=body)
    def _print_tax_details(self, report, reportinglevel, CGTCalc,  net_profit, open_value, close_value,
                          groupid, gbp_net_profit, open_comm, close_comm, open_tax, close_tax, allowable_costs,
                          disposal_proceeds, commissions, taxes):
    
        code=self.closingtrade.Code
        currency=self.closingtrade.Currency
        
        assetclass=(getattr(self.closingtrade, "AssetClass",""))
            
        datelabel=self.closingtrade.Date.strftime('%d/%m/%Y') 
    
    
        ## quantity will be negative for a closing sale / opening buy
        sign_quantity=self.closingtrade.SignQuantity
    
        abs_quantity=abs(sign_quantity)
    
    
        average_open_value= abs(open_value) / abs_quantity
        average_close_value= abs(close_value) / abs_quantity
    
    
        ## Labelling
        if sign_quantity<0:
            labels=("BUY", "SELL")
            signs=("-", "")
        else:
            labels=("OPEN SHORT", "CLOSE SHORT")
            signs=("+","-")
    
        if net_profit<0:
            pandl="LOSS"
        else:
            pandl="PROFIT" 



    
        inreport=reporting_detail(reportinglevel)
        
        if inreport.extraline():
            report.write(star_line())
            report.write("\n")
        
        if CGTCalc:

            """
            Example of CGT output
            1. SELL: 40867 XYZ (Stock) on 17/12/2013 at EUR0.911 gives LOSS of XYZ 8,275.00 equals GBP 5,000
            
            (or CLOSE SHORT:  . Matches with OPEN SHORT: )
            
            Matches with: 
            BUY: SAME DAY TRADES.
            TRADES WITHIN 30 days 
            SECTION 104 HOLDING. 40867 shares of XYZ bought at average price of EUR1.11333
            
            """
            
            if inreport.showbrieftrade():
                
                report.write("%d: %s %d %s %s on %s at %s %s each gives %s of %s %s equals GBP %s\n" % \
                      (groupid, labels[1], int(abs_quantity), code, assetclass, datelabel, currency, pretty(average_close_value), 
                       pandl, currency, pretty(round(net_profit)), pretty(gbp_net_profit)))

            if inreport.showextra():
                report.write(" Commission %s %s and taxes %s %s on %s\n"% (currency, pretty(close_comm), currency, pretty(close_tax),labels[1]))

            if inreport.listtrades():
                report.write("Trade details:"+self.closingtrade.__repr__()+"\n")
    
            if inreport.showextra():
                report.write("Total allowable cost %s %s   Total disposal proceeds %s %s\n" % \
                     (currency, pretty(allowable_costs), currency, pretty(disposal_proceeds))) 
                
                report.write("\nMatches with:\n")            

            ## Calculation strings, build up to show how we calculated our profit or loss
            calc_string="%s(%d*%s) - %s - %s " % \
            (signs[1], int(abs_quantity), pretty(average_close_value, commas=False), pretty(close_comm), pretty(close_tax))
            
                
            if len(self.sameday)>0:
                sameday_quantity=int(round(abs(self.sameday.final_position())))
                sameday_avg_value=self.sameday.average_value()
                sameday_tax=sum([trade.Tax for trade in self.sameday])
                sameday_comm=sum([trade.Commission for trade in self.sameday])

                sameday_calc_string="%s(%d*%s) - %s - %s " % \
                    (signs[0], sameday_quantity, pretty(sameday_avg_value, commas=False), pretty(sameday_comm), pretty(sameday_tax))

                calc_string=calc_string+sameday_calc_string

                if inreport.showextra():
                        
                    report.write("SAME DAY TRADE(S) Matches with %s of %d %s at average of %s %s each \n Commissions %s %s Taxes %s %s \n" % \
                      (labels[0], sameday_quantity, code, currency, pretty(sameday_avg_value), currency, pretty(sameday_comm), currency, pretty(sameday_tax)))

                if inreport.listtrades():
                    report.write("\nTrades:\n")
                    self.sameday.print_trades_and_parents(report)
                            
                
            if len(self.withinmonth)>0:
                withinmonth_quantity=int(abs(round((self.withinmonth.final_position()))))
                withinmonth_avg_value=self.withinmonth.average_value()
                withinmonth_tax=sum([trade.Tax for trade in self.withinmonth])
                withinmonth_comm=sum([trade.Commission for trade in self.withinmonth])
                
                tradecount=len(self.withinmonth)
                (startdate,enddate)=self.withinmonth.range_of_dates()

                withinmonth_calc_string="%s(%d*%s) - %s - %s " % \
                    (signs[0], withinmonth_quantity, pretty(withinmonth_avg_value, commas=False), pretty(withinmonth_comm), pretty(withinmonth_tax))

                calc_string=calc_string+withinmonth_calc_string
                
                if inreport.showextra():
    
                    report.write("SUBSEQUENT %d TRADE(S) Within 30 days between %s and %s: Matches with %s of %d %s at of %s %s each \n Commissions %s %s Taxes %s %s  \n" % \
                      (tradecount, str(startdate.date()), str(enddate.date()), labels[0], withinmonth_quantity, code, currency, pretty(withinmonth_avg_value), currency, pretty(withinmonth_comm), currency, pretty(withinmonth_tax)))

                if inreport.listtrades():

                    report.write("\nTrades:\n")
                    self.withinmonth.print_trades_and_parents(report)

            
            if len(self.s104)>0:
                s104_quantity=int(round(abs(self.s104.final_position())))
                s104_avg_value=self.s104.average_value()
                s104_tax=sum([trade.Tax for trade in self.s104])
                s104_comm=sum([trade.Commission for trade in self.s104])

                tradecount=len(self.s104)
                (startdate,enddate)=self.s104.range_of_dates()
                parent_quantity=self.s104.total_including_parents()

                s104_calc_string="%s(%d*%s) - %s - %s " % \
                    (signs[0], s104_quantity, pretty(s104_avg_value, commas=False), pretty(s104_comm), pretty(s104_tax))

                calc_string=calc_string+s104_calc_string

                if inreport.showextra():

                    report.write("PRO-RATA SECTION 104: Quantity %f %s allocated from total holding of %s, made up of %d trades between %s and %s\n At average value of %s %s Commissions %s %s Taxes %s %s  \n" % \
                      ( s104_quantity, code, pretty(parent_quantity), len(self.s104), str(startdate.date()), str(enddate.date()), currency, pretty(s104_avg_value), currency, pretty(s104_comm), currency, pretty(s104_tax)))


                if inreport.listtrades():
                    report.write("\nTrades:\n")
                    self.s104.print_trades_and_parents(report)


            if inreport.showcalcs():
                
                ## Show full calculations
                report.write("\nCALCULATION: "+calc_string+" = %s \n" % pretty(round(net_profit)))
            
        else:
            """
            Example of non CGT output
            
            SELL 40867 RSA (Stock) on 17/12/2013 at EUR0.911 gives net LOSS of EUR 8,275 equals GBP5,000.0
            AVERAGE price EUR .  Total commission: EUR   Total tax:  EUR 
            """
            if inreport.showbrieftrade():
            
                report.write("%d: %s of %d %s %s on %s at %s %s each Net %s of %s %s equals GBP %s\n" % \
                      (groupid, labels[1], int(abs_quantity), code, assetclass, datelabel, currency, pretty(average_close_value),
                       pandl, currency, pretty(round(net_profit)), pretty(gbp_net_profit)))                       

            if inreport.listtrades():
                
                report.write("Trade details:"+self.closingtrade.__repr__()+"\n")
                
            tradecount=len(self.s104)
            (startdate,enddate)=self.s104.range_of_dates()
            parent_quantity=self.s104.total_including_parents()

            ## Calculation strings, build up to show how we calculated our profit or loss
            calc_string="%s(%d*%s) - %s - %s " % \
            (signs[1], int(abs_quantity), pretty(average_close_value, commas=False), pretty(close_comm), pretty(close_tax))


            closing_calc_string="%s(%d*%s) - %s - %s " % \
                (signs[0], int(abs_quantity), pretty(average_open_value, commas=False), pretty(open_comm), pretty(open_tax))

            calc_string=calc_string+closing_calc_string

            if inreport.showextra():
    
                report.write("\n%s at average value %s each between %s and %s.  Total round-trip commission %s %s, and taxes %s %s" % \
                       (labels[0], pretty(average_open_value), str(startdate.date()), str(enddate.date()), currency, pretty(commissions), currency, pretty(taxes)))
        
            
            if inreport.listtrades():
                ## Trade by trade breakdown
                report.write("\nTrades:\n")
                self.s104.print_trades_and_parents(report)

            if inreport.showcalcs():
                ## calculations
                report.write("\nCALCULATION: "+calc_string+" = %s \n" % pretty(round(net_profit)))

        if inreport.extraline():
            report.write("\n")
Esempio n. 31
0
 def __repr__(self):
     return str(utils.pretty(self))
Esempio n. 32
0
 def do_snapshot_create(self, args):
     '''Create a SNAPSHOT'''
     body = self.client.snapshot_create(vm=args.vm,
                                        desc=args.desc)
     utils.pretty(head='SNAPSHOT|STATUS', body=body)
Esempio n. 33
0
 def do_snapshot_list(self, args):
     '''List snapshots.'''
     body = self.client.snapshot_list()
     utils.pretty(head='SNAPSHOT|STATUS|DESC|OWNER', body=body)
Esempio n. 34
0
 def do_vlan_delete(self, args):
     '''Delete VLAN.'''
     body = self.client.vlan_delete(vlan=args.vlan)
     utils.pretty(head='VLAN|STATUS', body=body)
Esempio n. 35
0
 def do_image_delete(self, args):
     '''Delete image.'''
     body = self.client.image_delete(image=args.image)
     utils.pretty(head='IMAGE|STATUS', body=body)
Esempio n. 36
0
 def do_image_list(self, args):
     '''List images.'''
     body = self.client.image_list()
     utils.pretty(head='IMAGE|SIZE|OS|DESC|OWNER', body=body)
Esempio n. 37
0
 def do_vm_delete(self, args):
     '''Delete virtual machine.'''
     body = self.client.vm_delete(vm=args.vm)
     utils.pretty(head='VM|STATUS', body=body)
Esempio n. 38
0
 def do_vm_list(self, args):
     """List virtual machines."""
     body = self.client.vm_list()
     head = 'VM|IMAGE|IP|NAME|VXLAN|STATUS|VNC'
     utils.pretty(head=head, body=body)
 def brief(self):
     return "ID %s Quantity %s" %   (getattr(self, "TradeID",""), pretty(self.SignQuantity))
Esempio n. 40
0
 def __str__(self):
     return pretty(self)
Esempio n. 41
0
 def do_volume_attach(self, args):
     '''Attach volume to VM.'''
     body = self.client.volume_attach(
         volume=args.volume, vm=args.vm)
     utils.pretty(head='VM|VOLUME|STATUS', body=body)
 def brief(self):
     return "ID %s Quantity %s" %   (getattr(self, "TradeID",""), pretty(self.SignQuantity))
 def __repr__(self):
     
     return "ID %s Code %s Date %s Quantity %s Price %s Value per block %s" %  \
 (getattr(self, "TradeID",""), self.Code, str(self.Date), pretty(self.SignQuantity), 
  pretty(self.Price), pretty(abs(self.Value/self.SignQuantity)))
Esempio n. 44
0
 def do_vlan_attach(self, args):
     '''Attach VLAN to VM.'''
     body = self.client.vlan_attach(
         vlan=args.vlan,
         vm=args.vm)
     utils.pretty(head='VM|VLAN|STATUS', body=body)
Esempio n. 45
0
    def run(self):
        """
        Return a point which is (hopefully) a minimizer of the goal
        function f, starting from point theta0.

        Returns:
            The point (as a dict) which is (hopefully) a minimizer of "f".
        """

        k = 0
        theta = self.theta0

        while True:
            k = k + 1

            self.iter = k

            if self.constraints is not None:
                theta = self.constraints(theta)

            #print("theta  = " + utils.pretty(theta))

            c_k = self.c / (k**self.gamma)
            a_k = self.a / ((k + self.A)**self.alpha)

            gradient = self.approximate_gradient(theta, c_k)

            #print(str(k) + " gradient = " + utils.pretty(gradient))
            # if k % 1000 == 0:
            # print(k + utils.pretty(theta) + "norm2(g) = " + str(utils.norm2(gradient)))
            # print(k + " theta = " + utils.pretty(theta))

            ## For SPSA we update with a small step (theta = theta - a_k * gradient)
            ## theta = utils.linear_combinaison(1.0, theta, -a_k, gradient)

            ## For steepest descent we update via a constant small step in the gradient direction
            mu = -0.01 / max(1.0, utils.norm2(gradient))
            theta = utils.linear_combinaison(1.0, theta, mu, gradient)

            ## For RPROP, we update with information about the sign of the gradients
            theta = utils.linear_combinaison(1.0, theta, -0.01,
                                             self.rprop(theta, gradient))

            ## We then move to the point which gives the best average of goal
            (avg_goal, avg_theta) = self.average_best_evals(30)
            theta = utils.linear_combinaison(0.98, theta, 0.02, avg_theta)

            if (k % 10 == 0):
                (avg_goal, avg_theta) = self.average_evaluations(30)
                print("iter = " + str(k))
                print("mean goal (all)   = " + str(avg_goal))
                print("mean theta (all)  = " + utils.pretty(avg_theta))

                (avg_goal, avg_theta) = self.average_best_evals(30)
                print("mean goal (best)  = " + str(avg_goal))
                print("mean theta (best) = " + utils.pretty(avg_theta))
                print(
                    "-----------------------------------------------------------------"
                )

            if k >= self.max_iter:
                break

        return theta
Esempio n. 46
0
 def do_snapshot_delete(self, args):
     '''Delete a SNAPSHOT'''
     body = self.client.snapshot_delete(snapshot=args.snapshot)
     utils.pretty(head='SNAPSHOT|STATUS', body=body)
Esempio n. 47
0
 def do_vlan_list(self, args):
     '''List vlan.'''
     body = self.client.vlan_list()
     # NETWORK|NETMASK|GATEWAY|START_IP|END_IP
     utils.pretty(head='VLAN|DESC|OWNER',
                  body=body)
 def __repr__(self):
     
     return "ID %s Code %s Date %s Quantity %s Price %s Value per block %s" %  \
 (getattr(self, "TradeID",""), self.Code, str(self.Date), pretty(self.SignQuantity), 
  pretty(self.Price), pretty(abs(self.Value/self.SignQuantity)))
Esempio n. 49
0
		raise NotImplementedError("Not handled type: %r" % (ast,))

if __name__ == "__main__":
	p = argparse.ArgumentParser()
	p.add_argument("source")
	args = p.parse_args()

	with open(args.source) as f:
		source = f.read()

	ast = parsing.parse(source)

	lowerer = Lowerer()
	lowerer.add_code_block(lowerer.top_level.root_block, ast)

	print utils.pretty(lowerer.top_level)

	print "=" * 20, "Doing inference."

	# Define a global typing context with an entry for nil.
	import prelude
	root_gamma = prelude.make_gamma()

	# Do inference.
	inf = inference.Inference()
	inf.infer_code_block(root_gamma, lowerer.top_level.root_block)

	print "=" * 20, "Inference complete."

	print utils.pretty(lowerer.top_level)
Esempio n. 50
0
def vector_to_file(vector, file_name, action):
    string = ','.join(pretty(_) for _ in vector)
    with open(file_name, action) as file:
        return file.write(string + '\n')
Esempio n. 51
0
 def do_volume_list(self, args):
     '''List volume.'''
     body = self.client.volume_list()
     utils.pretty(
         head='VOLUME|SIZE|DESC|VM|DEVICE|BOOTABLE|STATUS', body=body)
Esempio n. 52
0
        results = ga.get(dimensions, metrics, filters, start_date, end_date)

        return results


def syntax(emsg=None):

    prog = os.path.basename(sys.argv[0])
    ws = ' ' * len(prog)
    if emsg:
        print emsg

    print
    print '  %s <dimensions> <metrics> <filters> <start_date> <end_date>' \
        % prog
    print
    print '  Eq.:'
    print
    print '      %s ga:date ga:visits,ga:bounces ga:channelGrouping==Direct 2daysAgo 1daysAgo' % prog
    print
    print "      %s ga:date ga:transactions,ga:transactionRevenue '' 2016-11-01 2016-11-07" % prog
    print
    print "      %s ga:country,ga:region,ga:city ga:transactions,ga:transactionRevenue 'ga:channelGrouping==Directga:channelGrouping==Paid Search,ga:channelGrouping==Organic Search' 2daysAgo 1daysAgo" % prog
    print

    sys.exit(1)


if __name__ == '__main__':
    print pretty(GoogleAnalytics().process())
Esempio n. 53
0
 def test_pretty_str(self):
     import utils
     str = 'This is a string'
     self.assertEqual(str, utils.pretty(str))