def reco():

    property_name = request.form.get('property_name')
    property_code = request.form.get('property_code')
    flag_name = request.form.get('flag_name')
    num_of_rooms = request.form.get('num_of_rooms', type=int)
    location_type = request.form.get('location_type')
    state = request.form.get('state')
    revenue = request.form.get('revenue', type=float)
    profit_margin = request.form.get('profit_margin', type=float)
    occupancy_rate = request.form.get('occupancy_rate', type=float)

    store = Store(property_name, property_code, flag_name, num_of_rooms,
                  revenue, profit_margin, occupancy_rate, location_type, state)
    cluster = model.predict(store)
    spor = model.predict_spor(store)
    profit_margin = model.predict_profit_margin(store)
    stores = model.predict_comparable_stores(store, 5)
    store_hat = store.upgrade_to(spor=spor, profit_margin=profit_margin)

    return render_template("reco.html",
                           store=store,
                           cluster=cluster,
                           store_hat=store_hat,
                           stores=stores.tolist())
示例#2
0
 def _getDefaultStore(self):
     query = Store.gql('where name = :name', name='default')
     store = query.get()
     if store == None:
         store = Store(name='default', merchantid='0', useSandbox='true')
         store.put()
     return store
示例#3
0
class GenFE(object):
    '''
  generate fixed number entity
  '''
    def __init__(self, ent, ent_size, db):
        self.ent = ent
        self.ent_size = ent_size
        self.db = db
        self.start_idx = 0
        self.db_handler = Store(self.db)
        self.db_handler.connect()

    def set_start_idx(self, n):
        self.start_idx = n

    def start(self, max_id):
        # max_id: the max id should be generated
        count = max_id - start_idx + 1
        if count < 1:
            return
        data = gen_data(self.ent, self.ent_size, self.start_idx, count)
        self.start_idx += count
        # dump data to db
        name = self.ent['alias']
        sql = 'insert into %s values (?' % (name)
        if 'tag' in self.ent:
            sql = sql + ', ?'
        if 'attr' in self.ent:
            sql = sql + ', ?' * len(self.ent['attr'])
        sql = sql + ')'
        try:
            self.db_handler.insert_many(sql, data)
        except Exception as e:
            raise e
        print('[Node Generation]: Name %s, Max ID %s' % (name, max_id))
示例#4
0
 def __init__(self, ent, ent_size, db):
     self.ent = ent
     self.ent_size = ent_size
     self.db = db
     self.start_idx = 0
     self.db_handler = Store(self.db)
     self.db_handler.connect()
示例#5
0
  def __init__(self, db, dic, parent_conn, src_dic, ent_size, tgt_dic=None, mode='local'):
    '''
    db  : db name
    dic : the relation dict of the config
    parent_conn: server conn
                 1, rel data
                 2, src nodes: n
                 3, tgt nodes: m
    src_dic : src node config dict
    ent_size: the number of nodes of each entity
    tgt_dic : tgt node config dict
             if is None, then tgt_dic == src_dic, e.g. user -> user
    mode : local (default), dump edge locally
         : u-level, dump edge and node in parent process
    '''
    self.parent_conn = parent_conn
    self.rel_dict = dic
    self.db_name  = db
    self.src_dic = src_dic
    self.tgt_dic = tgt_dic
    self.mode = mode
    self.ent_size = ent_size
    self.db_handler  = Store(db)
    self.db_handler.connect()
    # parameters of in/out distributions
    # TODO: other type of distribution
    if dic['in']['type'] == 'power_law':
      mind, maxd, midd = 0, -1, -1
      if 'min_degree' in dic['in']:
        mind = dic['in']['min_degree']
      if 'max_degree' in dic['in']:
        maxd = dic['in']['max_degree']
      if 'mid_degree' in dic['in']:
        midd = dic['in']['mid_degree']
      if isinstance(dic['in']['lambd'], list):
        self.indistr_ins = PWL(0, dic['in']['lambd'][0], dic['in']['lambd'][1], mind, maxd, midd)
      else:
        self.indistr_ins = PWL(0, dic['in']['lambd'], min_degree=mind, max_degree=maxd, mid_degree=midd)
    elif dic['in']['type'] == 'uniform':
      self.indistr_ins = Uniform(0, dic['in']['min'], dic['in']['max'])

    if dic['out']['type'] == 'power_law':
      mind, maxd, midd = 0, -1, -1
      if 'min_degree' in dic['out']:
        mind = dic['out']['min_degree']
      if 'max_degree' in dic['out']:
        maxd = dic['out']['max_degree']
      if 'mid_degree' in dic['out']:
        midd = dic['out']['mid_degree']
      if isinstance(dic['out']['lambd'], list):
        self.outdistr_ins = PWL(0, dic['out']['lambd'][0], dic['out']['lambd'][1], mind, maxd, midd)
      else:
        self.outdistr_ins = PWL(0, dic['out']['lambd'], min_degree=mind, max_degree=maxd, mid_degree=midd)
    elif dic['out']['type'] = 'uniform':
      self.outdistr_ins = Uniform(0, dic['out']['min'], dic['out']['max'])
示例#6
0
 def __init__(self, dic, db, in_, out, cutoff=6):
     '''
 dic: the dict info of one type edge 
 db : db file name, store the generated graph data
 '''
     self.rel_dict = dic
     self.db_name = db
     self.db_handler = Store(db)
     self.db_handler.connect()
     self.cutoff = cutoff
     self.in_cnt = in_
     self.out_cnt = out
示例#7
0
def make_stores():
    """ Make fake stores and load into database. """

    print 'Making Stores...'

    # Since I like to run this file over and over again:
    Store.query.delete()

    for row in open('misc/seed_stores.txt'):
        row = row.rstrip()
        store_id, name, address, city, state, zipcode, phone = row.split('\t')
        store_id = "{:0>3}".format(store_id)
        zipcode = "{:0>5}".format(zipcode)
        district_id = get_random_district()

        # Instantiate a store using Store class in model.py! Woohoo!
        store = Store(store_id=store_id,
                      name=name,
                      address=address,
                      phone=phone,
                      city=city,
                      state=state,
                      zipcode=zipcode,
                      district_id=district_id)

        # Add to db
        db.session.add(store)

    db.session.commit()
示例#8
0
def check_order_store_quantity(store_id, oid):
    result = 0
    items = OrderItem.select().where(OrderItem.order == oid)
    r = 0
    if store_id:
        for i in items:
            if i.product.is_store == 1:  # and i.product.store.id == int(store_id)
                r += 1
            else:
                r += check_store_product_quantity(store_id,
                                                  i.product_standard.id)
        if r == items.count():
            result = 1
    else:
        list = []
        order = Order.get(Order.id == oid)
        store = Store.select().where(Store.status == 1)
        sid = 0
        for s in store:
            ss = getDistanceAS(order.take_address.replace(' ', ''), s.id)
            if ss['flag'] == 1:
                list.append(float(ss['data']))
                if float(ss['data']) < setting.PeiSongDistance:
                    sid = s.id
        for i in items:
            if i.product.is_store == 1 and i.product.store.id == sid:
                r += 1
            else:
                r += check_store_product_quantity(sid, i.product_standard.id)
        if r == items.count():
            result = 1
    return result
示例#9
0
    def fill_product(self, dictcat):
        """Fill the table products and store."""

        if self.session.query(Products.id).count() == 0:
            for key in dictcat.keys():
                select_product.extract(key, dictcat[key])
                for prod in select_product.product_list:
                    print(f"Downloading products: {prod}")
                    if prod[0] and prod[1] != 'NULL' or '':
                        newstore = Store(name_store=prod[3])
                        self.session.add(newstore)
                        self.session.commit()

                        store = self.session.query(Store.id).count()
                        newproduct = Products(name=prod[0],
                                              name_nut=prod[1],
                                              name_url=prod[2],
                                              store_name=prod[3],
                                              categorie_id=prod[4],
                                              store_id=store)
                        self.session.add(newproduct)
                        self.session.commit()
                        select_product.product_list.remove(prod)
                    else:
                        pass
        else:
            pass
示例#10
0
文件: store.py 项目: scaperow/carive
    def post(self):
        username = self.get_argument("username", None)
        password = self.get_argument("password", None)

        if username and password:
            try:
                user = AdminUser.get(AdminUser.username == username)
                if user.check_password(password):
                    if user.isactive == 1:
                        if not user.store:
                            storeid = 0
                        else:
                            storeid = user.store
                        if not user.front_user:
                            frontuserid = 0
                        else:
                            frontuserid = user.front_user
                        qstore = Store.select().where(Store.id == storeid)
                        qfront_user = User.select().where(
                            User.id == frontuserid)
                        if qstore.count() > 0 and qfront_user.count() > 0:
                            user.updatesignin()
                            self.session['store'] = user
                            self.session.save()
                            self.redirect("/store/index")
                            return
                        else:
                            self.flash("此帐户未关联经销商或经销商未绑定前台用户。")
                    else:
                        self.flash("此账户被禁止登录,请联系管理员。")
                else:
                    self.flash("密码错误")
            except Exception, e:
                print e
                self.flash("此用户不存在")
示例#11
0
def create():
    try:
        store=Store(
            code= request.json['code'] or None,
            name=request.json['name'], 
            online=request.json['online'] or False,
            website=request.json['website'] or None,
            longitude=request.json['longitude'] or None,
            latitude=request.json['latitude'] or None,
            source='OWN',
            source_id=request.json['source_id'] or None
        )
        database.session.add(store)
        database.session.commit()
        return jsonify({ 'status': 'OK', 'store': store.serialize() }), 201
    except Exception as e:
	    return jsonify({ 'status': 'ERROR', 'error': str(e) }), 500
示例#12
0
 def delete(self, name):
     store = Store.find_by_name(name)
     if store:
         try:
             store.delete()
         except Exception:
             return {'message': 'Unable to delete store at this time.'}, 500
     else:
         return {'message': 'Store deleted'}
示例#13
0
 def render(self):
     client_store = self.handler.get_secure_cookie('store', None)
     if client_store:
         sid = simplejson.loads(client_store)
         s = Store.get(Store.id == sid)
         name = s.name
     else:
         name = u'实体店'
     return name
示例#14
0
 def setUp(self):
     super(TestCRUDController, self).setUp()
     self.store = Store()
     self.app = self.parent = cimarron.skin.Application()
     self.widget = CRUDController.fromXmlFile('test/testCrud.xml')
     self.widget.parent = self.parent
     self.window = self.widget.window
     self.widget.store = self.store
     person = Person.__values__[0]
     self.setUpControl(target=person, attr=None)
示例#15
0
文件: store.py 项目: scaperow/carive
 def post(self):
     result = {"flag": 0, "msg": "", "data": ""}
     try:
         args = simplejson.loads(self.request.body)
         username = args["username"]
         password = args["password"]
         if username and password:
             quser = AdminUser.select().where(
                 AdminUser.username == username)
             if quser.count() > 0 and quser[0].check_password(password):
                 user = quser[0]
                 if user.isactive == 1:
                     if self.vrole("J", user.roles):
                         if not user.store:
                             storeid = 0
                         else:
                             storeid = user.store
                         if not user.front_user:
                             frontuserid = 0
                         else:
                             frontuserid = user.front_user
                         qstore = Store.select().where(Store.id == storeid)
                         qfront_user = User.select().where(
                             User.id == frontuserid)
                         if qstore.count() > 0 and qfront_user.count() > 0:
                             user.updatesignin()
                             result["flag"] = 1
                             result["data"] = {
                                 'adminid': user.id,
                                 'storeid': qstore[0].id,
                                 'front_user': user.front_user,
                                 'storename': qstore[0].name,
                             }
                         else:
                             result["flag"] = 0
                             result["msg"] = "此帐户未关联经销商或经销商未绑定前台用户。"
                     else:
                         result["flag"] = 0
                         result["msg"] = "此账户没有经销商的登录权限。"
                 else:
                     result["flag"] = 0
                     result["msg"] = "此账户被禁止登录,请联系管理员。"
             else:
                 if quser.count() > 0:
                     result["flag"] = 0
                     result["msg"] = "密码错误。"
                 else:
                     result["flag"] = 0
                     result["msg"] = "此用户不存在"
         else:
             result["flag"] = 0
             result["msg"] = "请输入用户名或者密码"
     except Exception, e:
         result["flag"] = 0
         result["msg"] = e
示例#16
0
def estimateR_weighted(S, W, D, R0):
    '''
    estimates the update of the rotation matrix for the second part of the iterations
    :param S : shape
    :param W : heatmap
    :param D : weight of the heatmap
    :param R0 : rotation matrix
    :return: R the new rotation matrix
    '''

    A = np.transpose(S)
    B = np.transpose(W)
    X0 = R0[0:2, :]
    store_E = Store()

    [m, n] = A.shape
    p = B.shape[1]

    At = np.zeros([n, m])
    At = np.transpose(A)

    # we use the optimization on a Stiefel manifold because R is constrained to be othogonal
    manifold = Stiefel(n, p, 1)

    ####################################################################################################################
    def cost(X):
        '''
        cost function of the manifold, the cost is trace(E'*D*E)/2 with E = A*X - B or store_E
        :param X : vector
        :return f : the cost
        '''

        if store_E.stored is None:
            store_E.stored = np.dot(A, np.transpose(X)) - B

        E = store_E.stored
        f = np.trace(np.dot(np.transpose(E), np.dot(D, E))) / 2

        return f

    ####################################################################################################################

    # setup the problem structure with manifold M and cost
    problem = Problem(manifold=manifold, cost=cost, verbosity=0)

    # setup the trust region algorithm to solve the problem
    TR = TrustRegions(maxiter=10)

    # solve the problem
    X = TR.solve(problem, X0)

    #print('X : ',X)
    return np.transpose(X)  # return R = X'
示例#17
0
    def setUp(self):
        super(TestEditor, self).setUp()
        self.store = Store()
        self.parent = self.window = cimarron.skin.Window()
        # self.widget = cimarron.skin.Editor(store=self.store,
        #                                    attributes=['name', 'surname'])
        self.widget = Editor.fromXmlFile('test/editor.xml')
        self.widget.parent = self.parent
        self.widget.store = self.store
        self.entry = self.widget.entries.children[0]

        self.setUpControl(target=Person('Marcos', 'Dione'), attr=None)
示例#18
0
class Main(object):
  '''
  main procedure
  Input : scheme
  Output: social network data, saved to sqlite
  '''
  def __init__(self, scheme):
    self.scheme  = scheme
    self.db_name = scheme['alias'] + '.db'
    self.db_handler = Store(self.db_name)
    self.db_handler.connect()

  def create_db(self):
    try:
      crt_db_sql = tbl_sql(self.scheme)
      # with open('ddl.sql', 'w') as f:
      #   f.write(crt_db_sql)
      self.db_handler.execute_script(crt_db_sql)
      print('Create db %s done' % self.db_name)
    except Exception as e:
      raise e

  def clear_db(self):
    try:
      dlt_sql = delete_sql(self.scheme)
      self.db_handler.execute_script(dlt_sql)
      print('clear db %s done' % (self.db_name))
    except Exception as e:
      raise e

  def process(self):
    pass
示例#19
0
 def __init__(self, config, lowtran, hightran, device):
     self.config = config
     self.device = device
     self.lownet = lowPolicy(config.get('feature_dim'),
                             config.get('action_dim'),
                             config.get('num_options'),
                             config.get('hidden_dim')).double().to(
                                 self.device)
     self.highnet = OptionNet(config.get('num_options'),
                              config.get('feature_dim'),
                              config.get('hidden_dim')).double().to(
                                  self.device)
     self.lowmemory = Store(lowtran, config.get('buffer_cap'),
                            config.get('batch_size'))
     self.highmemory = Store(hightran, config.get('buffer_cap'),
                             config.get('batch_size'))
     self.lowoptimizition = torch.optim.Adam(self.lownet.parameters(),
                                             lr=config.get('low_lr'))
     self.highoptimizition = torch.optim.Adam(self.highnet.parameters(),
                                              lr=config.get('high_lr'))
     self.start_list = config.get('start_list')
     self.end_list = config.get('end_list')
示例#20
0
def create_store(store_name, address_id, store_website, web_only_indicator):
    """Create and return a store."""

    store = Store(store_name=store_name,
                address_id = address_id,
                store_website = store_website,
                web_only_indicator = web_only_indicator
                )
    

    db.session.add(store)
    db.session.commit()

    return store
示例#21
0
def store_add():
    if request.method == 'POST':
        if request.form.get('store_id'):
            store = get_object_or_404(Store, Store.id == request.form['store_id'])
            store.name = request.form['name']
            store.save()
            flash('Store #%d updated successfully.' % (store.id,), 'success')
        else:
            name = request.form['name']
            if name == "":
                flash('Store needs to have a name', 'danger')
            else:
                store = Store.create(name=name)
                flash('Store %s created successfully.' % (name,), 'success')
        return jsonify(success=True) 
    return render_template('store.html')
    def post(self, name):
        if Item.find_by_name(name):
            return {'message': 'item already exists'}

        data = ItemResource.parser.parse_args()

        if Store.find_by_id(data['store_id']) is None:
            return {'message': 'invalid store_id'}

        item = Item(name, data['price'], data['store_id'])
        try:
            item.persist()
        except Exception:
            return {'message': 'error occurred while creating item'}, 500
        else:
            return item.json(), 201
示例#23
0
    def post(self, name):
        if Store.find_by_name(name):
            return {'message': 'Store already exists.'}, 400

        store = Store(name)
        try:
            store.persist()
        except Exception:
            return {'message': 'error occurred while creating store'}, 500
        else:
            return store.json(), 201
示例#24
0
def add_nancy():
    """ Adds me & corp to the employee & store tables """

    corp_store = Store(store_id='999',
                       name='Corporate Headquarters',
                       address='400 Valley Drive',
                       city='Brisbane',
                       state='CA',
                       zipcode='94005', phone='(415) 555-1234',
                       district_id='D99')

    nancy = Employee(emp_id='09332', fname='Nancy',
                     lname='Reyes', ssn='123-45-6789',
                     password='******', store_id='999', pos_id='99-HQ')

    db.session.add_all([nancy, corp_store])
    db.session.commit()
示例#25
0
def optimizer_R_v1(W, D, S, R0):
    """
    :param W: heatmap constant
    :param D: weight of the keypoints
    :param S: shape of the object
    :param R0: initial R

    :return : the optimal R with fixed T and s
    the cost is ||(W-(RS))*sqrt(D)|| but in fact is the scale factor is already taken into account in S and T is taken into account in W
    """

    # this store object is needed because the manifold optimizer do not works if it is not implemented like that
    store = Store()

    # -------------------------------------COST FUNCTION-------------------------------------
    def cost(R):
        """
        :param R: rotation matrix variable
        :return : ||(W-(RS))*D^1/2||^2 = tr((W-(RS))*D*(W-(RS))')
        """

        if store.stored is None:
            store.stored = W - np.dot(R, S)

        X = store.stored
        f = np.trace(np.dot(X, np.dot(D, np.transpose(X)))) / 2

        return f

    # ----------------------------------------------------------------------------------------

    # we use the optimization on a Stiefel manifold because R is constrained to be othogonal
    manifold = Stiefel(3, 2, 1)

    # setup the problem structure with manifold M and cost
    problem = Problem(manifold=manifold, cost=cost, verbosity=0)

    # setup the trust region algorithm to solve the problem
    TR = TrustRegions(maxiter=15)

    # solve the problem
    R_opt = TR.solve(problem, R0)

    return np.transpose(R_opt)
示例#26
0
def virtual_creation():
    with dm.session_scope() as db:
        stores = []
        for i in range(STORES_NUM):
            store = Store(name="Tienda {}".format(i),
                          latitude=0.0,
                          longitude=0.0)
            offers = []
            for j in range(PRODUCTS_PER_STORE):
                pr = Product(
                    store=store,
                    name="Product {},{}".format(i, j),
                    img_url=
                    "http://www.lavozlibre.com/userfiles/2a_decada/image/FOTOS%202013/04%20ABRIL%202013/02%20ABRIL%202013/yogures.jpg",
                    price="3€")
                offers.append(Offer(product=pr, offer_price="2€", store=store))
                store.products.append(pr)
            db.add_all(offers)
            stores.append(store)
        db.add_all(stores)
示例#27
0
文件: map.py 项目: scaperow/carive
def getMinDistanceStore(address):
    result = {"flag": 0, "msg": "", "data": ""}
    try:
        if address:

            if address.count('枫林绿洲') > 0:
                address = address.replace('小区', '')
            qstore = Store.select().where((Store.status == 1)
                                          & (Store.storetype == 0))
            point = getPointByAddress(address)
            minDistance = 10000
            minStore = None
            for store in qstore:
                minD = getDistance(point["lng"], point["lat"], float(store.x),
                                   float(store.y))
                if minD < minDistance:
                    minDistance = minD
                    minStore = store
            if minDistance > 0 and minStore and minDistance < minStore.psdistance:
                result["flag"] = 1
                result["data"] = {
                    "id": minStore.id,
                    "name": minStore.name,
                    "distance": minDistance,
                    "byprice": minStore.byprice,
                    "freight": minStore.freight,
                }
            else:
                result["flag"] = 0
                result["msg"] = "在该地址附近未找到可以配送的经销商!"
                result["data"] = ""
        else:
            result["flag"] = 0
            result["msg"] = "地址不能为空!"

    except Exception, ex:
        result["flag"] = 0
        result["msg"] = "地址或者经销商信息错误!"
示例#28
0
文件: map.py 项目: scaperow/carive
def getDistanceAS(address, store_id):
    result = {"flag": 0, "msg": "", "data": ""}
    try:
        if address:
            if store_id > 0:
                store = Store.get(Store.id == store_id)
                result["flag"] = 1
                point = getPointByAddress(address)
                result["data"] = str(
                    getDistance(point["lng"], point["lat"], float(store.x),
                                float(store.y)))
            else:
                result["flag"] = 0
                result["msg"] = "经销商ID不正确!"
        else:
            result["flag"] = 0
            result["msg"] = "地址不能为空!"

    except:
        result["flag"] = 0
        result["msg"] = "地址或者经销商信息错误!"

    return result
示例#29
0
class GenDDR(object):
  '''
  src is dynamic, and tag is dynamic
  '''
  def __init__(self, db, dic, parent_conn, src_dic, ent_size, tgt_dic=None, mode='local'):
    '''
    db  : db name
    dic : the relation dict of the config
    parent_conn: server conn
                 1, rel data
                 2, src nodes: n
                 3, tgt nodes: m
    src_dic : src node config dict
    ent_size: the number of nodes of each entity
    tgt_dic : tgt node config dict
             if is None, then tgt_dic == src_dic, e.g. user -> user
    mode : local (default), dump edge locally
         : u-level, dump edge and node in parent process
    '''
    self.parent_conn = parent_conn
    self.rel_dict = dic
    self.db_name  = db
    self.src_dic = src_dic
    self.tgt_dic = tgt_dic
    self.mode = mode
    self.ent_size = ent_size
    self.db_handler  = Store(db)
    self.db_handler.connect()
    # parameters of in/out distributions
    # TODO: other type of distribution
    if dic['in']['type'] == 'power_law':
      mind, maxd, midd = 0, -1, -1
      if 'min_degree' in dic['in']:
        mind = dic['in']['min_degree']
      if 'max_degree' in dic['in']:
        maxd = dic['in']['max_degree']
      if 'mid_degree' in dic['in']:
        midd = dic['in']['mid_degree']
      if isinstance(dic['in']['lambd'], list):
        self.indistr_ins = PWL(0, dic['in']['lambd'][0], dic['in']['lambd'][1], mind, maxd, midd)
      else:
        self.indistr_ins = PWL(0, dic['in']['lambd'], min_degree=mind, max_degree=maxd, mid_degree=midd)
    elif dic['in']['type'] == 'uniform':
      self.indistr_ins = Uniform(0, dic['in']['min'], dic['in']['max'])

    if dic['out']['type'] == 'power_law':
      mind, maxd, midd = 0, -1, -1
      if 'min_degree' in dic['out']:
        mind = dic['out']['min_degree']
      if 'max_degree' in dic['out']:
        maxd = dic['out']['max_degree']
      if 'mid_degree' in dic['out']:
        midd = dic['out']['mid_degree']
      if isinstance(dic['out']['lambd'], list):
        self.outdistr_ins = PWL(0, dic['out']['lambd'][0], dic['out']['lambd'][1], mind, maxd, midd)
      else:
        self.outdistr_ins = PWL(0, dic['out']['lambd'], min_degree=mind, max_degree=maxd, mid_degree=midd)
    elif dic['out']['type'] = 'uniform':
      self.outdistr_ins = Uniform(0, dic['out']['min'], dic['out']['max'])
    # some statistical info
    self.in_degree_nums  = []   # [i] : the number of nodes with in degree i
    self.out_degree_nums = []   # [i] : the number of nodes with out degree i 
    self.node_in_degree  = []   # [i] : the in degree of node i
    self.node_out_degree = []   # [i] : the out degree of node i
    self.in_degree_nodes  = []  # [i] : the nodes with in degree i, from degree 1
    self.out_degree_nodes = []  # [i] : the nodes with out degree i,from degree 1
    self.src_remain_nodes = []  # : source nodes (out) list with degree 0
    self.tgt_remain_nodes = []  # : target nodes (in)  list with degree 0
    # generate index and nums info
    self.src_l_index = 0 
    self.src_r_index = 1 
    self.tgt_l_index = 0 
    self.tgt_r_index = 1 
    self.src_fake_cnt = 0 
    self.tgt_fake_cnt = 0 
    # for community 
    self.mu_parameter = 0.4 # used to determine community belongs 
    self.ncomunty = 10      # community id: 0, 1, ... 
    self.comunty_nodes = [] # community: set of nodes 
    # node id: start from 1
    self.node_comunty_n_indegree = [[]]  # [d1, ..., dn] 
    self.node_comunty_n_outdegree = [[]] # [d1, ..., dn]
    self.node_comunty_ident = [set()]    # the communities node i belongs to
示例#30
0
 def get(self):
     result = []
     q = Store.select().where(Store.status == 1)
     for n in q:
         result.append({'ID': n.id, 'Name': n.name})
     self.write(simplejson.dumps(result))
示例#31
0
def store_list():
    stores = Store.listWithStats()
    return render_template('store.html', stores=stores)