= invoice_balance:\n pay_service: PaymentSystemService = PaymentSystemFactory.create_from_payment_method(\n invoice.payment_method_code)\n # Only release records, as the actual status change should happen during reconciliation.\n pay_service.apply_credit(invoice)\n credit_balance = payment_account.credit - invoice_balance\n invoice.paid = invoice.total\n invoice.save()\n elif (payment_account.credit or 0) <= invoice_balance:\n invoice.paid = (invoice.paid or 0) + (payment_account.credit or 0)\n invoice.save()\n\n payment_account.credit = credit_balance\n payment_account.save()\n else:\n payment_method = get_str_by_path(payment_request, 'paymentInfo/methodOfPayment')\n\n is_not_currently_on_ob = invoice.payment_method_code != PaymentMethod.ONLINE_BANKING.value\n is_not_changing_to_cc = payment_method not in (PaymentMethod.CC.value, PaymentMethod.DIRECT_PAY.value)\n # can patch only if the current payment method is OB\n if is_not_currently_on_ob or is_not_changing_to_cc:\n raise BusinessException(Error.INVALID_REQUEST)\n\n # check if it has any invoice references already created\n # if there is any invoice ref , send them to the invoiced credit card flow\n\n invoice_reference = InvoiceReference.find_active_reference_by_invoice_id(invoice.id)\n if invoice_reference:\n invoice.payment_method_code = PaymentMethod.CC.value\n else:\n pay_service: PaymentSystemService = PaymentSystemFactory.create_from_payment_method(\n PaymentMethod.DIRECT_PAY.value)\n payment_account = PaymentAccount.find_by_id(invoice.payment_account_id)\n pay_service.create_invoice(payment_account, invoice.payment_line_items, invoice,\n corp_type_code=invoice.corp_type_code)\n\n invoice.payment_method_code = PaymentMethod.DIRECT_PAY.value\n invoice.save()\n current_app.logger.debug('>update_invoice')\n return invoice.asdict()","def action_process(self):\n self.check_difference_balance()\n for statement in self:\n statement_lines = statement.credit_move_line_ids + statement.debit_move_line_ids\n for statement_line in statement_lines:\n if statement_line.move_line_id:\n statement_line.move_line_id.write({'cleared_bank_account': statement_line.cleared_bank_account,\n 'bank_acc_rec_statement_id': statement_line.cleared_bank_account and statement.id or False\n })\n statement.write({'state': 'done',\n 'verified_by_user_id': self._uid,\n 'verified_date': time.strftime('%Y-%m-%d')\n })\n for debit_line in statement.debit_move_line_ids:\n if debit_line.move_line_id.cleared_bank_account:\n debit_line.move_line_id.move_id.is_reconciled = True\n return True","def _inline_draft(request):\n # TODO(guido): turn asserts marked with XXX into errors\n # Don't use @login_required, since the JS doesn't understand redirects.\n if not request.user:\n # Don't log this, spammers have started abusing this.\n return HttpTextResponse('Not logged in')\n snapshot = request.POST.get('snapshot')\n assert snapshot in ('old', 'new'), repr(snapshot)\n left = (snapshot == 'old')\n side = request.POST.get('side')\n assert side in ('a', 'b'), repr(side) # Display left (a) or right (b)\n issue_id = int(request.POST['issue'])\n issue = models.Issue.get_by_id(issue_id)\n assert issue # XXX\n patchset_id = int(request.POST.get('patchset') or\n request.POST[side == 'a' and 'ps_left' or 'ps_right'])\n patchset = models.PatchSet.get_by_id(int(patchset_id), parent=issue.key)\n assert patchset # XXX\n patch_id = int(request.POST.get('patch') or\n request.POST[side == 'a' and 'patch_left' or 'patch_right'])\n patch = models.Patch.get_by_id(int(patch_id), parent=patchset.key)\n assert patch # XXX\n text = request.POST.get('text')\n lineno = int(request.POST['lineno'])\n message_id = request.POST.get('message_id')\n comment = _add_or_update_comment(user=request.user, issue=issue, patch=patch,\n lineno=lineno, left=left,\n text=text, message_id=message_id)\n issue.calculate_draft_count_by_user()\n issue_fut = issue.put_async()\n\n query = models.Comment.query(\n models.Comment.patch_key == patch.key, models.Comment.lineno == lineno,\n models.Comment.left == left).order(models.Comment.date)\n comments = list(c for c in query if not c.draft or c.author == request.user)\n if comment is not None and comment.author is None:\n # Show anonymous draft even though we don't save it\n comments.append(comment)\n issue_fut.get_result()\n if not comments:\n return HttpTextResponse(' ')\n for c in comments:\n c.complete()\n return render_to_response('inline_comment.html',\n {'user': request.user,\n 'patch': patch,\n 'patchset': patchset,\n 'issue': issue,\n 'comments': comments,\n 'lineno': lineno,\n 'snapshot': snapshot,\n 'side': side,\n },\n context_instance=RequestContext(request))","def action_view_invoice_salon(self):\n return {\n 'name': 'Invoices',\n 'domain': [('invoice_origin', '=', self.name)],\n 'res_model': 'account.move',\n 'view_id': False,\n 'view_mode': 'tree,form',\n 'type': 'ir.actions.act_window',\n }","def test_duplicate_invoices(self):\n biling_info = baker.make(BillingInfo)\n for i in range(20): # Try this more times to increase chance of failure\n order = baker.make(Order, user=biling_info.user)\n Invoice.objects.all().delete()\n call_concurrently(3, complete_concrete_order, order_id=order.id)\n self.assertEqual(Invoice.objects.count(), 1)","def get_partial_books(self, fb_brw):\n cr, uid = self.cr, self.uid\n fb_obj = self.pool.get('fiscal.book')\n if not fb_brw.fbl_ids:\n return [{'init': [], 'lines': [], 'partial_total': []}]\n\n line_groups = self.get_line_groups(fb_brw)\n last_page = len(line_groups)\n if last_page == 1:\n # self._print_book(\n # [], line_groups[0].get('report_lines'), [], line_groups[0])\n return [{'init': [],\n 'lines': line_groups[0].get('report_lines'),\n 'partial_total': []}]\n res = []\n for subgroup in line_groups:\n cr.execute('SAVEPOINT report_original_fb_' + str(\n subgroup.get('page')))\n inv_ids = [line.get('invoice_id')[0]\n for line in subgroup.get('report_lines')\n if line.get('invoice_id')]\n self.context.update(\n call_from_report=1, report_group_inv_ids=inv_ids)\n fb_obj.update_book(cr, uid, [fb_brw.id], context=self.context)\n fb_brw.refresh()\n begin_line = self.get_begin_line(res)\n partial_total = (subgroup.get('page') != last_page and\n self.get_partial_total(fb_brw, begin_line) or [])\n res.append({'init': begin_line,\n 'lines': subgroup.get('report_lines'),\n 'partial_total': partial_total})\n # self._print_book(\n # begin_line, subgroup.get('report_lines'), partial_total,\n # subgroup)\n cr.execute('ROLLBACK TO SAVEPOINT report_original_fb_' + str(\n subgroup.get('page')))\n return res","def _prepare_invoice_line(self, cr, uid, group, picking, move_line, invoice_id,\n invoice_vals, context=None):\n result = super(stock_picking, self)._prepare_invoice_line(cr, uid, group, picking, move_line, invoice_id,\n invoice_vals, context=None)\n \n result['discount'] = self._get_discount_invoice(cr, uid, move_line)\n result['discount2'] = self._get_discount2_invoice(cr, uid, move_line)\n result['price_unit'] = self._get_price_unit_invoice(cr, uid, move_line, invoice_vals['type'], context=None)\n return result","def UpdateInvoice(self):\n self.builder.get_object('GuiInvProd').get_buffer().set_text(\"Product:\\n\")\n self.builder.get_object('GuiInvPrice').get_buffer().set_text(\"Price:\\n\")\n self.amount = 0\n for items in self.prod_list:\n self.builder.get_object('GuiInvProd').get_buffer().insert_at_cursor(\n u\"%s\\n\" % items['name'])\n if self.is_member:\n self.builder.get_object('GuiInvPrice').get_buffer().insert_at_cursor(\n config.CURRENCY_SYMBOL + u\"%.2f\\n\" % items[2])\n self.amount = self.amount + items[2]\n else:\n self.builder.get_object('GuiInvPrice').get_buffer().insert_at_cursor(\n config.CURRENCY_SYMBOL + u\"%.2f\\n\" % items[3])\n self.amount = self.amount + items[3]\n if self.is_member:\n self.builder.get_object('GuiInvProd').get_buffer().insert_at_cursor(\n u\"\\nYou are a member.\")\n self.builder.get_object('GuiTotal').set_text(config.CURRENCY_SYMBOL + u\"%.2f\" % self.amount)\n self.builder.get_object('GuiInput').set_text(\"\")","def unlink(self, cr, uid, ids, context=None):\n payenrich = self.read(cr, uid, ids, ['state'], context=context)\n for s in payenrich:\n if s['state'] not in ['draft', 'cancel']:\n raise osv.except_osv(_('Invalid Action Error'), _('In Order To Delete A Service Request Order(s), It Must Be Cancelled First!'))\n return super(payment_enrich, self).unlink(cr, uid, ids, context=context)","def _prepare_invoice(self):\n # get current logged in user's timezone\n local = pytz.timezone(self.env['res.users'].browse(self._uid).tz) or pytz.utc\n\n self.ensure_one()\n journal_id = self.env['account.journal'].search([('type', '=', 'purchase')], limit=1).id\n if not journal_id:\n raise UserError(_('Please define an accounting purchase journal for this company.'))\n invoice_vals = {\n 'name': self.partner_ref or '',\n 'origin': self.name,\n 'type': 'in_invoice',\n 'account_id': self.partner_id.property_account_payable_id.id,\n 'partner_id': self.partner_id.id,\n 'journal_id': journal_id,\n 'currency_id': self.currency_id.id,\n 'comment': self.notes,\n 'payment_term_id': self.payment_term_id.id,\n 'fiscal_position_id': self.fiscal_position_id.id or self.partner_id.property_account_position_id.id,\n 'company_id': self.company_id.id,\n 'purchase_id': self.id,\n 'date_invoice':pytz.utc.localize(datetime.datetime.now()).astimezone(local).strftime('%Y-%m-%d'),\n }\n return invoice_vals","def generate_eob(\n self, date_of_service, date_of_eob, insured, invoice_id, cpt_code, charge_amount\n ):\n if insured == \"insured\":\n # first copayments\n copay_amount = np.random.choice(\n self.distributions[\"copay_amounts\"],\n 1,\n p=self.distributions[\"copay_distribution\"],\n )[0]\n if copay_amount > 0:\n invoicelineitemeob = pd.DataFrame(\n {\n \"invoice_id\": [invoice_id],\n \"cpt_code\": [cpt_code],\n \"created_on\": [date_of_service],\n \"copay_amount\": [copay_amount],\n \"adjustment_amount\": [0],\n \"paid_amount\": [0],\n }\n )\n self.InvoiceLineItemsEob = self.InvoiceLineItemsEob.append(\n invoicelineitemeob\n )\n remaining_charge = charge_amount - copay_amount\n else:\n remaining_charge = charge_amount\n # next eob discounts\n eob_discount_percent = np.random.choice(\n self.distributions[\"eob_discount_percentages\"],\n 1,\n p=self.distributions[\"eob_discount_distribution\"],\n )[0]\n if eob_discount_percent > 0:\n insurance_adjustment = remaining_charge * eob_discount_percent / 100\n remaining_charge = remaining_charge - insurance_adjustment\n invoicelineitemeob = pd.DataFrame(\n {\n \"invoice_id\": [invoice_id],\n \"cpt_code\": [cpt_code],\n \"created_on\": [date_of_eob],\n \"copay_amount\": [0],\n \"adjustment_amount\": [insurance_adjustment],\n \"paid_amount\": [0],\n }\n )\n self.InvoiceLineItemsEob = self.InvoiceLineItemsEob.append(\n invoicelineitemeob\n )\n # next handle eob payments where relevant\n eob_payment_percentage = np.random.choice(\n self.distributions[\"eob_payment_percentages\"],\n 1,\n p=self.distributions[\"eob_payment_distribution\"],\n )[0]\n eob_payment_amount = remaining_charge * (eob_payment_percentage / 100.0)\n if eob_payment_amount > 0:\n invoicelineitemeob = pd.DataFrame(\n {\n \"invoice_id\": [invoice_id],\n \"cpt_code\": [cpt_code],\n \"created_on\": [date_of_eob],\n \"copay_amount\": [0],\n \"adjustment_amount\": [0],\n \"paid_amount\": [eob_payment_amount],\n }\n )\n self.InvoiceLineItemsEob = self.InvoiceLineItemsEob.append(\n invoicelineitemeob\n )\n remaining_charge = remaining_charge - eob_payment_amount\n else:\n remaining_charge = charge_amount\n return remaining_charge"],"string":"[\n \"def merge_purchase_invoice(self):\\r\\n active_id = self.env['purchase.order'].browse(self.env['purchase.order']._context.get('active_ids'))\\r\\n journal_id = self.env['account.journal'].search([('type', '=', 'purchase')]) \\r\\n active_id_count = 0\\r\\n active_count = 0\\r\\n exist_vendor = []; invoice = [];exist_vendors = [];ctx = ();invoice_id = []\\r\\n for rec in active_id : \\r\\n po_reference = self.env['account.invoice'].search([('origin', 'like', rec.name)])\\r\\n active_count = len(active_id)\\r\\n if rec.picking_count >= 1 and rec.picking_count != rec.invoice_count:\\r\\n len_name = [] \\r\\n for inv in po_reference: \\r\\n len_name = inv.origin.split(\\\":\\\") \\r\\n if rec.name in len_name:\\r\\n if po_reference.state == 'draft':\\r\\n for record in po_reference.invoice_line_ids:\\r\\n print (record.line_id)\\r\\n for res in rec.order_line:\\r\\n if res.id == record.line_id: \\r\\n record.write({'quantity':res.qty_received})\\r\\n res.write({'qty_invoiced':record.quantity})\\r\\n \\r\\n else:\\r\\n \\r\\n po_list = [];line_values = {};lines = {};purchase = []\\r\\n if rec.state in 'purchase' and rec.invoice_status in 'to invoice':\\r\\n purchase.append(rec.id)\\r\\n active_id_count = len(purchase)\\r\\n if rec.partner_id.id in exist_vendor:\\r\\n for inv in invoice:\\r\\n if inv['partner_id'] == rec.partner_id.id:\\r\\n for recc in rec.order_line:\\r\\n if rec.picking_count > 1 and rec.invoice_count >= 1:\\r\\n qty_received = recc.qty_received - recc.qty_invoiced \\r\\n else:\\r\\n qty_received = recc.qty_received \\r\\n line_values = (0, 0, {'product_id': recc.product_id.id,\\r\\n 'quantity': qty_received ,\\r\\n 'price_unit': recc.price_unit,\\r\\n 'invoice_line_tax_ids': [(6, 0, recc.taxes_id and recc.taxes_id.ids) or False] ,\\r\\n 'price_subtotal': recc.price_subtotal,\\r\\n 'product_uom': recc.product_uom.id,\\r\\n 'name': recc.name,\\r\\n 'account_id': journal_id.default_debit_account_id.id ,\\r\\n 'line_id':recc.id\\r\\n }) \\r\\n inv['invoice_line_ids'].append(line_values)\\r\\n inv['origin'] = inv['origin'] + ':' + rec.name\\r\\n if rec.partner_id.id not in exist_vendor:\\r\\n exist_vendors.append(rec.partner_id.id) \\r\\n else: \\r\\n for recc in rec.order_line:\\r\\n if rec.picking_count > 1 and rec.invoice_count >= 1:\\r\\n qty_received = recc.qty_received - recc.qty_invoiced \\r\\n else:\\r\\n qty_received = recc.qty_received\\r\\n line_values = (0, 0, {'product_id': recc.product_id.id,\\r\\n 'quantity': qty_received,\\r\\n 'price_unit': recc.price_unit,\\r\\n 'invoice_line_tax_ids': [(6, 0, recc.taxes_id and recc.taxes_id.ids)or False],\\r\\n 'price_subtotal': recc.price_subtotal,\\r\\n 'product_uom': recc.product_uom.id,\\r\\n 'name': recc.name,\\r\\n 'account_id': journal_id.default_debit_account_id.id,\\r\\n 'line_id':recc.id\\r\\n }) \\r\\n print (rec.id)\\r\\n po_list.append(line_values) \\r\\n invoice.append({'origin':rec.name, 'partner_id': rec.partner_id.id, 'invoice_line_ids':po_list, 'account_id': rec.partner_id.property_account_payable_id.id, 'type': 'in_invoice', 'journal_id':journal_id.id,'date_invoice':datetime.today()}) \\r\\n if rec.partner_id.id not in exist_vendor:\\r\\n exist_vendor.append(rec.partner_id.id) \\r\\n \\r\\n else:\\r\\n po_list = [];line_values = {};lines = {};purchase = []\\r\\n if rec.state in 'purchase' and rec.invoice_status in 'to invoice':\\r\\n purchase.append(rec.id)\\r\\n active_id_count = len(purchase)\\r\\n if rec.partner_id.id in exist_vendor:\\r\\n for inv in invoice:\\r\\n if inv['partner_id'] == rec.partner_id.id:\\r\\n for recc in rec.order_line:\\r\\n if rec.picking_count > 1 and rec.invoice_count >= 1:\\r\\n qty_received = recc.qty_received - recc.qty_invoiced \\r\\n else:\\r\\n qty_received = recc.qty_received\\r\\n line_values = (0, 0, {'product_id': recc.product_id.id,\\r\\n 'quantity': qty_received ,\\r\\n 'price_unit': recc.price_unit,\\r\\n 'invoice_line_tax_ids': [(6, 0, recc.taxes_id and recc.taxes_id.ids) or False] ,\\r\\n 'price_subtotal': recc.price_subtotal,\\r\\n 'product_uom': recc.product_uom.id,\\r\\n 'name': recc.name,\\r\\n 'account_id': journal_id.default_debit_account_id.id ,\\r\\n 'line_id':recc.id\\r\\n }) \\r\\n inv['invoice_line_ids'].append(line_values)\\r\\n inv['origin'] = inv['origin'] + ':' + rec.name\\r\\n if rec.partner_id.id not in exist_vendor:\\r\\n exist_vendors.append(rec.partner_id.id) \\r\\n else: \\r\\n for recc in rec.order_line:\\r\\n if rec.picking_count > 1 and rec.invoice_count >= 1:\\r\\n qty_received = recc.qty_received - recc.qty_invoiced \\r\\n else:\\r\\n qty_received = recc.qty_received\\r\\n line_values = (0, 0, {'product_id': recc.product_id.id,\\r\\n 'quantity': qty_received,\\r\\n 'price_unit': recc.price_unit,\\r\\n 'invoice_line_tax_ids': [(6, 0, recc.taxes_id and recc.taxes_id.ids)or False],\\r\\n 'price_subtotal': recc.price_subtotal,\\r\\n 'product_uom': recc.product_uom.id,\\r\\n 'name': recc.name,\\r\\n 'account_id': journal_id.default_debit_account_id.id,\\r\\n 'line_id':recc.id\\r\\n }) \\r\\n print (rec.id)\\r\\n po_list.append(line_values) \\r\\n invoice.append({'origin':rec.name, 'partner_id': rec.partner_id.id, 'invoice_line_ids':po_list, 'account_id': rec.partner_id.property_account_payable_id.id, 'type': 'in_invoice', 'journal_id':journal_id.id,'date_invoice':date.today()}) \\r\\n if rec.partner_id.id not in exist_vendor:\\r\\n exist_vendor.append(rec.partner_id.id) \\r\\n \\r\\n invoices = []\\r\\n invoice_counts = 0\\r\\n for record in invoice:\\r\\n invoice_id = self.env['account.invoice'].create(record)\\r\\n invoices.append(invoice_id.id)\\r\\n invoice_counts = len(invoices)\\r\\n if active_id_count == 1:\\r\\n if invoice_counts == 1:\\r\\n form_view = self.env.ref('purchase.view_invoice_supplier_purchase_form').id\\r\\n tree_view = self.env.ref('account.invoice_tree').id \\r\\n return{\\r\\n 'name': _('Invoice'),\\r\\n 'type':'ir.actions.act_window',\\r\\n 'view_type':'form',\\r\\n 'view_mode':'form,tree',\\r\\n 'res_model':'account.invoice',\\r\\n 'res_id':invoices[0],\\r\\n 'views_id':False,\\r\\n 'views':[(form_view , 'form'), (tree_view , 'tree')],\\r\\n 'domain':[('id', 'in', invoices)],\\r\\n 'target': 'current',\\r\\n } \\r\\n else: \\r\\n form_view = self.env.ref('account.invoice_supplier_form').id\\r\\n tree_view = self.env.ref('account.invoice_supplier_tree').id \\r\\n return{\\r\\n 'name': _('Invoice'),\\r\\n 'type':'ir.actions.act_window',\\r\\n 'view_type':'form',\\r\\n 'view_mode':'form,tree',\\r\\n 'res_model':'account.invoice',\\r\\n 'views_id':True,\\r\\n 'views':[(tree_view , 'tree'), (form_view , 'form')],\\r\\n 'domain':[('id', 'in', invoices)],\\r\\n 'target': 'current',\\r\\n }\",\n \"def create_or_find_b2b_invoices_and_process_ept(self, row, sale_order, invoice_date, tax):\\n\\n vat_number = row.get('Buyer Tax Registration', False)\\n invoice_number = row.get('VAT Invoice Number', False)\\n\\n invoices = sale_order.invoice_ids.filtered(\\n lambda x: x.type == 'out_invoice' and x.state != 'cancel')\\n if not invoices:\\n lines = sale_order.order_line.filtered(lambda line: line.qty_to_invoice > 0)\\n if not lines:\\n return False\\n invoices = sale_order._create_invoices()\\n self.write({'invoice_ids': [(4, invoices and invoices.id)]})\\n\\n for invoice in invoices:\\n if not invoice.partner_id.vat:\\n invoice.partner_id.vat = vat_number\\n\\n payments_lines = []\\n if invoice.invoice_payments_widget != 'false':\\n payments_dict = json.loads(invoice.invoice_payments_widget)\\n payments_content = payments_dict.get('content', [])\\n for line in payments_content:\\n payments_lines.append(line.get('payment_id', False))\\n\\n invoice_line = invoice.mapped('invoice_line_ids').filtered(\\\\\\n lambda line: line.tax_ids != tax)\\n if invoice_line:\\n invoice.button_draft()\\n invoice.write({'ref': invoice_number, 'date': invoice_date})\\n\\n if len(invoice_line) > 1:\\n for line in invoice_line:\\n line.with_context({'check_move_validity': False}).write( \\\\\\n {'tax_ids': [(6, 0, [tax.id])]})\\n else:\\n invoice_line.with_context({'check_move_validity': False}).write( \\\\\\n {'tax_ids': [(6, 0, [tax.id])]})\\n\\n invoice.with_context({'check_move_validity': False})._recompute_tax_lines( \\\\\\n recompute_tax_base_amount=True)\\n invoice.action_post()\\n for line in payments_lines:\\n invoice.js_assign_outstanding_line(line)\\n\\n return True\",\n \"def action_draft(self):\\n context = self._context or {}\\n inv_obj = self.env['account.invoice']\\n\\n brw = self.browse( self.ids[0])\\n inv_ids = [i.invoice_id.id for i in brw.line_ids]\\n if inv_ids:\\n inv_obj.write( {'wh_src_id': False})\\n\\n return self.write( {'state': 'draft'})\",\n \"def do_merge(self, cr, uid, ids, context=None): \\n invent_obj = self.pool.get('stock.inventory')\\n invent_line_obj = self.pool.get('stock.inventory.line')\\n invent_lines = {}\\n if context is None:\\n context = {}\\n for inventory in invent_obj.browse(cr, uid, context['active_ids'], context=context):\\n if inventory.state == \\\"done\\\":\\n raise osv.except_osv(_('Warning!'),\\n _('Merging is only allowed on draft inventories.'))\\n\\n for line in inventory.inventory_line_id:\\n key = (line.location_id.id, line.product_id.id, line.product_uom.id)\\n if key in invent_lines:\\n invent_lines[key] += line.product_qty\\n else:\\n invent_lines[key] = line.product_qty\\n\\n\\n new_invent = invent_obj.create(cr, uid, {\\n 'name': 'Merged inventory'\\n }, context=context)\\n\\n for key, quantity in invent_lines.items():\\n invent_line_obj.create(cr, uid, {\\n 'inventory_id': new_invent,\\n 'location_id': key[0],\\n 'product_id': key[1],\\n 'product_uom': key[2],\\n 'product_qty': quantity,\\n })\\n\\n return {'type': 'ir.actions.act_window_close'}\",\n \"def action_invoice_create(self, grouped=False, final=False):\\n inv_obj = self.env['account.invoice']\\n precision = self.env['decimal.precision'].sudo().precision_get('Product Unit of Measure')\\n invoices = {}\\n references = {}\\n for order in self:\\n group_key = order.id if grouped else (order.partner_invoice_id.id, order.currency_id.id)\\n for line in order.order_line.sorted(key=lambda l: l.qty_to_invoice < 0):\\n if float_is_zero(line.qty_to_invoice, precision_digits=precision):\\n continue\\n if group_key not in invoices:\\n inv_data = order._prepare_invoice()\\n invoice = inv_obj.sudo().create(inv_data)\\n references[invoice] = order\\n invoices[group_key] = invoice\\n invoice['sale_order_id'] = order.id\\n elif group_key in invoices:\\n vals = {}\\n if order.name not in invoices[group_key].origin.split(', '):\\n vals['origin'] = invoices[group_key].origin + ', ' + order.name\\n if order.client_order_ref and order.client_order_ref not in invoices[group_key].name.split(\\n ', ') and order.client_order_ref != invoices[group_key].name:\\n vals['name'] = invoices[group_key].name + ', ' + order.client_order_ref\\n invoices[group_key].sudo().write(vals)\\n if line.qty_to_invoice > 0:\\n line.invoice_line_create(invoices[group_key].id, line.qty_to_invoice)\\n elif line.qty_to_invoice < 0 and final:\\n line.invoice_line_create(invoices[group_key].id, line.qty_to_invoice)\\n\\n if references.get(invoices.get(group_key)):\\n if order not in references[invoices[group_key]]:\\n references[invoices[group_key]] |= order\\n if not invoices:\\n raise UserError(_('There is no invoiceable line.'))\\n for invoice in invoices.values():\\n if not invoice.invoice_line_ids:\\n raise UserError(_('There is no invoiceable line.'))\\n # If invoice is negative, do a refund invoice instead\\n if invoice.amount_untaxed < 0:\\n invoice.type = 'out_refund'\\n for line in invoice.invoice_line_ids:\\n line.quantity = -line.quantity\\n # Use additional field helper function (for account extensions)\\n for line in invoice.invoice_line_ids:\\n line._set_additional_fields(invoice)\\n # Necessary to force computation of taxes. In account_invoice, they are triggered\\n # by onchanges, which are not triggered when doing a create.\\n invoice.compute_taxes()\\n invoice.message_post_with_view('mail.message_origin_link',\\n values={'self': invoice, 'origin': references[invoice]},\\n subtype_id=self.env.ref('mail.mt_note').id)\\n return [inv.id for inv in invoices.values()]\",\n \"def action_invoice_create(self, grouped=False, final=False):\\n inv_obj = self.env['account.invoice']\\n precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')\\n invoices = {}\\n references = {}\\n invoices_origin = {}\\n invoices_name = {}\\n for order in self:\\n group_key = order.id if grouped else (order.partner_id.id, order.currency_id.id)\\n for line in order.order_line.sorted(key=lambda l: l.qty_received - l.qty_invoiced < 0):\\n if float_is_zero(line.qty_received - line.qty_invoiced, precision_digits=precision):\\n continue\\n if group_key not in invoices:\\n inv_data = order._prepare_invoice()\\n invoice = inv_obj.create(inv_data)\\n references[invoice] = order\\n invoices[group_key] = invoice\\n invoices_origin[group_key] = [invoice.origin]\\n invoices_name[group_key] = [invoice.name]\\n elif group_key in invoices:\\n if order.name not in invoices_origin[group_key]:\\n invoices_origin[group_key].append(order.name)\\n if order.partner_ref and order.partner_ref not in invoices_name[group_key]:\\n invoices_name[group_key].append(order.partner_ref)\\n\\n if line.qty_received - line.qty_invoiced > 0:\\n line.invoice_line_create(invoices[group_key].id, line.qty_received - line.qty_invoiced)\\n elif line.qty_received - line.qty_invoiced < 0 and final:\\n line.invoice_line_create(invoices[group_key].id, line.qty_received - line.qty_invoiced)\\n\\n if references.get(invoices.get(group_key)):\\n if order not in references[invoices[group_key]]:\\n references[invoices[group_key]] |= order\\n\\n for group_key in invoices:\\n invoices[group_key].write({'name': ', '.join(invoices_name[group_key]),\\n 'origin': ', '.join(invoices_origin[group_key])})\\n\\n if not invoices:\\n raise UserError(_('There is no invoicable line.'))\\n\\n for invoice in invoices.values():\\n if not invoice.invoice_line_ids:\\n raise UserError(_('There is no invoicable line.'))\\n # If invoice is negative, do a refund invoice instead\\n if invoice.amount_total < 0:\\n invoice.type = 'in_refund'\\n for line in invoice.invoice_line_ids:\\n line.quantity = -line.quantity\\n # Necessary to force computation of taxes. In account_invoice, they are triggered\\n # by onchanges, which are not triggered when doing a create.\\n invoice.compute_taxes()\\n invoice.message_post_with_view('mail.message_origin_link',\\n values={'self': invoice, 'origin': references[invoice]},\\n subtype_id=self.env.ref('mail.mt_note').id)\\n return [inv.id for inv in invoices.values()]\",\n \"def action_invoice_create(self, grouped=False, final=False):\\n if self.invoice_option == 'before_delivery':\\n inv_obj = self.env['account.invoice']\\n for order in self:\\n inv_data = order._prepare_invoice()\\n invoice = inv_obj.create(inv_data)\\n for inv_line in order.order_line:\\n inv_line.invoice_line_create(invoice.id, inv_line.product_uom_qty)\\n\\n else:\\n inv_obj = self.env['account.invoice']\\n precision = self.env['decimal.precision'].precision_get('Product Unit of Measure')\\n invoices = {}\\n references = {}\\n invoices_origin = {}\\n invoices_name = {}\\n\\n # Keep track of the sequences of the lines\\n # To keep lines under their section\\n inv_line_sequence = 0\\n for order in self:\\n group_key = order.id if grouped else (order.partner_invoice_id.id, order.currency_id.id)\\n\\n # We only want to create sections that have at least one invoiceable line\\n pending_section = None\\n\\n # Create lines in batch to avoid performance problems\\n line_vals_list = []\\n # sequence is the natural order of order_lines\\n for line in order.order_line:\\n if line.display_type == 'line_section':\\n pending_section = line\\n continue\\n if float_is_zero(line.qty_to_invoice, precision_digits=precision):\\n continue\\n if group_key not in invoices:\\n inv_data = order._prepare_invoice()\\n invoice = inv_obj.create(inv_data)\\n references[invoice] = order\\n invoices[group_key] = invoice\\n invoices_origin[group_key] = [invoice.origin]\\n invoices_name[group_key] = [invoice.name]\\n elif group_key in invoices:\\n if order.name not in invoices_origin[group_key]:\\n invoices_origin[group_key].append(order.name)\\n if order.client_order_ref and order.client_order_ref not in invoices_name[group_key]:\\n invoices_name[group_key].append(order.client_order_ref)\\n\\n if line.qty_to_invoice > 0 or (line.qty_to_invoice < 0 and final):\\n if pending_section:\\n section_invoice = pending_section.invoice_line_create_vals(\\n invoices[group_key].id,\\n pending_section.qty_to_invoice\\n )\\n inv_line_sequence += 1\\n section_invoice[0]['sequence'] = inv_line_sequence\\n line_vals_list.extend(section_invoice)\\n pending_section = None\\n\\n inv_line_sequence += 1\\n inv_line = line.invoice_line_create_vals(\\n invoices[group_key].id, line.qty_to_invoice\\n )\\n inv_line[0]['sequence'] = inv_line_sequence\\n line_vals_list.extend(inv_line)\\n\\n if references.get(invoices.get(group_key)):\\n if order not in references[invoices[group_key]]:\\n references[invoices[group_key]] |= order\\n\\n self.env['account.invoice.line'].create(line_vals_list)\\n\\n for group_key in invoices:\\n invoices[group_key].write({'name': ', '.join(invoices_name[group_key]),\\n 'origin': ', '.join(invoices_origin[group_key])})\\n sale_orders = references[invoices[group_key]]\\n if len(sale_orders) == 1:\\n invoices[group_key].reference = sale_orders.reference\\n\\n if not invoices:\\n raise UserError(_(\\n 'There is no invoiceable line. If a product has a Delivered quantities invoicing policy, please make sure that a quantity has been delivered.'))\\n\\n for invoice in invoices.values():\\n invoice.compute_taxes()\\n if not invoice.invoice_line_ids:\\n raise UserError(_(\\n 'There is no invoiceable line. If a product has a Delivered quantities invoicing policy, please make sure that a quantity has been delivered.'))\\n # If invoice is negative, do a refund invoice instead\\n if invoice.amount_total < 0:\\n invoice.type = 'out_refund'\\n for line in invoice.invoice_line_ids:\\n line.quantity = -line.quantity\\n # Use additional field helper function (for account extensions)\\n for line in invoice.invoice_line_ids:\\n line._set_additional_fields(invoice)\\n # Necessary to force computation of taxes. In account_invoice, they are triggered\\n # by onchanges, which are not triggered when doing a create.\\n invoice.compute_taxes()\\n # Idem for partner\\n so_payment_term_id = invoice.payment_term_id.id\\n fp_invoice = invoice.fiscal_position_id\\n invoice._onchange_partner_id()\\n invoice.fiscal_position_id = fp_invoice\\n # To keep the payment terms set on the SO\\n invoice.payment_term_id = so_payment_term_id\\n invoice.message_post_with_view('mail.message_origin_link',\\n values={'self': invoice, 'origin': references[invoice]},\\n subtype_id=self.env.ref('mail.mt_note').id)\\n return [inv.id for inv in invoices.values()]\",\n \"def _get_related_invoices(self):\\n rslt = super(StockMove, self)._get_related_invoices()\\n rslt += self.mapped('picking_id.subcontract_id.invoice_ids').filtered(lambda x: x.state not in ('draft', 'cancel'))\\n return rslt\",\n \"def create_invoices(self, cr, uid, ids, context=None):\\n invoice_list = []\\n po_obj = self.pool.get('purchase.order')\\n inv_line_obj = self.pool.get('account.invoice.line')\\n inv_obj = self.pool.get('account.invoice')\\n addr_obj = self.pool.get('res.partner')\\n journal_obj = self.pool.get('account.journal')\\n if context is None:\\n context = {}\\n\\n for purchase_adv_obj in self.browse(cr, uid, ids, context=context):\\n for purchase_order in po_obj.browse(cr, uid, context.get('active_ids', []), context=context):\\n inv_line_ids = []\\n invoice_ids = []\\n val = inv_line_obj.product_id_change(cr, uid, [], purchase_adv_obj.product_id.id,\\n uom_id=False, partner_id=purchase_order.partner_id.id, fposition_id=purchase_order.fiscal_position.id)\\n line_id = inv_line_obj.create(cr, uid, {\\n 'name': val['value']['name'],\\n 'account_id': val['value']['account_id'],\\n 'price_unit': purchase_adv_obj.amount,\\n 'quantity': purchase_adv_obj.qtty,\\n 'discount': False,\\n 'uos_id': val['value']['uos_id'],\\n 'product_id': purchase_adv_obj.product_id.id,\\n 'invoice_line_tax_id': [(6, 0, val['value']['invoice_line_tax_id'])],\\n })\\n inv_line_ids.append(line_id)\\n addr = addr_obj.address_get(cr, uid, [purchase_order.partner_id.id], ['invoice'])\\n journal_ids = journal_obj.search(cr, uid, [('type', '=', 'purchase')])\\n context.update({'type':'in_invoice','journal_type':'purchase'})\\n inv_vals = {\\n 'name': purchase_order.partner_ref or purchase_order.name,\\n 'origin': purchase_order.name,\\n 'type': 'in_invoice',\\n 'reference': False,\\n 'account_id': purchase_order.partner_id.property_account_payable.id,\\n 'journal_id':journal_ids and journal_ids[0] or False,\\n 'partner_id': purchase_order.partner_id.id,\\n 'address_invoice_id': addr['invoice'],\\n 'invoice_line': [(6, 0, inv_line_ids)],\\n 'currency_id': purchase_order.pricelist_id.currency_id.id,\\n 'comment': '',\\n 'payment_term': purchase_order.payment_term_id and purchase_order.payment_term_id.id or False,\\n 'fiscal_position': purchase_order.fiscal_position.id or purchase_order.partner_id.property_account_position.id,\\n 'prepaid': True\\n }\\n\\n inv_id = inv_obj.create(cr, uid, inv_vals, context=context)\\n inv_obj.button_reset_taxes(cr, uid, [inv_id], context=context)\\n for invoice in purchase_order.invoice_ids:\\n invoice_ids.append(invoice.id)\\n invoice_ids.append(inv_id)\\n po_obj.write(cr, uid, purchase_order.id, {'invoice_ids': [(6, 0, invoice_ids)]})\\n invoice_list.append(inv_id)\\n\\n if purchase_order.invoice_method in ('picking','order'):\\n self.pool.get('purchase.order.line').create(cr, uid, {\\n 'order_id': purchase_order.id,\\n 'name': val['value']['name'],\\n 'date_planned':purchase_order.date_order,\\n 'price_unit': -purchase_adv_obj.amount,\\n 'product_uom_qty': purchase_adv_obj.qtty,\\n 'product_uos': val['value']['uos_id'],\\n 'product_uom': val['value']['uos_id'],\\n 'product_id': purchase_adv_obj.product_id.id,\\n 'adavance_product':True,\\n 'discount': False,\\n 'taxes_id': [(6, 0, val['value']['invoice_line_tax_id'])],\\n }, context=context)\\n\\n\\n context.update({'invoice_id':invoice_list})\\n return {\\n 'name': 'Open Invoice',\\n 'view_type': 'form',\\n 'view_mode': 'form',\\n 'res_model': 'purchase.open.invoice',\\n 'type': 'ir.actions.act_window',\\n 'target': 'new',\\n 'context': context\\n }\",\n \"def action_move_create(self):\\n inv_obj = self.env['account.invoice']\\n context = dict(self._context or {})\\n context.update({'wh_src': True})\\n ret = self.browse(self.ids[0])\\n for line in ret.line_ids:\\n if line.move_id:\\n raise exceptions.except_orm(\\n _('Invoice already withhold !'),\\n _(\\\"You must omit the follow invoice '%s' !\\\") %\\n (line.invoice_id.number,))\\n\\n acc_id = ret.account_id.id\\n journal_id = ret.journal_id.id\\n demo_enabled = self.env['ir.module.module'].search(\\n [('name', '=', 'base'), ('demo', '=', True)])\\n args = [('id', 'in')]\\n if not demo_enabled:\\n args.append(('special', '=', False))\\n\\n if ret.line_ids:\\n for line in ret.line_ids:\\n writeoff_account_id, writeoff_journal_id = False, False\\n amount = line.wh_amount\\n if line.invoice_id.type in ['in_invoice', 'in_refund']:\\n name = 'COMP. RET. CRS ' + ret.number + ' Doc. ' + (\\n line.invoice_id.supplier_invoice_number or '')\\n else:\\n name = 'COMP. RET. CRS ' + ret.number + ' Doc. ' + (\\n line.invoice_id.number or '')\\n # ret_move = inv_obj.ret_and_reconcile(\\n # self, [line.invoice_id.id], amount, acc_id,\\n # journal_id, writeoff_account_id,\\n # writeoff_journal_id, ret.date_ret, name, [line]\\n # )\\n # rl = {\\n # 'move_id': ret_move['move_id'],\\n # }\\n #lines = [(1, line.id)]\\n self.write({'line_ids': line})\\n\\n if (line.invoice_id.type in [\\n 'out_invoice', 'out_refund']):\\n inv_obj.write({'wh_src_id': ret.id})\\n else:\\n return False\\n return True\",\n \"def recompute_billing_lines(self, cr, uid, ids, partner_id, journal_id, price, currency_id, date, context=None):\\n def _remove_noise_in_o2m():\\n \\\"\\\"\\\"if the line is partially reconciled, then we must pay attention to display it only once and\\n in the good o2m.\\n This function returns True if the line is considered as noise and should not be displayed\\n \\\"\\\"\\\"\\n if line.reconcile_partial_id:\\n sign = 1\\n if currency_id == line.currency_id.id:\\n if line.amount_residual_currency * sign <= 0:\\n return True\\n else:\\n if line.amount_residual * sign <= 0:\\n return True\\n return False\\n\\n if context is None:\\n context = {}\\n billing_date_condition = context.get('billing_date_condition', [])\\n context_multi_currency = context.copy()\\n if date:\\n context_multi_currency.update({'date': date})\\n\\n currency_pool = self.pool.get('res.currency')\\n move_line_pool = self.pool.get('account.move.line')\\n partner_pool = self.pool.get('res.partner')\\n journal_pool = self.pool.get('account.journal')\\n line_pool = self.pool.get('account.billing.line')\\n\\n #set default values\\n default = {\\n 'value': {'line_cr_ids': [] },\\n }\\n\\n #drop existing lines\\n line_ids = ids and line_pool.search(cr, uid, [('billing_id', '=', ids[0])]) or False\\n if line_ids:\\n line_pool.unlink(cr, uid, line_ids)\\n\\n if not partner_id or not journal_id:\\n return default\\n\\n journal = journal_pool.browse(cr, uid, journal_id, context=context)\\n partner = partner_pool.browse(cr, uid, partner_id, context=context)\\n currency_id = currency_id or journal.company_id.currency_id.id\\n account_id = False\\n if journal.type in ('sale','sale_refund'):\\n account_id = partner.property_account_receivable.id\\n elif journal.type in ('purchase', 'purchase_refund','expense'):\\n account_id = partner.property_account_payable.id\\n else:\\n account_id = journal.default_credit_account_id.id or journal.default_debit_account_id.id\\n\\n default['value']['account_id'] = account_id\\n\\n if journal.type not in ('cash', 'bank'):\\n return default\\n\\n total_credit = price or 0.0\\n account_type = 'receivable'\\n\\n if not context.get('move_line_ids', False):\\n ids = move_line_pool.search(cr, uid, \\n [('state','=','valid'), ('account_id.type', '=', account_type), ('reconcile_id', '=', False), ('partner_id', '=', partner_id), \\n ] + billing_date_condition, \\n context=context)\\n else:\\n ids = context['move_line_ids']\\n invoice_id = context.get('invoice_id', False)\\n company_currency = journal.company_id.currency_id.id\\n move_line_found = False\\n\\n #order the lines by most old first\\n ids.reverse()\\n account_move_lines = move_line_pool.browse(cr, uid, ids, context=context)\\n\\n #compute the total debit/credit and look for a matching open amount or invoice\\n for line in account_move_lines:\\n if _remove_noise_in_o2m():\\n continue\\n\\n if invoice_id:\\n if line.invoice.id == invoice_id:\\n #if the invoice linked to the billing line is equal to the invoice_id in context\\n #then we assign the amount on that line, whatever the other billing lines\\n move_line_found = line.id\\n break\\n elif currency_id == company_currency:\\n #otherwise treatments is the same but with other field names\\n if line.amount_residual == price:\\n #if the amount residual is equal the amount billing, we assign it to that billing\\n #line, whatever the other billing lines\\n move_line_found = line.id\\n break\\n #otherwise we will split the billing amount on each line (by most old first)\\n total_credit += line.credit or 0.0\\n elif currency_id == line.currency_id.id:\\n if line.amount_residual_currency == price:\\n move_line_found = line.id\\n break\\n total_credit += line.credit and line.amount_currency or 0.0\\n\\n #billing line creation\\n for line in account_move_lines:\\n\\n if _remove_noise_in_o2m():\\n continue\\n\\n if line.currency_id and currency_id==line.currency_id.id:\\n amount_original = abs(line.amount_currency)\\n amount_unreconciled = abs(line.amount_residual_currency)\\n else:\\n amount_original = currency_pool.compute(cr, uid, company_currency, currency_id, line.credit or 0.0)\\n amount_unreconciled = currency_pool.compute(cr, uid, company_currency, currency_id, abs(line.amount_residual))\\n line_currency_id = line.currency_id and line.currency_id.id or company_currency\\n rs = {\\n 'move_line_id':line.id,\\n 'type': line.credit and 'dr' or 'cr',\\n 'reference':line.invoice.reference,\\n 'account_id':line.account_id.id,\\n 'amount_original': amount_original,\\n 'amount': (move_line_found == line.id) and min(abs(price), amount_unreconciled) or amount_unreconciled,\\n 'date_original':line.date,\\n 'date_due':line.date_maturity,\\n 'amount_unreconciled': amount_unreconciled,\\n 'currency_id': line_currency_id,\\n }\\n \\n # Negate DR records\\n if rs['type'] == 'dr':\\n rs['amount_original'] = - rs['amount_original']\\n rs['amount'] = - rs['amount']\\n rs['amount_unreconciled'] = - rs['amount_unreconciled']\\n\\n if rs['amount_unreconciled'] == rs['amount']:\\n rs['reconcile'] = True\\n else:\\n rs['reconcile'] = False\\n\\n default['value']['line_cr_ids'].append(rs)\\n\\n# if ttype == 'payment' and len(default['value']['line_cr_ids']) > 0:\\n# default['value']['pre_line'] = 1\\n# elif ttype == 'receipt' and len(default['value']['line_dr_ids']) > 0:\\n# default['value']['pre_line'] = 1\\n default['value']['billing_amount'] = self._compute_billing_amount(cr, uid, default['value']['line_cr_ids'], price)\\n return default\",\n \"def create_invoice(self):\\n for line in self:\\n # if not line.account_id:\\n # raise UserError(_('Please Add the incoming Account !!'))\\n self.ensure_one()\\n journal_id = self.env['account.journal'].search([\\n ('type', '=', 'sale')], limit=1)\\n inv_line_main = {\\n 'name': line.description.name,\\n 'price_unit': line.amount or 0.00,\\n 'quantity': 1,\\n 'discount': line.discount,\\n 'account_id': line.description.property_account_income_id.id or line.description.categ_id.property_account_income_categ_id.id or False,\\n }\\n inv_values = {\\n 'partner_id': line.patient_id.partner_id.id,\\n 'patient_id': line.patient_id.id,\\n 'dentist': line.dentist.id,\\n 'move_type': 'out_invoice',\\n 'invoice_date': datetime.now().strftime(DF) or False,\\n 'journal_id': journal_id and journal_id.id or False,\\n 'teeth_id': line.patient_id and line.patient_id.id or False,\\n }\\n acc_id = self.env['account.move'].create(inv_values)\\n acc_id.write({'invoice_line_ids': [(0, 0, inv_line_main)]})\\n\\n self.write({'invc_id': acc_id.id, 'inv': True})\\n context = dict(self._context or {})\\n wiz_form_id = self.env['ir.model.data'].get_object_reference(\\n 'account', 'view_move_form')[1]\\n\\n return {\\n 'view_type': 'form',\\n 'view_id': wiz_form_id,\\n 'view_mode': 'form',\\n 'res_model': 'account.move',\\n 'res_id': self.invc_id.id,\\n 'type': 'ir.actions.act_window',\\n 'target': 'current',\\n 'context': context,\\n }\",\n \"def action_move_create(self):\\n res = super(HrExpenseExpense, self).action_move_create()\\n for expense in self:\\n if expense.invoice:\\n partner = expense.invoice.partner_id.commercial_partner_id\\n move_lines = expense.account_move_id.line_ids\\n c_move_lines = move_lines.filtered(\\n lambda x: x.partner_id == partner and\\n x.debit == abs(round(expense.invoice.residual, 2)))\\n c_move_lines |= expense.invoice.move_id.line_ids.filtered(\\n lambda x: x.account_id == expense.invoice.account_id and\\n x.credit == abs(round(expense.invoice.residual, 2)))\\n if len(c_move_lines) != 2:\\n raise exceptions.Warning(\\n _('Cannot reconcile supplier invoice payable with '\\n 'generated line. Please check amounts and see '\\n 'if the invoice is already added or paid. '\\n 'Invoice: %s') % expense.invoice.number)\\n c_move_lines.reconcile()\\n return res\",\n \"def withholding_reconciliation(self):\\n\\n for inv_brw in self:\\n move_ids = [move.id or False\\n for move in (inv_brw.move_id, inv_brw.wh_move_id)]\\n\\n if not all(move_ids):\\n continue\\n\\n line_ids = [line.id\\n for move2 in (inv_brw.move_id, inv_brw.wh_move_id)\\n for line in move2.line_id\\n if line.account_id.id == inv_brw.account_id.id]\\n\\n if len(line_ids) < 2:\\n continue\\n\\n # /!\\\\ NOTE: There could be some payments in the invoice let us\\n # reconcile them too\\n line_ids += [lin2.id for lin2 in inv_brw.payment_ids]\\n line_ids = list(set(line_ids))\\n\\n line_ids = self.env['account.move.line'].browse(line_ids)\\n line_ids.reconcile_partial()\\n\\n return True\",\n \"def _prepare_invoice(self, cr, uid, order, lines, context=None):\\n if context is None:\\n context = {}\\n journal_ids = self.pool.get('account.journal').search(cr, uid,\\n [('type', '=', 'sale'), ('company_id', '=', order.company_id.id)],\\n limit=1)\\n if not journal_ids:\\n raise osv.except_osv(_('Error !'),\\n _('There is no sales journal defined for this company: \\\"%s\\\" (id:%d)') % (order.company_id.name, order.company_id.id))\\n\\n invoice_vals = {\\n 'name': order.client_order_ref or '',\\n 'origin': order.name,\\n 'type': 'out_invoice',\\n 'reference': order.client_order_ref or order.name,\\n 'account_id': order.partner_id.property_account_receivable.id,\\n 'journal_id': order.partner_id.property_default_sale_invoice_journal.id,\\n 'partner_id': order.partner_id.id,\\n 'address_invoice_id': order.partner_invoice_id.id,\\n #'address_contact_id': order.partner_order_id.id,\\n 'invoice_line': [(6, 0, lines)],\\n 'currency_id': order.pricelist_id.currency_id.id,\\n 'comment': order.note,\\n 'payment_term': order.payment_term and order.payment_term.id or False,\\n 'fiscal_position': order.fiscal_position.id or order.partner_id.property_account_position.id,\\n 'date_invoice': context.get('date_invoice', False),\\n 'company_id': order.company_id.id,\\n 'user_id': order.user_id and order.user_id.id or False\\n }\\n\\n # Care for deprecated _inv_get() hook - FIXME: to be removed after 6.1\\n invoice_vals.update(self._inv_get(cr, uid, order, context=context))\\n\\n return invoice_vals\",\n \"def _prepare_invoice_grp(self, cr, uid, order, line_ids, context=None):\\n if context is None:\\n context = {}\\n context = dict(context)\\n\\n inv_data = super(grp_orden_compra, self)._prepare_invoice_grp(cr, uid, order, line_ids, context=context)\\n\\n # adicionando campos numero compromiso y no obligacion desde la OC\\n monto_oc = math.floor(order.total_llavep or 0)\\n monto_oc = int(monto_oc)\\n inv_data.update({'nro_compromiso': order.nro_compromiso or False, 'monto_comprometido': monto_oc or 0, 'currency_id':order.currency_oc.id})\\n\\n # adicionando campos no afectacion y monto autorizado desde la primera APG\\n if order.pc_apg_id:\\n first_apg = order.pc_apg_id\\n monto_apg = math.floor(first_apg.total_llavep)\\n monto_apg = int(monto_apg)\\n # TODO R SPRING X ADICIONANDO CABEZALES SIIF A LA FACTURA A PARTIR DE LA APG\\n inv_data.update({'nro_afectacion': first_apg.nro_afectacion_siif or False,\\n 'monto_afectado': monto_apg or 0,\\n 'siif_tipo_ejecucion':first_apg.siif_tipo_ejecucion.id,\\n 'siif_concepto_gasto':first_apg.siif_concepto_gasto.id,\\n 'siif_financiamiento':first_apg.siif_financiamiento.id,\\n 'siif_codigo_sir':first_apg.siif_codigo_sir.id,\\n 'siif_nro_fondo_rot':first_apg.siif_nro_fondo_rot.id,\\n }) # cambiando nro_afectacion 23/10\\n # inv.update({'nro_afectacion': first_apg.nro_afectacion_apg or False, 'monto_afectado': monto_apg or 0})\\n\\n # # TODO R SPRING X NO LLEVAR LAS LLAVES PRESUPUESTALES POR DEFECTO\\n # if order.pc_apg_id.llpapg_ids:\\n # llavep_ids = []\\n # for llavep in order.pc_apg_id.llpapg_ids:\\n # llavep_ids.append((0, 0, {\\n # 'programa_id': llavep.programa_id.id,\\n # 'odg_id': llavep.odg_id.id,\\n # 'auxiliar_id': llavep.auxiliar_id.id,\\n # 'disponible': llavep.disponible,\\n # 'proyecto_id': llavep.proyecto_id.id,\\n # 'fin_id': llavep.fin_id.id,\\n # 'mon_id': llavep.mon_id.id,\\n # 'tc_id': llavep.tc_id.id,\\n # 'importe': llavep.importe\\n # }))\\n # inv_data.update({'llpapg_ids': llavep_ids})\\n\\n return inv_data\",\n \"def _prepare_invoice(self, cr, uid, order, lines, context=None):\\n if context is None:\\n context = {}\\n journal_id = self.pool['account.invoice'].default_get(cr, uid, ['journal_id'], context=context)['journal_id']\\n if not journal_id:\\n raise osv.except_osv(_('Error!'),\\n _('Please define sales journal for this company: \\\"%s\\\" (id:%d).') % (order.company_id.name, order.company_id.id))\\n invoice_vals = {\\n 'name': order.client_order_ref or '',\\n 'origin': order.name,\\n 'type': 'out_invoice',\\n 'reference': order.client_order_ref or order.name,\\n 'account_id': order.partner_invoice_id.property_account_receivable.id,\\n 'partner_id': order.partner_invoice_id.id,\\n 'journal_id': journal_id,\\n 'invoice_line': [(6, 0, lines)],\\n 'currency_id': order.pricelist_id.currency_id.id,\\n 'comment': order.note,\\n 'payment_term': order.payment_term and order.payment_term.id or False,\\n 'fiscal_position': order.fiscal_position.id or order.partner_invoice_id.property_account_position.id,\\n 'date_invoice': context.get('date_invoice', False),\\n 'company_id': order.company_id.id,\\n 'user_id': order.user_id and order.user_id.id or False,\\n 'section_id' : order.section_id.id,\\n 'test_1' :order.test\\n }\\n\\n # Care for deprecated _inv_get() hook - FIXME: to be removed after 6.1\\n invoice_vals.update(self._inv_get(cr, uid, order, context=context))\\n return invoice_vals\",\n \"def duplicate_invoice(invoice):\\n from invoicer.models import Invoice\\n from invoicer.models import LineItem\\n\\n # copy main attributes\\n new_invoice = Invoice(\\n company=invoice.company,\\n invoice_date=datetime.now(),\\n client=invoice.client,\\n location=invoice.location,\\n tax_rate=invoice.tax_rate,\\n left_address=invoice.left_address,\\n right_address=invoice.right_address,\\n terms=invoice.terms,\\n footer=invoice.footer\\n )\\n new_invoice.save()\\n\\n # now line items\\n for line_item in invoice.line_items.all():\\n new_invoice.line_items.add(LineItem(\\n name=line_item.name,\\n description=line_item.description,\\n price=line_item.price,\\n taxable=line_item.taxable,\\n item=line_item.item,\\n quantity=line_item.quantity\\n ))\\n\\n return new_invoice\",\n \"def action_cancel_draft(self):\\n for statement in self:\\n statement_lines = statement.credit_move_line_ids + statement.debit_move_line_ids\\n for statement_line in statement_lines:\\n if statement_line:\\n statement_line.write({'cleared_bank_account': False,\\n 'research_required': False\\n })\\n if statement_line.move_line_id:\\n statement_line.move_line_id.write({'cleared_bank_account': False,\\n 'bank_acc_rec_statement_id': False,\\n })\\n if statement_line.move_line_id.move_id:\\n statement_line.move_line_id.move_id.write({'is_reconciled': False})\\n\\n statement.write({'state': 'draft',\\n 'verified_by_user_id': False,\\n 'verified_date': False\\n })\\n return True\",\n \"def envoi_par_mail(self):\\n cr , uid, context = self.env.args\\n if not self.pool['res.users'].has_group(cr, uid, 'is_plastigray.is_comptable_group'):\\n raise Warning(u\\\"Accès non autorisé !\\\")\\n ids=[]\\n for obj in self:\\n ids.append(str(obj.id))\\n if len(ids)>0:\\n SQL=\\\"\\\"\\\"\\n select ai.is_mode_envoi_facture, ai.partner_id, ai.name, ai.id\\n from account_invoice ai\\n where \\n ai.id in(\\\"\\\"\\\"+','.join(ids)+\\\"\\\"\\\") and \\n ai.is_date_envoi_mail is null and \\n ai.is_mode_envoi_facture like 'mail%'\\n order by ai.is_mode_envoi_facture, ai.partner_id, ai.name\\n \\\"\\\"\\\"\\n cr.execute(SQL)\\n result = cr.fetchall()\\n\\n # ** Un mail par client*********************************************\\n partners={}\\n for row in result:\\n if row[0]=='mail_client':\\n partner_id = row[1]\\n id = row[3]\\n if not partner_id in partners:\\n partners[partner_id]=[]\\n partners[partner_id].append(id)\\n #*******************************************************************\\n\\n\\n # ** Un mail+BL par client******************************************\\n for row in result:\\n if row[0]=='mail_client_bl':\\n partner_id = row[1]\\n id = row[3]\\n if not partner_id in partners:\\n partners[partner_id]=[]\\n partners[partner_id].append(id)\\n #*******************************************************************\\n\\n\\n #** Envoi des mails par partner ************************************\\n for partner_id in partners:\\n ids=partners[partner_id]\\n self._envoi_par_mail(partner_id, ids)\\n #*******************************************************************\\n\\n\\n # ** Un mail par facture *******************************************\\n for row in result:\\n if row[0] in ['mail', 'mail_regroupe_bl']:\\n partner_id = row[1]\\n id = row[3]\\n self._envoi_par_mail(partner_id, [id])\\n #*******************************************************************\\n\\n\\n # ** Un mail par facture en double exemplaire **********************\\n for row in result:\\n if row[0]=='mail2':\\n partner_id = row[1]\\n id = row[3]\\n self._envoi_par_mail(partner_id, [id])\\n #*******************************************************************\",\n \"def button_fac_cob_ent(self):\\n invoice = self._fac_ent()\\n\\n # pagar la factura\\n # hacer configuracion para modificar esto\\n receipt_obj = self.env['account.voucher.receiptbook']\\n receipt = receipt_obj.search([('name', 'like', 'Recibos')], limit=1)\\n\\n journal = self.journal_id\\n res = invoice.invoice_pay_customer()\\n context = res['context']\\n\\n account_voucher_obj = self.env['account.voucher']\\n voucher = account_voucher_obj.create({\\n 'partner_id': context['default_partner_id'],\\n 'journal_id': journal.id,\\n 'account_id': journal.default_debit_account_id.id,\\n 'type': context['type'],\\n 'amount': context['default_amount'],\\n 'net_amount': context['default_amount'],\\n 'receiptbook_id': receipt.id,\\n 'company_id': self.env.user.company_id.id\\n })\\n voucher.signal_workflow('proforma_voucher')\\n\\n account_move_line_obj = self.env['account.move.line']\\n\\n # obtener un recordser vacio\\n lines2rec = account_move_line_obj.browse()\\n\\n # obtener las lineas a conciliar de facturas\\n account_move_line = account_move_line_obj.search(\\n [('document_number', '=', invoice.document_number)])\\n for re in account_move_line:\\n if re.account_id.reconcile:\\n lines2rec += re\\n\\n # obtener las lineas a conciliar de pagos\\n account_move_line = account_move_line_obj.search(\\n [('document_number', '=', voucher.document_number)])\\n for re in account_move_line:\\n if re.account_id.reconcile:\\n lines2rec += re\\n\\n period_obj = self.env['account.period']\\n period = period_obj.find()\\n\\n # reconciliar las lineas de factura con pagos\\n lines2rec.reconcile('manual',\\n journal.default_debit_account_id.id, # writeoff_acc_id\\n period.id, # writeoff_period_id,\\n journal.id) # writeoff_journal_id)\\n\\n # imprime factura\\n datas = {\\n 'ids': invoice.ids,\\n 'model': 'account.report_invoice',\\n 'form': invoice.read()\\n }\\n return {\\n 'type': 'ir.actions.report.xml',\\n 'report_name': 'aeroo_report_ar_einvoice',\\n 'datas': datas,\\n }\",\n \"def action_invoice_create(self, cr, uid, ids, context=None):\\n res = False\\n\\n journal_obj = self.pool.get('account.journal')\\n inv_obj = self.pool.get('account.invoice')\\n inv_line_obj = self.pool.get('account.invoice.line')\\n fiscal_obj = self.pool.get('account.fiscal.position')\\n\\n for order in self.browse(cr, uid, ids, context=context):\\n# pay_acc_id = order.partner_id.property_account_payable.id\\n #use a new method to get the account_id\\n pay_acc_id = self._get_inv_pay_acc_id(cr,uid,order) \\n journal_ids = journal_obj.search(cr, uid, [('type', '=','purchase'),('company_id', '=', order.company_id.id)], limit=1)\\n if not journal_ids:\\n raise osv.except_osv(_('Error!'),\\n _('Define purchase journal for this company: \\\"%s\\\" (id:%d).') % (order.company_id.name, order.company_id.id))\\n\\n # generate invoice line correspond to PO line and link that to created invoice (inv_id) and PO line\\n inv_lines = []\\n for po_line in order.order_line:\\n #check if this line have quantity to generate invoice, by johnw\\n if po_line.product_qty <= po_line.invoice_qty:\\n continue \\n# if po_line.product_id:\\n# acc_id = po_line.product_id.property_account_expense.id\\n# if not acc_id:\\n# acc_id = po_line.product_id.categ_id.property_account_expense_categ.id\\n# if not acc_id:\\n# raise osv.except_osv(_('Error!'), _('Define expense account for this company: \\\"%s\\\" (id:%d).') % (po_line.product_id.name, po_line.product_id.id,))\\n# else:\\n# acc_id = property_obj.get(cr, uid, 'property_account_expense_categ', 'product.category').id \\n #use a new method to get the account_id, by johnw \\n acc_id = self._get_inv_line_exp_acc_id(cr,uid,order,po_line)\\n fpos = order.fiscal_position or False\\n acc_id = fiscal_obj.map_account(cr, uid, fpos, acc_id)\\n\\n inv_line_data = self._prepare_inv_line(cr, uid, acc_id, po_line, context=context)\\n #update the quantity to the quantity, by johnw\\n inv_line_data.update({'quantity':(po_line.product_qty - po_line.invoice_qty)})\\n inv_line_id = inv_line_obj.create(cr, uid, inv_line_data, context=context)\\n inv_lines.append(inv_line_id)\\n\\n po_line.write({'invoiced':True, 'invoice_lines': [(4, inv_line_id)]}, context=context)\\n \\n #if no lines then return direct, by johnw\\n if len(inv_lines) == 0:\\n continue\\n \\n # get invoice data and create invoice\\n inv_data = {\\n 'name': order.partner_ref or order.name,\\n 'reference': order.partner_ref or order.name,\\n 'account_id': pay_acc_id,\\n 'type': 'in_invoice',\\n 'partner_id': order.partner_id.id,\\n 'currency_id': order.pricelist_id.currency_id.id,\\n 'journal_id': len(journal_ids) and journal_ids[0] or False,\\n 'invoice_line': [(6, 0, inv_lines)],\\n 'origin': order.name,\\n 'fiscal_position': order.fiscal_position.id or False,\\n 'payment_term': order.payment_term_id.id or False,\\n 'company_id': order.company_id.id,\\n }\\n inv_id = inv_obj.create(cr, uid, inv_data, context=context)\\n\\n # compute the invoice\\n inv_obj.button_compute(cr, uid, [inv_id], context=context, set_total=True)\\n\\n # Link this new invoice to related purchase order\\n order.write({'invoice_ids': [(4, inv_id)]}, context=context)\\n res = inv_id\\n return res\",\n \"def action_move_create(self, cr, uid, ids, context=None):\\n ait_obj = self.pool.get('account.invoice.tax')\\n cur_obj = self.pool.get('res.currency')\\n period_obj = self.pool.get('account.period')\\n payment_term_obj = self.pool.get('account.payment.term')\\n journal_obj = self.pool.get('account.journal')\\n move_obj = self.pool.get('account.move')\\n if context is None:\\n context = {}\\n for inv in self.browse(cr, uid, ids, context=context):\\n if not inv.journal_id.sequence_id:\\n raise osv.except_osv(_('Error!'), _('Please define sequence on the journal related to this invoice.'))\\n if not inv.invoice_line:\\n raise osv.except_osv(_('No Invoice Lines!'), _('Please create some invoice lines.'))\\n if inv.move_id:\\n continue\\n\\n ctx = context.copy()\\n ctx.update({'lang': inv.partner_id.lang})\\n if not inv.date_invoice:\\n self.write(cr, uid, [inv.id], {'date_invoice': fields.date.context_today(self,cr,uid,context=context)}, context=ctx)\\n company_currency = self.pool['res.company'].browse(cr, uid, inv.company_id.id).currency_id.id\\n # create the analytical lines\\n # one move line per invoice line\\n iml = self._get_analytic_lines(cr, uid, inv.id, context=ctx)\\n # check if taxes are all computed\\n compute_taxes = ait_obj.compute(cr, uid, inv.id, context=ctx)\\n self.check_tax_lines(cr, uid, inv, compute_taxes, ait_obj)\\n\\n # I disabled the check_total feature\\n group_check_total_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account', 'group_supplier_inv_check_total')[1]\\n group_check_total = self.pool.get('res.groups').browse(cr, uid, group_check_total_id, context=context)\\n if group_check_total and uid in [x.id for x in group_check_total.users]:\\n if (inv.type in ('in_invoice', 'in_refund') and abs(inv.check_total - inv.amount_total) >= (inv.currency_id.rounding/2.0)):\\n raise osv.except_osv(_('Bad Total!'), _('Please verify the price of the invoice!\\\\nThe encoded total does not match the computed total.'))\\n\\n if inv.payment_term:\\n total_fixed = total_percent = 0\\n for line in inv.payment_term.line_ids:\\n if line.value == 'fixed':\\n total_fixed += line.value_amount\\n if line.value == 'procent':\\n total_percent += line.value_amount\\n total_fixed = (total_fixed * 100) / (inv.amount_total or 1.0)\\n if (total_fixed + total_percent) > 100:\\n raise osv.except_osv(_('Error!'), _(\\\"Cannot create the invoice.\\\\nThe related payment term is probably misconfigured as it gives a computed amount greater than the total invoiced amount. In order to avoid rounding issues, the latest line of your payment term must be of type 'balance'.\\\"))\\n\\n # one move line per tax line\\n iml += ait_obj.move_line_get(cr, uid, inv.id)\\n\\n entry_type = ''\\n if inv.type in ('in_invoice', 'in_refund'):\\n ref = inv.reference\\n entry_type = 'journal_pur_voucher'\\n if inv.type == 'in_refund':\\n entry_type = 'cont_voucher'\\n else:\\n ref = self._convert_ref(cr, uid, inv.number)\\n entry_type = 'journal_sale_vou'\\n if inv.type == 'out_refund':\\n entry_type = 'cont_voucher'\\n\\n diff_currency_p = inv.currency_id.id <> company_currency\\n # create one move line for the total and possibly adjust the other lines amount\\n total = 0\\n total_currency = 0\\n total, total_currency, iml = self.compute_invoice_totals(cr, uid, inv, company_currency, ref, iml, context=ctx)\\n acc_id = inv.account_id.id\\n\\n name = inv['name'] or inv['supplier_invoice_number'] or '/'\\n totlines = False\\n # kittiu\\n #if inv.payment_term:\\n if inv.payment_term and not inv.date_due:\\n # --\\n totlines = payment_term_obj.compute(cr,\\n uid, inv.payment_term.id, total, inv.date_invoice or False, context=ctx)\\n if totlines:\\n res_amount_currency = total_currency\\n i = 0\\n ctx.update({'date': inv.date_invoice})\\n for t in totlines:\\n if inv.currency_id.id != company_currency:\\n amount_currency = cur_obj.compute(cr, uid, company_currency, inv.currency_id.id, t[1], context=ctx)\\n else:\\n amount_currency = False\\n\\n # last line add the diff\\n res_amount_currency -= amount_currency or 0\\n i += 1\\n if i == len(totlines):\\n amount_currency += res_amount_currency\\n\\n iml.append({\\n 'type': 'dest',\\n 'name': name,\\n 'price': t[1],\\n 'account_id': acc_id,\\n 'date_maturity': t[0],\\n 'amount_currency': diff_currency_p \\\\\\n and amount_currency or False,\\n 'currency_id': diff_currency_p \\\\\\n and inv.currency_id.id or False,\\n 'ref': ref,\\n })\\n else:\\n iml.append({\\n 'type': 'dest',\\n 'name': name,\\n 'price': total,\\n 'account_id': acc_id,\\n 'date_maturity': inv.date_due or False,\\n 'amount_currency': diff_currency_p \\\\\\n and total_currency or False,\\n 'currency_id': diff_currency_p \\\\\\n and inv.currency_id.id or False,\\n 'ref': ref\\n })\\n\\n date = inv.date_invoice or time.strftime('%Y-%m-%d')\\n\\n part = self.pool.get(\\\"res.partner\\\")._find_accounting_partner(inv.partner_id)\\n\\n line = map(lambda x:(0,0,self.line_get_convert(cr, uid, x, part.id, date, context=ctx)),iml)\\n\\n line = self.group_lines(cr, uid, iml, line, inv)\\n\\n journal_id = inv.journal_id.id\\n journal = journal_obj.browse(cr, uid, journal_id, context=ctx)\\n if journal.centralisation:\\n raise osv.except_osv(_('User Error!'),\\n _('You cannot create an invoice on a centralized journal. Uncheck the centralized counterpart box in the related journal from the configuration menu.'))\\n\\n line = self.finalize_invoice_move_lines(cr, uid, inv, line)\\n\\n move = {\\n 'ref': inv.reference and inv.reference or inv.name,\\n 'line_id': line,\\n 'journal_id': journal_id,\\n 'date': date,\\n 'narration': inv.comment,\\n 'company_id': inv.company_id.id,\\n }\\n period_id = inv.period_id and inv.period_id.id or False\\n ctx.update(company_id=inv.company_id.id,\\n account_period_prefer_normal=True)\\n if not period_id:\\n period_ids = period_obj.find(cr, uid, inv.date_invoice, context=ctx)\\n period_id = period_ids and period_ids[0] or False\\n if period_id:\\n move['period_id'] = period_id\\n for i in line:\\n i[2]['period_id'] = period_id\\n\\n ctx.update(invoice=inv)\\n move_id = move_obj.create(cr, uid, move, context=ctx)\\n new_move_name = move_obj.browse(cr, uid, move_id, context=ctx).name\\n # make the invoice point to that move\\n self.write(cr, uid, [inv.id], {'move_id': move_id,'period_id':period_id, 'move_name':new_move_name}, context=ctx)\\n # Pass invoice in context in method post: used if you want to get the same\\n # account move reference when creating the same invoice after a cancelled one:\\n move_obj.post(cr, uid, [move_id], context=ctx)\\n self._log_event(cr, uid, ids)\\n return True\",\n \"def action_invoice_create(self, cr, uid, ids, grouped=False, states=None, date_invoice=False, context=None):\\n order = self.browse(cr, uid, ids[0], context=context)\\n inv_obj = self.pool.get('account.invoice')\\n # create the invoice\\n inv_id = super(sale_order, self).action_invoice_create(cr, uid, ids, grouped, states, date_invoice, context=context)\\n # modify the invoice\\n inv_obj.write(cr, uid, [inv_id], {'past_doc': order.past_doc})\\n return inv_id\",\n \"def action_move_create(self, cr, uid, ids, context=None):\\n ait_obj = self.pool.get('account.invoice.tax')\\n cur_obj = self.pool.get('res.currency')\\n period_obj = self.pool.get('account.period')\\n payment_term_obj = self.pool.get('account.payment.term')\\n journal_obj = self.pool.get('account.journal')\\n move_obj = self.pool.get('account.move')\\n if context is None:\\n context = {}\\n for inv in self.browse(cr, uid, ids, context=context):\\n if not inv.journal_id:\\n raise orm.except_orm(_('Error!'),\\n _('Journal not defined for this invoice!'))\\n if not inv.journal_id.iva_registry_id:\\n raise orm.except_orm(_('Error!'),\\n _('You must link %s with a VAT registry!') % (inv.journal_id.name))\\n if not inv.journal_id.sequence_id:\\n raise orm.except_orm(_('Error!'),\\n _('Please define sequence on the journal related to this invoice.')) \\n if not inv.invoice_line:\\n raise orm.except_orm(_('No Invoice Lines!'),\\n _('Please create some invoice lines.'))\\n if inv.move_id:\\n continue\\n\\n ctx = context.copy()\\n ctx.update({'lang': inv.partner_id.lang})\\n if not inv.date_invoice:\\n self.write(cr, uid, [inv.id],\\n {'date_invoice': fields.date.context_today(self,\\n cr,\\n uid,\\n context=context)},\\n context=ctx)\\n company_currency = self.pool['res.company'].browse(cr, uid,\\n inv.company_id.id).currency_id.id\\n # create the analytical lines\\n # one move line per invoice line\\n # iml = self._get_analytic_lines(cr, uid, inv.id, context=ctx)\\n iml = super(account_invoice_makeover, self)._get_analytic_lines(cr, uid, inv.id, context=ctx)\\n # check if taxes are all computed\\n compute_taxes = ait_obj.compute(cr, uid, inv.id, context=ctx)\\n # self.check_tax_lines(cr, uid, inv, compute_taxes, ait_obj)\\n super(account_invoice_makeover, self).check_tax_lines(cr, uid, inv, compute_taxes, ait_obj)\\n\\n # I disabled the check_total feature\\n group_check_total_id = self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account', 'group_supplier_inv_check_total')[1]\\n group_check_total = self.pool.get('res.groups').browse(cr, uid,\\n group_check_total_id,\\n context=context)\\n if group_check_total and uid in [x.id for x in group_check_total.users]:\\n if (inv.type in ('in_invoice', 'in_refund') and abs(inv.check_total - inv.amount_total) >= (inv.currency_id.rounding / 2.0)):\\n raise orm.except_orm(_('Bad Total!'), _('Please verify the price of the invoice!\\\\nThe encoded total does not match the computed total.'))\\n\\n if inv.payment_term:\\n total_fixed = total_percent = 0\\n for line in inv.payment_term.line_ids:\\n if line.value == 'fixed':\\n total_fixed += line.value_amount\\n if line.value == 'procent':\\n total_percent += line.value_amount\\n total_fixed = (total_fixed * 100) / (inv.amount_total or 1.0)\\n if (total_fixed + total_percent) > 100:\\n raise orm.except_orm(_('Error!'), _(\\\"Cannot create the invoice.\\\\nThe related payment term is probably misconfigured as it gives a computed amount greater than the total invoiced amount. In order to avoid rounding issues, the latest line of your payment term must be of type 'balance'.\\\"))\\n\\n # one move line per tax line\\n iml += ait_obj.move_line_get(cr, uid, inv.id)\\n\\n# entry_type = ''\\n if inv.type in ('in_invoice', 'in_refund'):\\n ref = inv.reference\\n# entry_type = 'journal_pur_voucher'\\n# if inv.type == 'in_refund':\\n# entry_type = 'cont_voucher'\\n else:\\n # ref = self._convert_ref(cr, uid, inv.number)\\n ref = super(account_invoice_makeover, self)._convert_ref(cr, uid, inv.number)\\n# entry_type = 'journal_sale_vou'\\n# if inv.type == 'out_refund':\\n# entry_type = 'cont_voucher'\\n\\n diff_currency_p = inv.currency_id.id <> company_currency\\n # create one move line for the total and possibly adjust the other lines amount\\n total = 0\\n total_currency = 0\\n # total, total_currency, iml = self.compute_invoice_totals(cr, uid, inv, company_currency, ref, iml, context=ctx)\\n total, total_currency, iml = super(account_invoice_makeover, self).compute_invoice_totals(cr, uid, inv, company_currency, ref, iml, context=ctx)\\n acc_id = inv.account_id.id\\n\\n name = inv['name'] or inv['supplier_invoice_number'] or '/'\\n totlines = False\\n if inv.payment_term:\\n totlines = payment_term_obj.compute(cr,\\n uid, inv.payment_term.id, total, inv.date_invoice or False, context=ctx)\\n if totlines:\\n res_amount_currency = total_currency\\n i = 0\\n ctx.update({'date': inv.date_invoice})\\n for t_line in totlines:\\n if inv.currency_id.id != company_currency:\\n amount_currency = cur_obj.compute(cr, uid, company_currency, inv.currency_id.id, t_line[1], context=ctx)\\n else:\\n amount_currency = False\\n\\n # last line add the diff\\n res_amount_currency -= amount_currency or 0\\n i += 1\\n if i == len(totlines):\\n amount_currency += res_amount_currency\\n\\n iml.append({\\n 'type': 'dest',\\n 'name': name,\\n 'price': t_line[1],\\n 'account_id': acc_id,\\n 'date_maturity': t_line[0],\\n 'amount_currency': diff_currency_p \\\\\\n and amount_currency or False,\\n 'currency_id': diff_currency_p \\\\\\n and inv.currency_id.id or False,\\n 'ref': ref,\\n 'payment_type': t_line[2]\\n })\\n else:\\n iml.append({\\n 'type': 'dest',\\n 'name': name,\\n 'price': total,\\n 'account_id': acc_id,\\n 'date_maturity': inv.date_due or False,\\n 'amount_currency': diff_currency_p \\\\\\n and total_currency or False,\\n 'currency_id': diff_currency_p \\\\\\n and inv.currency_id.id or False,\\n 'ref': ref,\\n 'payment_type': None\\n })\\n\\n date = inv.date_invoice or time.strftime('%Y-%m-%d')\\n\\n part = self.pool.get(\\\"res.partner\\\")._find_accounting_partner(inv.partner_id)\\n\\n line = map(lambda x:(0, 0, self.line_get_convert(cr, uid, x, part.id, date, context=ctx)), iml)\\n\\n # line = self.group_lines(cr, uid, iml, line, inv)\\n line = super(account_invoice_makeover, self).group_lines(cr, uid, iml, line, inv)\\n\\n journal_id = inv.journal_id.id\\n journal = journal_obj.browse(cr, uid, journal_id, context=ctx)\\n if journal.centralisation:\\n raise orm.except_orm(_('User Error!'),\\n _('You cannot create an invoice on a centralized journal. Uncheck the centralized counterpart box in the related journal from the configuration menu.'))\\n\\n line = self.finalize_invoice_move_lines(cr, uid, inv, line)\\n\\n move = {\\n 'ref': inv.reference and inv.reference or inv.name,\\n 'line_id': line,\\n 'journal_id': journal_id,\\n 'date': date,\\n 'narration': inv.comment,\\n 'company_id': inv.company_id.id,\\n }\\n period_id = inv.period_id and inv.period_id.id or False\\n ctx.update(company_id=inv.company_id.id,\\n account_period_prefer_normal=True)\\n if not period_id:\\n period_ids = period_obj.find(cr, uid, inv.registration_date, context=ctx)\\n period_id = period_ids and period_ids[0] or False\\n if period_id:\\n move['period_id'] = period_id\\n for i in line:\\n i[2]['period_id'] = period_id\\n\\n ctx.update(invoice=inv)\\n move_id = move_obj.create(cr, uid, move, context=ctx)\\n new_move_name = move_obj.browse(cr, uid, move_id, context=ctx).name\\n # make the invoice point to that move\\n self.write(cr, uid, [inv.id], {'move_id': move_id, 'period_id':period_id, 'move_name':new_move_name}, context=ctx)\\n # Pass invoice in context in method post: used if you want to get the same\\n # account move reference when creating the same invoice after a cancelled one:\\n move_obj.post(cr, uid, [move_id], context=ctx)\\n # self._log_event(cr, uid, ids)\\n super(account_invoice_makeover, self)._log_event(cr, uid, ids)\\n return True\",\n \"def _create_invoice(self):\\n self.ensure_one()\\n partner = self.member_id.partner_id\\n invoice = self.env['account.invoice'].create({\\n 'partner_id': partner.id,\\n 'account_id': partner.property_account_receivable_id.id,\\n 'fiscal_position_id': partner.property_account_position_id.id\\n })\\n for line in self.line_ids:\\n product = line.activity_id.product_id\\n # Handling of invoice lines : needs cache record for onchange, then\\n # real writing...\\n invoice_line = self.env['account.invoice.line'].new({\\n 'product_id': product.id,\\n 'invoice_id': invoice.id\\n })\\n invoice_line._onchange_product_id()\\n line_values = dict(invoice_line._cache)\\n line_values['price_unit'] = line.price\\n invoice_line = self.env['account.invoice.line'].create(line_values)\\n invoice.compute_taxes()\\n line.registration_id.invoice_line_id = invoice_line.id\\n return invoice\",\n \"def action_invoice_create(self, cr, uid, ids, context=None):\\n res = False\\n\\n journal_obj = self.pool.get('account.journal')\\n inv_obj = self.pool.get('account.invoice')\\n inv_line_obj = self.pool.get('account.invoice.line')\\n fiscal_obj = self.pool.get('account.fiscal.position')\\n property_obj = self.pool.get('ir.property')\\n\\n for order in self.browse(cr, uid, ids, context=context):\\n pay_acc_id = order.partner_id.property_account_payable.id\\n journal_ids = journal_obj.search(cr, uid, [('type', '=','purchase'),('company_id', '=', order.company_id.id)], limit=1)\\n if not journal_ids:\\n raise osv.except_osv(_('Error !'),\\n _('There is no purchase journal defined for this company: \\\"%s\\\" (id:%d)') % (order.company_id.name, order.company_id.id))\\n\\n # generate invoice line correspond to PO line and link that to created invoice (inv_id) and PO line\\n inv_lines = []\\n for po_line in order.order_line:\\n if po_line.product_id:\\n acc_id = po_line.product_id.product_tmpl_id.property_account_expense.id\\n if not acc_id:\\n acc_id = po_line.product_id.categ_id.property_account_expense_categ.id\\n if not acc_id:\\n raise osv.except_osv(_('Error !'), _('There is no expense account defined for this product: \\\"%s\\\" (id:%d)') % (po_line.product_id.name, po_line.product_id.id,))\\n else:\\n acc_id = property_obj.get(cr, uid, 'property_account_expense_categ', 'product.category').id\\n fpos = order.fiscal_position or False\\n acc_id = fiscal_obj.map_account(cr, uid, fpos, acc_id)\\n\\n inv_line_data = self._prepare_inv_line(cr, uid, acc_id, po_line, context=context)\\n inv_line_id = inv_line_obj.create(cr, uid, inv_line_data, context=context)\\n inv_lines.append(inv_line_id)\\n\\n po_line.write({'invoiced':True, 'invoice_lines': [(4, inv_line_id)]}, context=context)\\n\\n # get invoice data and create invoice\\n inv_data = {\\n 'name': order.partner_ref or order.name,\\n 'reference': order.partner_ref or order.name,\\n 'account_id': pay_acc_id,\\n 'type': 'in_invoice',\\n 'partner_id': order.partner_id.id,\\n 'currency_id': order.pricelist_id.currency_id.id,\\n 'address_invoice_id': order.partner_address_id.id,\\n 'address_contact_id': order.partner_address_id.id,\\n 'journal_id': len(journal_ids) and journal_ids[0] or False,\\n 'invoice_line': [(6, 0, inv_lines)], \\n 'origin': order.name,\\n 'fiscal_position': order.fiscal_position.id or order.partner_id.property_account_position.id,\\n 'payment_term': order.partner_id.property_payment_term and order.partner_id.property_payment_term.id or False,\\n 'company_id': order.company_id.id,\\n 'add_disc': order.add_disc or 0.0\\n }\\n inv_id = inv_obj.create(cr, uid, inv_data, context=context)\\n\\n # compute the invoice\\n inv_obj.button_compute(cr, uid, [inv_id], context=context, set_total=True)\\n\\n # Link this new invoice to related purchase order\\n order.write({'invoice_ids': [(4, inv_id)]}, context=context)\\n res = inv_id\\n return res\",\n \"def action_move_create(self):\\n\\t\\taccount_move = self.env['account.move']\\n\\n\\t\\tfor inv in self:\\n\\t\\t\\tif not inv.journal_id.sequence_id:\\n\\t\\t\\t\\traise UserError(_('Please define sequence on the journal related to this invoice.'))\\n\\t\\t\\tif not inv.invoice_line_ids.filtered(lambda line: line.account_id):\\n\\t\\t\\t\\traise UserError(_('Please add at least one invoice line.'))\\n\\t\\t\\tif inv.move_id:\\n\\t\\t\\t\\tcontinue\\n\\n\\n\\t\\t\\tif not inv.date_invoice:\\n\\t\\t\\t\\tinv.write({'date_invoice': fields.Date.context_today(self)})\\n\\t\\t\\tif not inv.date_due:\\n\\t\\t\\t\\tinv.write({'date_due': inv.date_invoice})\\n\\t\\t\\tcompany_currency = inv.company_id.currency_id\\n\\n\\t\\t\\t# create move lines (one per invoice line + eventual taxes and analytic lines)\\n\\t\\t\\timl = inv.invoice_line_move_line_get()\\n\\t\\t\\timl += inv.tax_line_move_line_get()\\n\\n\\t\\t\\tdiff_currency = inv.currency_id != company_currency\\n\\t\\t\\t# create one move line for the total and possibly adjust the other lines amount\\n\\t\\t\\ttotal, total_currency, iml = inv.compute_invoice_totals(company_currency, iml)\\n\\n\\t\\t\\tname = inv.name or ''\\n\\t\\t\\tif inv.payment_term_id:\\n\\t\\t\\t\\ttotlines = inv.payment_term_id.with_context(currency_id=company_currency.id).compute(total, inv.date_invoice)[0]\\n\\t\\t\\t\\tres_amount_currency = total_currency\\n\\t\\t\\t\\tfor i, t in enumerate(totlines):\\n\\t\\t\\t\\t\\tif inv.currency_id != company_currency:\\n\\t\\t\\t\\t\\t\\tamount_currency = company_currency._convert(t[1], inv.currency_id, inv.company_id, inv._get_currency_rate_date() or fields.Date.today())\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tamount_currency = False\\n\\n\\t\\t\\t\\t\\t# last line: add the diff\\n\\t\\t\\t\\t\\tres_amount_currency -= amount_currency or 0\\n\\t\\t\\t\\t\\tif i + 1 == len(totlines):\\n\\t\\t\\t\\t\\t\\tamount_currency += res_amount_currency\\n\\n\\t\\t\\t\\t\\t_logger.info(inv)\\n\\t\\t\\t\\t\\timl.append({\\n\\t\\t\\t\\t\\t\\t'type': 'dest',\\n\\t\\t\\t\\t\\t\\t'name': name,\\n\\t\\t\\t\\t\\t\\t'price': t[1],\\n\\t\\t\\t\\t\\t\\t'account_id': inv.account_id.id,\\n\\t\\t\\t\\t\\t\\t'date_maturity': t[0],\\n\\t\\t\\t\\t\\t\\t'amount_currency': diff_currency and amount_currency,\\n\\t\\t\\t\\t\\t\\t'currency_id': diff_currency and inv.currency_id.id,\\n\\t\\t\\t\\t\\t\\t'invoice_id': inv.id,\\n\\t\\t\\t\\t\\t\\t#'partner_id': inv.partner_line_id.id\\n\\t\\t\\t\\t\\t})\\n\\t\\t\\telse:\\n\\t\\t\\t\\t_logger.info(inv)\\n\\t\\t\\t\\ttotal_taxes_to_pay = self.return_tax_to_payy()\\n\\n\\t\\t\\t\\tif inv.taxes_collected_id.type_taxes == 'tax_company':\\n\\t\\t\\t\\t\\timl.append({\\n\\t\\t\\t\\t\\t'type': 'dest',\\n\\t\\t\\t\\t\\t'name': name,\\n\\t\\t\\t\\t\\t'price': total_taxes_to_pay,\\n\\t\\t\\t\\t\\t'account_id': inv.taxes_collected_id.account_id.id,\\n\\t\\t\\t\\t\\t'date_maturity': inv.date_due,\\n\\t\\t\\t\\t\\t'amount_currency': diff_currency and total_currency,\\n\\t\\t\\t\\t\\t'currency_id': diff_currency and inv.currency_id.id,\\n\\t\\t\\t\\t\\t'invoice_id': inv.id,\\n\\t\\t\\t\\t\\t#'partner_id': inv.partner_line_id.id\\n\\t\\t\\t\\t\\t})\\n\\t\\t\\t\\t\\timl.append({\\n\\t\\t\\t\\t\\t'type': 'dest',\\n\\t\\t\\t\\t\\t'name': name,\\n\\t\\t\\t\\t\\t'price': total- total_taxes_to_pay,\\n\\t\\t\\t\\t\\t'account_id': inv.account_id.id,\\n\\t\\t\\t\\t\\t'date_maturity': inv.date_due,\\n\\t\\t\\t\\t\\t'amount_currency': diff_currency and total_currency,\\n\\t\\t\\t\\t\\t'currency_id': diff_currency and inv.currency_id.id,\\n\\t\\t\\t\\t\\t'invoice_id': inv.id,\\n\\t\\t\\t\\t\\t#'partner_id': inv.partner_line_id.id\\n\\t\\t\\t\\t\\t})\\n\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\timl.append({\\n\\t\\t\\t\\t\\t'type': 'dest',\\n\\t\\t\\t\\t\\t'name': name,\\n\\t\\t\\t\\t\\t'price': total,\\n\\t\\t\\t\\t\\t'account_id': inv.account_id.id,\\n\\t\\t\\t\\t\\t'date_maturity': inv.date_due,\\n\\t\\t\\t\\t\\t'amount_currency': diff_currency and total_currency,\\n\\t\\t\\t\\t\\t'currency_id': diff_currency and inv.currency_id.id,\\n\\t\\t\\t\\t\\t'invoice_id': inv.id,\\n\\t\\t\\t\\t\\t#'partner_id': inv.partner_line_id.id\\n\\t\\t\\t\\t})\\n\\n\\t\\t\\tpart = self.env['res.partner']._find_accounting_partner(inv.partner_id)\\n\\n\\t\\t\\t#validamo que sea una factura de proveedor\\n\\t\\t\\tif self.type == 'in_invoice':\\n\\t\\t\\t\\tdata_new = []\\n\\t\\t\\t\\tfor l in iml:\\n\\t\\t\\t\\t\\tif 'partner_id' in l:\\n\\t\\t\\t\\t\\t\\tif l['partner_id']:\\n\\t\\t\\t\\t\\t\\t\\tdata_new.append((0, 0, self.line_get_convert(l, l['partner_id'])) )\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdata_new.append((0, 0, self.line_get_convert(l, part.id)) )\\n\\n\\t\\t\\t\\tline = [l for l in data_new ]\\n\\t\\t\\telse:\\n\\t\\t\\t\\tline = [(0, 0, self.line_get_convert(l, part.id)) for l in iml ]\\n\\n\\t\\t\\tline = inv.group_lines(iml, line)\\n\\n\\t\\t\\tline = inv.finalize_invoice_move_lines(line)\\n\\n\\t\\t\\tdate = inv.date or inv.date_invoice\\n\\t\\t\\tmove_vals = {\\n\\t\\t\\t\\t'ref': inv.reference,\\n\\t\\t\\t\\t'line_ids': line,\\n\\t\\t\\t\\t'journal_id': inv.journal_id.id,\\n\\t\\t\\t\\t'date': date,\\n\\t\\t\\t\\t'narration': inv.comment,\\n\\t\\t\\t}\\n\\n\\t\\t\\tmove = account_move.create(move_vals)\\n\\t\\t\\t# Pass invoice in method post: used if you want to get the same\\n\\t\\t\\t# account move reference when creating the same invoice after a cancelled one:\\n\\t\\t\\tmove.post(invoice = inv)\\n\\t\\t\\t# make the invoice point to that move\\n\\t\\t\\tvals = {\\n\\t\\t\\t\\t'move_id': move.id,\\n\\t\\t\\t\\t'date': date,\\n\\t\\t\\t\\t'move_name': move.name,\\n\\t\\t\\t}\\n\\t\\t\\tinv.write(vals)\\n\\t\\treturn True\",\n \"def compute_counterpart_lines(self):\\n for item in self:\\n move_debit_lines = []\\n move_credit_lines = []\\n\\n # list of all the move lines of the payment's move\\n line_list = []\\n for entry in item.journal_entry_ids:\\n for line in entry.line_ids:\\n if line.account_id.treasury_planning:\\n line_list.append(line)\\n\\n # for each line above collect all the reconciled counterpart lines\\n for line in line_list:\\n if line.credit > 0 and line.debit == 0:\\n for match in line.matched_debit_ids:\\n move_debit_lines.append(match.debit_move_id.id)\\n\\n if line.credit == 0 and line.debit > 0:\\n for match in line.matched_credit_ids:\\n move_credit_lines.append(match.credit_move_id.id)\\n\\n if move_credit_lines:\\n counterpart_move_ids = move_credit_lines\\n else:\\n counterpart_move_ids = move_debit_lines\\n\\n # bank move share is transformed to dictionary\\n bank_move_dict = (ast.literal_eval(item.cf_share) if\\n item.cf_share else {})\\n\\n # the share of each counterpart line is \\\"merged or added\\\"\\n # in a weighted manner to the bank line share\\n for cpt in counterpart_move_ids:\\n dest_move_line = self.env['account.move.line'].browse(cpt)\\n weight = round(dest_move_line.balance / item.amount, 2)\\n # counterpart share is transformed into dictionary\\n move_line_dict = ast.literal_eval(dest_move_line.cf_share)\\n\\n # each key is finally added to the bank line share\\n for key, value in move_line_dict.iteritems():\\n draft_dictionary = dictop.sum_dictionary(\\n bank_move_dict.get(key, {}), 1,\\n move_line_dict.get(key, {}), weight)\\n bank_move_dict[key] = dictop.check_dict_total(\\n draft_dictionary, 1)\\n\\n # the dictionary is transformed into string and assigned\\n item.cf_share = json.dumps(bank_move_dict)\",\n \"def compute_advice(self):\\n for advice in self:\\n old_lines = self.env['hr.payroll.advice.line'].search([('advice_id', '=', advice.id)])\\n if old_lines:\\n old_lines.unlink()\\n payslips = self.env['hr.payslip'].search([('date_from', '<=', advice.date), ('date_to', '>=', advice.date), ('state', '=', 'done')])\\n for slip in payslips:\\n if not slip.sudo().employee_id.bank_account_id and not slip.sudo().employee_id.bank_account_id.acc_number:\\n raise UserError(_('Please define bank account for the %s employee') % (slip.employee_id.name,))\\n payslip_line = self.env['hr.payslip.line'].search([('slip_id', '=', slip.id), ('code', '=', 'NET')], limit=1)\\n if payslip_line:\\n self.env['hr.payroll.advice.line'].create({\\n 'advice_id': advice.id,\\n 'name': slip.sudo().employee_id.bank_account_id.acc_number,\\n 'ifsc_code': slip.sudo().employee_id.bank_account_id.bank_bic or '',\\n 'employee_id': slip.employee_id.id,\\n 'bysal': payslip_line.total\\n })\\n slip.advice_id = advice.id\",\n \"def abc_confirm_invoice(self, lines, packages, data, params, res):\\n invoice = params.get('invoice')\\n if invoice and invoice.state == 'draft':\\n self.env.cr.commit()\\n env = None\\n try:\\n # Ne cursor doesn't time out when requesting lock.\\n # Could be bad I guess? Works for now.\\n # TODO: Look into setting a more reasonable lock wait time.\\n new_cr = Registry(self.env.cr.dbname).cursor()\\n new_cr.autocommit(True)\\n env = api.Environment(new_cr, self.env.uid, self.env.context)\\n # Validate invoice\\n invoice.signal_workflow('invoice_open')\\n res['invoice']['name'] = invoice.number\\n res['messages'].append(u\\\"Created and confirmed invoice %s.\\\" % invoice.number)\\n res['results']['invoice'] = 'confirmed'\\n # Commit to unlock the invoice sequence\\n env.cr.commit()\\n except Exception as e:\\n res['warnings'].append((\\n _(u\\\"Failed to confirm invoice %s!\\\") % (invoice and (invoice.number or invoice.name) or 'Unknown'),\\n '%s\\\\n\\\\nTraceback:\\\\n%s' % (e.message or 'Unknown Error', traceback.format_exc())))\\n finally:\\n if env:\\n env.cr.close()\",\n \"def process_b2c_amazon_order_ept(self, row, sale_order, invoice_date):\\n invoice_number = row.get('VAT Invoice Number', False)\\n invoice_url = row.get('Invoice Url', '')\\n\\n invoices = sale_order.invoice_ids.filtered(\\n lambda x: x.type == 'out_invoice' and x.state != 'cancel')\\n if not invoices:\\n lines = sale_order.order_line.filtered(lambda line: line.qty_to_invoice > 0)\\n if not lines:\\n return False\\n invoices = sale_order.with_context({'vcs_invoice_number': invoice_number})._create_invoices()\\n self.write({'invoice_ids': [(4, invoices and invoices.id)]})\\n\\n for invoice in invoices:\\n invoice_vals = {}\\n invoice_vals.update({'date': invoice_date, 'invoice_url': invoice_url})\\n if invoice.state == 'draft' and \\\\\\n sale_order.amz_seller_id.is_invoice_number_same_as_vcs_report:\\n invoice_vals.update({'name': invoice_number})\\n invoice.write(invoice_vals)\\n return True\",\n \"def generate_orders(self, cr, uid, ids, context=None):\\n voucher_pool = self.pool.get('account.voucher')\\n payment_term_obj = self.pool.get('account.payment.term')\\n account_budget_confirmation_obj = self.pool.get('account.budget.confirmation')\\n period_obj = self.pool.get('account.period')\\n if context is None:\\n context = {}\\n for order in self.browse(cr, uid, ids, context=context):\\n #################################to remind\\n total_fixed = total_percent = 0\\n for line in order.payment_term.line_ids:\\n if line.value == 'fixed':\\n total_fixed += line.value_amount\\n if line.value == 'procent':\\n total_percent += line.value_amount\\n total_fixed = (total_fixed * 100) / (order.amount or 1.0)\\n if (total_fixed + total_percent) > 100:\\n raise orm.except_orm(_('Error!'), _(\\\"Can not create the payments !\\\\n\\\\\\n The related payment term is probably miss configured as it gives a computed amount greater than the total permanent payment amount. \\\\\\n The latest line of your payment term must be of type 'balance' to avoid rounding issues.\\\"))\\n # create one move line for the total and possibly adjust the other lines amount\\n totlines1 = []\\n for o in order.line_ids:\\n totlines1 += payment_term_obj.compute(cr, uid, order.payment_term.id, o.amount, order.date or False, context=context)\\n \\n d = {}\\n for k, v in totlines1:\\n d.setdefault(k, [k]).append(v)\\n totlines = map(tuple, d.values())\\n\\n for t in totlines :\\n #to substract date from the interval number \\n order_date = t[0]\\n entered_date = datetime.datetime.strptime(order_date, '%Y-%m-%d')\\n entered_date = entered_date.date()\\n account_id = (order.partner_id.property_account_payable and order.partner_id.property_account_payable.id) or \\\\\\n (order.journal_id.default_credit_account_id and order.journal_id.default_credit_account_id.id)\\n period_id = period_obj.find(cr, uid, t[0], context=context)[0]\\n\\n list_confirm = [conf.id for conf in o.confirmation_ids]\\n confirmations = account_budget_confirmation_obj.search(cr, uid, [('id','in', list_confirm),('period_id','=', period_id)], context=context) #('date','=',t[0]),\\n\\n for confirm in confirmations:\\n confirm_id = confirm\\n\\n voucher_lines = [(0, 0, {'name':ol.name, 'account_id':ol.account_id.id, 'type':'dr',\\n 'amount':t[count + 1], 'account_analytic_id':ol.account_analytic_id.id, 'budget_confirm_id': confirm_id })\\n for count, ol in enumerate(order.line_ids)]\\n res = voucher_pool.onchange_price(cr, uid, 0, voucher_lines, [], partner_id=order.partner_id.id, context=context).get(\\\"value\\\", {})\\n voucher_dict = {\\n 'partner_id' : order.partner_id.id,\\n 'account_id': account_id,\\n 'company_id' : order.company_id.id,\\n 'journal_id' : order.journal_id.id,\\n 'period_id': order.period_id.id,\\n 'type':'purchase',\\n 'date' : t[0],\\n 'reference': order.name,\\n 'payment_permanent_voucher_id': order.id,\\n 'line_ids':voucher_lines,\\n 'amount':res.get(\\\"amount\\\", 0.0)\\n }\\n voucher_pool.create(cr, uid, voucher_dict, context=context)\\n return self.write(cr, uid, ids, {'state':'done'}, context=context)\",\n \"def action_create_invoice(self):\\n if self.partner_id:\\n supplier = self.partner_id\\n else:\\n supplier = self.partner_id.search(\\n [(\\\"name\\\", \\\"=\\\", \\\"Salon Default Customer\\\")])\\n lines = []\\n product_id = self.env['product.product'].search(\\n [(\\\"name\\\", \\\"=\\\", \\\"Salon Service\\\")])\\n for records in self.order_line_ids:\\n if product_id.property_account_income_id.id:\\n income_account = product_id.property_account_income_id.id\\n elif product_id.categ_id.property_account_income_categ_id.id:\\n income_account = product_id.categ_id.\\\\\\n property_account_income_categ_id.id\\n else:\\n raise UserError(\\n _(\\\"Please define income account for this product: \\\"\\n \\\"'%s' (id:%d).\\\") % (product_id.name, product_id.id))\\n value = (0, 0, {\\n 'name': records.service_id.name,\\n 'account_id': income_account,\\n 'price_unit': records.price,\\n 'quantity': 1,\\n 'product_id': product_id.id,\\n })\\n lines.append(value)\\n invoice_line = {\\n 'move_type': 'out_invoice',\\n 'partner_id': supplier.id,\\n 'invoice_user_id': self.env.user.id,\\n 'invoice_origin': self.name,\\n 'invoice_line_ids': lines,\\n }\\n inv = self.env['account.move'].create(invoice_line)\\n action = self.env.ref('account.action_move_out_invoice_type',\\n raise_if_not_found=False)\\n result = {\\n 'name': action.name,\\n 'type': 'ir.actions.act_window',\\n 'views': [[False, 'form']],\\n 'target': 'current',\\n 'res_id': inv.id,\\n 'res_model': 'account.move',\\n }\\n self.inv_stage_identifier = True\\n self.stage_id = 3\\n invoiced_records = self.env['salon.order'].search(\\n [('stage_id', 'in', [3, 4]), ('chair_id', '=', self.chair_id.id)])\\n total = 0\\n for rows in invoiced_records:\\n invoiced_date = str(rows.date)\\n invoiced_date = invoiced_date[0:10]\\n if invoiced_date == str(date.today()):\\n total = total + rows.price_subtotal\\n self.chair_id.collection_today = total\\n self.update_number_of_orders()\\n return result\",\n \"def operation_invoices(self):\\r\\n for operation in self:\\r\\n invoices = self.env['account.invoice'].search([\\r\\n ('freight_hbl', '=', operation.id),\\r\\n ('type', 'in', ['out_invoice', 'out_refund']),\\r\\n ('state', '!=', 'cancel'),\\r\\n ])\\r\\n action = self.env.ref('account.action_invoice_tree1').read()[0]\\r\\n if len(invoices) > 1:\\r\\n action['domain'] = [('id', 'in', invoices.ids)]\\r\\n elif len(invoices) == 1:\\r\\n action['views'] = [(self.env.ref('account.invoice_form').id, 'form')]\\r\\n action['res_id'] = invoices.ids[0]\\r\\n else:\\r\\n action = {'type': 'ir.actions.act_window_close'}\\r\\n return action\",\n \"def create_order_amended_invoice(sender, instance, using, **kwargs):\\n\\n sender_name = sender._meta.model.__name__\\n\\n if sender_name == \\\"WillOrder\\\":\\n order = instance\\n elif sender_name == \\\"Allocation\\\":\\n order = instance.asset_store.order\\n else:\\n order = instance.order\\n\\n if Invoice.objects.filter(\\n order=order, been_paid=True, parent_invoice=None\\n ).exists():\\n amended_invoice_required = False\\n latest_paid_invoice = order.invoice.latest_paid()\\n print(\\\"latest_paid_invoice\\\", latest_paid_invoice)\\n if latest_paid_invoice:\\n order_details = InvoiceService(order).limit_details\\n\\n for order_detail, order_numbers in order_details.items():\\n try:\\n willorder_limit = OrderLimit.objects.get(\\n invoice=latest_paid_invoice, detail=order_detail\\n )\\n if order_numbers > willorder_limit.limit:\\n amended_invoice_required = True\\n except OrderLimit.DoesNotExist:\\n amended_invoice_required = True\\n\\n parent_invoice = Invoice.objects.get(order=order, parent_invoice=None)\\n\\n if amended_invoice_required:\\n if Invoice.objects.filter(\\n order=order, been_paid=False, parent_invoice=parent_invoice\\n ).exists():\\n print(\\\"UPDATE AMENDED INVOICE\\\")\\n order.invoice.latest().update_invoice()\\n else:\\n Invoice.objects.create(\\n order=order, parent_invoice=parent_invoice)\\n else:\\n print(\\\"DELETE AMENDED INVOICE\\\")\\n if Invoice.objects.filter(\\n order=order, been_paid=False, parent_invoice=parent_invoice\\n ).exists():\\n Invoice.objects.get(\\n order=order, parent_invoice=parent_invoice, been_paid=False\\n ).delete()\",\n \"def test_merge_ok_draft_with_draft(self):\\n p1 = PathFactory.create(name=\\\"PATH_AB\\\", geom=LineString((0, 1), (10, 1)), draft=True)\\n p2 = PathFactory.create(name=\\\"PATH_CD\\\", geom=LineString((10, 1), (20, 1)), draft=True)\\n response = self.client.post(reverse('core:path-drf-merge-path'), {'path[]': [p1.pk, p2.pk]})\\n self.assertIn('success', response.json())\",\n \"def exchange_payment(self, cr, uid, ids, context=None):\\n data = self.browse(cr, uid, ids, context=context)[0]\\n check_log_pool = self.pool.get('check.log')\\n sequence_pool = self.pool.get('ir.sequence')\\n move_pool = self.pool.get('account.move') \\n move_line_pool = self.pool.get('account.move.line')\\n\\n voucher_obj = self.pool.get('account.voucher')\\n old_voucher_ids = voucher_obj.search(cr, uid, [('move_id', '=', context['active_id'])], context=context)\\n old_chk_log_ids = check_log_pool.search(cr,uid,[('name','in',old_voucher_ids),('status','=','active')], context=context)\\n '''if chk_log_ids:\\n check_log_pool.write(cr, uid, chk_log_ids, {'status':'delete','deleted':True},context=context)'''\\n if old_chk_log_ids:\\n raise osv.except_osv(_('Warning'), _('This move have already exchanged'))\\n voucher_id = self.check_move_data(cr, uid, ids, context=context)\\n if not voucher_id:\\n raise osv.except_osv(_('Warning'), _('The account in credit lines must be of type liquidity'))\\n if data.new_no and voucher_id:\\n move = move_pool.browse(cr, uid, context['active_id'], context=context)\\n journal_id=move and move.journal_id\\n if self._exchange_journal_seq(journal_id, context=context):\\n chk_log_ids = check_log_pool.search(cr,uid,[('status','=','active')], context=context)\\n sequence_pool.write(cr, uid, [journal_id.check_sequence.id], {'number_next_actual':data.new_no}, context=context)\\n next_seq = sequence_pool.get_id(cr, uid, journal_id.check_sequence.id, context=context)\\n lines = move_line_pool.search(cr, uid,[('move_id','=',context['active_id'])], context=context)\\n line = move_line_pool.browse(cr, uid, lines, context=context)[0]\\n check_log_pool.create(cr, uid,{'name': voucher_id, 'status': 'active', 'check_no': next_seq, 'journal_id':journal_id.id,'company_id':move.company_id.id}, context=context)\\n #check_log_pool.create(cr, uid,{'partner_id':line.partner_id.id,'date_due':move.date,'status': 'active', 'check_no': next_seq, 'journal_id':journal_id.id,'company_id':move.company_id.id}, context=context)\\n move_pool.write(cr, uid,[context['active_id']], {'ref' : next_seq or ' '}, context=context)\\n move_line_pool.write(cr, uid,lines, {'ref' : next_seq or ' '}, context=context)\\n return {'type':'ir.actions.act_window_close'}\",\n \"def return_fnc(self, cr, uid, ids, context=None):\\n\\n wf_service = netsvc.LocalService(\\\"workflow\\\")\\n for rec in self.browse(cr, uid, ids, context=context):\\n lines = []\\n if rec.state == 'recieved':\\n for line in rec.spares_ids:\\n if line.recieved_quantity != 0:\\n \\n lines_dict = {\\n 'name': line.product_id.name[:250],\\n #'picking_id': picking_id,\\n 'product_id': line.product_id.id,\\n 'product_qty': line.recieved_quantity,\\n 'product_uom': line.product_id.uom_id.id,\\n 'product_uos_qty':line.recieved_quantity,\\n 'product_uos': line.product_id.uom_id.id,\\n 'location_id': rec.damage_line_id.department_id.location_dest_id.id ,\\n 'location_dest_id': rec.damage_line_id.department_id.stock_location_id.id,\\n #'exchange_line_id': line.id,\\n 'tracking_id': False,\\n 'state': 'draft',\\n 'note': '',\\n 'price_unit': line.product_id.standard_price or 0.0,\\n 'move_type': 'one',\\n } \\n \\n lines.append([0, False, lines_dict])\\n\\n if lines:\\n piking_dict = {\\n 'name': '/',\\n #'origin': order.name,\\n #'request': order.id,\\n 'date': time.strftime('%Y-%m-%d'),\\n 'type': 'in',\\n 'state': 'draft',\\n #'exchange_id': order.id,\\n 'job_id': rec.id,\\n 'maintenance': True,\\n 'note': '',\\n 'department_id':rec.damage_line_id.department_id.department_id.id,\\n #'stock_journal_id':order.stock_journal_id and order.stock_journal_id.id,\\n 'invoice_state': 'none',\\n 'move_lines': lines,\\n 'state': 'draft'\\n }\\n new_id = self.pool.get('stock.picking.in').create(cr, uid, piking_dict, context)\\n wf_service.trg_validate(uid, 'stock.picking', new_id, 'button_confirm', cr)\\n self.write(cr, uid, ids, {'state': 'return','picking_id':new_id})\\n continue\\n else:\\n self.write(cr, uid, ids, {'state': 'canceled'})\\n\\n return True\",\n \"def exchange_move_data(self, cr, uid, ids, context=None): \\n move_line_pool = self.pool.get('account.move.line')\\n move = self.pool.get('account.move').browse(cr, uid, context.get('active_id',[]), context=context)\\n move_line = move_line_pool.search(cr, uid, [('move_id','=',context.get('active_id',[]))], context=context)\\n partners = move_line_pool.read(cr, uid, move_line, ['partner_id'], context=context)\\n if len(set([part['partner_id'] for part in partners])) > 1:\\n raise osv.except_osv(_('Warning'), _('Can not create new exchange for multiple partner!!'))\\n return True\",\n \"def _get_lines(self, cr, uid, ids, context=None):\\n List=[]\\n if ids:\\n line = self.pool.get('payment.enrich.lines').browse(cr, uid, ids[0], context=context)\\n \\n record = line.enrich_id\\n val = 0.0\\n for line in record.enrich_lines:\\n if line.state == 'done' :\\n val += line.cost\\n res = {\\n 'paid_amount':val,\\n 'residual_amount':record.amount - val,\\n }\\n record.write(res)\\n return List\",\n \"def done(self, cr, uid, ids, context=None):\\n budget_line = self.pool.get('account.budget.lines')\\n budget_line_id = False \\n for r in self.browse(cr, uid, ids, context=context):\\n to = {'analytic_account': r.analytic_account_id.id,\\n 'account_id': r.account_id.id,\\n 'period_id': r.period_id.id,\\n 'company': r.company_id.id,\\n 'amount' : r.amount\\n }\\n \\n budget_line_id ,history_ids=budget_line.transfer(cr, uid, {'type':r.type, 'budget_type':r.budget_type, 'line_ids': r.line_ids, 'to':to, 'reference':self._name+','+str(r.id)}, context=context)\\n return self.write(cr, uid, ids,{'state':'done', 'budget_line':budget_line_id}, context=context)\",\n \"def get_invoice(self):\\n\\n # Check if unclosed invoice for the client exists\\n old_inv = connection.Kinko.find_one({'cl': self.cl, 'tid': None,\\n 'typ': TYPE_MAP[self.tab_type]})\\n\\n inv_num = None\\n # If it does, update its values and update packages\\n if old_inv:\\n old_inv.dt = datetime.datetime.today()\\n old_inv.range.lt = self.q_dict[\\\"cs.sd\\\"].get(\\\"$lt\\\", None)\\n old_inv.save()\\n\\n inv_num = old_inv.num\\n\\n else:\\n #kinko dict to be updated in Kinko Collection.\\n kdict = {\\n \\\"amt\\\": 0.0,\\n \\\"cl\\\": unicode(self.cl),\\n \\\"dt\\\": datetime.datetime.today(),\\n \\\"typ\\\": TYPE_MAP[self.tab_type],\\n \\\"range\\\": {\\\"lt\\\": self.q_dict[\\\"cs.sd\\\"].get(\\\"$lt\\\", None),\\n \\\"gt\\\": self.q_dict[\\\"cs.sd\\\"].get(\\\"$gte\\\", None),\\n }\\n }\\n\\n k = Kinko(kdict)\\n\\n k_count = 1\\n\\n #the get num method of Kinko model generates the unique no for new kinko\\n k[\\\"num\\\"] = self.get_knum(1)\\n while connection.Kinko.collection.find({\\\"num\\\": k.num}).count() > 0:\\n k[\\\"num\\\"] = self.get_knum(k_count+1)\\n k_count += k_count\\n\\n connection.Kinko(k).save()\\n\\n inv_num = k['num']\\n\\n if inv_num:\\n #after creating a new document in Kinko all packages are updated.\\n connection.Package.collection.update(self.q_dict, {'$set': {'inv.num': inv_num}}, safe=True, multi=True)\\n \\n #Aggrigation of remitted amount for requested client\\n non_invoiced = kinko_map_reduce(inv_num, TYPE_MAP[self.tab_type])\\n\\n if len(non_invoiced) == 0:\\n return False\\n else:\\n inv = connection.Kinko.find_one({'num': inv_num})\\n if inv:\\n inv.amt = non_invoiced[0]['value']['amt']\\n inv.save()\\n return inv\\n else:\\n return False\\n else:\\n return False\",\n \"def _prepare_invoice(self, cr, uid, order, lines, context=None):\\n invoice_vals = super(my_sale_order, self)._prepare_invoice(cr, uid, order,\\n lines, context)\\n\\n invoice_vals.update({\\n 'partner_shipping_id': order.partner_shipping_id.id,\\n })\\n\\n # Care for deprecated _inv_get() hook - FIXME: to be removed after 6.1\\n invoice_vals.update(self._inv_get(cr, uid, order, context=context))\\n\\n return invoice_vals\",\n \"def _prepare_invoice(self):\\n self.ensure_one()\\n journal_id = self.env['account.invoice'].default_get(['journal_id'])['journal_id']\\n if not journal_id:\\n raise UserError(_('Please define an accounting sales journal for this company.'))\\n invoice_vals = {\\n 'name': self.client_order_ref or '',\\n 'origin': self.name,\\n 'type': 'out_invoice',\\n 'account_id': self.partner_invoice_id.property_account_receivable_id.id,\\n 'partner_id': self.partner_invoice_id.id,\\n 'partner_shipping_id': self.partner_shipping_id.id,\\n 'journal_id': journal_id,\\n 'currency_id': self.pricelist_id.currency_id.id,\\n 'comment': self.note,\\n 'payment_term_id': self.payment_term_id.id,\\n 'fiscal_position_id': self.fiscal_position_id.id or self.partner_invoice_id.property_account_position_id.id,\\n 'company_id': self.company_id.id,\\n 'user_id': self.user_id and self.user_id.id,\\n 'team_id': self.team_id.id,\\n 'x_studio_field_rgEdd': self.x_studio_field_icWOZ.id,\\n 'x_studio_car_type_1': self.vehicle.id,\\n 'x_studio_job_card_1': self.x_studio_agency_job_card,\\n 'x_studio_car_type_name': self.vehicle.model_id.name,\\n 'x_studio_plate_num': self.vehicle.license_plate,\\n 'x_studio_claim_num': self.claim_no,\\n\\n 'x_studio_is_insured':self.is_insured,\\n 'x_studio_service_provider': self.service_advisor.id,\\n 'date_invoice': fields.Date.today(),\\n 'transaction_ids': [(6, 0, self.transaction_ids.ids)],\\n }\\n return invoice_vals\\n\\n # 'x_studio_field_rgEdd':order.x_studio_field_icWOZ.id,\",\n \"def make_invoices(self):\\n for invoice in self.policy.invoices:\\n db.session.delete(invoice)\\n db.session.commit()\\n\\n billing_schedules = {'Annual': None, 'Semi-Annual': 3, 'Quarterly': 4, 'Monthly': 12}\\n\\n invoices = []\\n first_invoice = Invoice(self.policy.id,\\n self.policy.effective_date, # bill_date\\n self.policy.effective_date + relativedelta(months=1), # due\\n self.policy.effective_date + relativedelta(months=1, days=14), # cancel\\n self.policy.annual_premium)\\n invoices.append(first_invoice)\\n\\n if self.policy.billing_schedule == \\\"Annual\\\":\\n pass\\n elif self.policy.billing_schedule == \\\"Two-Pay\\\":\\n first_invoice.amount_due = first_invoice.amount_due / billing_schedules.get(self.policy.billing_schedule)\\n for i in range(1, billing_schedules.get(self.policy.billing_schedule)):\\n months_after_eff_date = i*6\\n bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date)\\n invoice = Invoice(self.policy.id,\\n bill_date,\\n bill_date + relativedelta(months=1),\\n bill_date + relativedelta(months=1, days=14),\\n self.policy.annual_premium / billing_schedules.get(self.policy.billing_schedule))\\n invoices.append(invoice)\\n elif self.policy.billing_schedule == \\\"Quarterly\\\":\\n first_invoice.amount_due = first_invoice.amount_due / billing_schedules.get(self.policy.billing_schedule)\\n for i in range(1, billing_schedules.get(self.policy.billing_schedule)):\\n months_after_eff_date = i*3\\n bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date)\\n invoice = Invoice(self.policy.id,\\n bill_date,\\n bill_date + relativedelta(months=1),\\n bill_date + relativedelta(months=1, days=14),\\n self.policy.annual_premium / billing_schedules.get(self.policy.billing_schedule))\\n invoices.append(invoice)\\n elif self.policy.billing_schedule == \\\"Monthly\\\":\\n first_invoice.amount_due = first_invoice.amount_due / billing_schedules.get(self.policy.billing_schedule)\\n for i in range(1, billing_schedules.get(self.policy.billing_schedule)):\\n months_after_eff_date = i\\n bill_date = self.policy.effective_date + relativedelta(months=months_after_eff_date)\\n invoice = Invoice(self.policy.id,\\n bill_date,\\n bill_date + relativedelta(months=1),\\n bill_date + relativedelta(months=1, days=14),\\n self.policy.annual_premium / billing_schedules.get(self.policy.billing_schedule))\\n invoices.append(invoice)\\n else:\\n print \\\"You have chosen a bad billing schedule.\\\"\\n\\n logger.info(str(len(invoices)) + \\\" invoices generated for policy %s\\\" % self.policy.id)\\n\\n for invoice in invoices:\\n db.session.add(invoice)\\n db.session.commit()\",\n \"def office_merge_process_view(request):\\n # admin, analytics_admin, partner_organization, political_data_manager, political_data_viewer, verified_volunteer\\n authority_required = {'verified_volunteer'}\\n if not voter_has_authority(request, authority_required):\\n return redirect_to_sign_in_page(request, authority_required)\\n\\n contest_office_manager = ContestOfficeManager()\\n\\n is_post = True if request.method == 'POST' else False\\n\\n if is_post:\\n # merge = request.POST.get('merge', False)\\n skip = request.POST.get('skip', False)\\n # Contest office 1 is the one we keep, and Contest office 2 is the one we will merge into Contest office 1\\n contest_office1_we_vote_id = request.POST.get('contest_office1_we_vote_id', 0)\\n contest_office2_we_vote_id = request.POST.get('contest_office2_we_vote_id', 0)\\n google_civic_election_id = request.POST.get('google_civic_election_id', 0)\\n redirect_to_contest_office_list = positive_value_exists(request.POST.get('redirect_to_contest_office_list', False))\\n remove_duplicate_process = positive_value_exists(request.POST.get('remove_duplicate_process', False))\\n state_code = request.POST.get('state_code', '')\\n else:\\n # merge = request.GET.get('merge', False)\\n skip = request.GET.get('skip', False)\\n # Contest office 1 is the one we keep, and Contest office 2 is the one we will merge into Contest office 1\\n contest_office1_we_vote_id = request.GET.get('contest_office1_we_vote_id', 0)\\n contest_office2_we_vote_id = request.GET.get('contest_office2_we_vote_id', 0)\\n google_civic_election_id = request.GET.get('google_civic_election_id', 0)\\n redirect_to_contest_office_list = positive_value_exists(request.GET.get('redirect_to_contest_office_list', False))\\n remove_duplicate_process = positive_value_exists(request.GET.get('remove_duplicate_process', False))\\n state_code = request.GET.get('state_code', '')\\n\\n if positive_value_exists(skip):\\n results = contest_office_manager.update_or_create_contest_offices_are_not_duplicates(\\n contest_office1_we_vote_id, contest_office2_we_vote_id)\\n if not results['new_contest_offices_are_not_duplicates_created']:\\n messages.add_message(request, messages.ERROR, 'Could not save contest_offices_are_not_duplicates entry: ' +\\n results['status'])\\n messages.add_message(request, messages.INFO, 'Prior contest offices skipped, and not merged.')\\n return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n \\\"&state_code=\\\" + str(state_code))\\n\\n contest_office1_results = contest_office_manager.retrieve_contest_office_from_we_vote_id(contest_office1_we_vote_id)\\n if contest_office1_results['contest_office_found']:\\n contest_office1_on_stage = contest_office1_results['contest_office']\\n contest_office1_id = contest_office1_on_stage.id\\n else:\\n messages.add_message(request, messages.ERROR, 'Could not retrieve office 1.')\\n return HttpResponseRedirect(reverse('office:office_list', args=()) +\\n '?google_civic_election_id=' + str(google_civic_election_id) +\\n '&state_code=' + str(state_code))\\n\\n contest_office2_results = contest_office_manager.retrieve_contest_office_from_we_vote_id(contest_office2_we_vote_id)\\n if contest_office2_results['contest_office_found']:\\n contest_office2_on_stage = contest_office2_results['contest_office']\\n contest_office2_id = contest_office2_on_stage.id\\n else:\\n messages.add_message(request, messages.ERROR, 'Could not retrieve contest office 2.')\\n return HttpResponseRedirect(reverse('office:office_list', args=()) +\\n '?google_civic_election_id=' + str(google_civic_election_id) +\\n '&state_code=' + str(state_code))\\n\\n # # TODO: Migrate bookmarks\\n # bookmark_item_list_manager = BookmarkItemList()\\n # bookmark_results = bookmark_item_list_manager.retrieve_bookmark_item_list_for_contest_office(\\n # contest_office2_we_vote_id)\\n # if bookmark_results['bookmark_item_list_found']:\\n # messages.add_message(request, messages.ERROR, \\\"Bookmarks found for Contest Office 2 - \\\"\\n # \\\"automatic merge not working yet.\\\")\\n # return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n # \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n # \\\"&state_code=\\\" + str(state_code))\\n\\n # Merge attribute values\\n conflict_values = figure_out_office_conflict_values(contest_office1_on_stage, contest_office2_on_stage)\\n\\n for attribute in CONTEST_OFFICE_UNIQUE_IDENTIFIERS:\\n conflict_value = conflict_values.get(attribute, None)\\n if conflict_value == \\\"CONFLICT\\\":\\n if is_post:\\n choice = request.POST.get(attribute + '_choice', '')\\n else:\\n choice = request.GET.get(attribute + '_choice', '')\\n if contest_office2_we_vote_id == choice:\\n setattr(contest_office1_on_stage, attribute, getattr(contest_office2_on_stage, attribute))\\n elif conflict_value == \\\"CONTEST_OFFICE2\\\":\\n setattr(contest_office1_on_stage, attribute, getattr(contest_office2_on_stage, attribute))\\n else:\\n pass\\n\\n # Preserve unique google_civic_office_name, _name2, _name3, _name4, and _name5\\n if positive_value_exists(contest_office2_on_stage.google_civic_office_name):\\n contest_office1_on_stage = add_contest_office_name_to_next_spot(\\n contest_office1_on_stage, contest_office2_on_stage.google_civic_office_name)\\n if positive_value_exists(contest_office2_on_stage.google_civic_office_name2):\\n contest_office1_on_stage = add_contest_office_name_to_next_spot(\\n contest_office1_on_stage, contest_office2_on_stage.google_civic_office_name2)\\n if positive_value_exists(contest_office2_on_stage.google_civic_office_name3):\\n contest_office1_on_stage = add_contest_office_name_to_next_spot(\\n contest_office1_on_stage, contest_office2_on_stage.google_civic_office_name3)\\n if positive_value_exists(contest_office2_on_stage.google_civic_office_name4):\\n contest_office1_on_stage = add_contest_office_name_to_next_spot(\\n contest_office1_on_stage, contest_office2_on_stage.google_civic_office_name4)\\n if positive_value_exists(contest_office2_on_stage.google_civic_office_name5):\\n contest_office1_on_stage = add_contest_office_name_to_next_spot(\\n contest_office1_on_stage, contest_office2_on_stage.google_civic_office_name5)\\n\\n # TODO: Merge quick_info's office details in future\\n\\n # Merge ballot item's office details\\n ballot_items_results = move_ballot_items_to_another_office(contest_office2_id, contest_office2_we_vote_id,\\n contest_office1_id, contest_office1_we_vote_id,\\n contest_office1_on_stage)\\n if not ballot_items_results['success']:\\n messages.add_message(request, messages.ERROR, ballot_items_results['status'])\\n return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n \\\"&state_code=\\\" + str(state_code))\\n\\n # Merge public positions - DALE 2020-06-04 I think we will want to alter this soon\\n public_positions_results = move_positions_to_another_office(contest_office2_id, contest_office2_we_vote_id,\\n contest_office1_id, contest_office1_we_vote_id,\\n True)\\n if not public_positions_results['success']:\\n messages.add_message(request, messages.ERROR, public_positions_results['status'])\\n return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n \\\"&state_code=\\\" + str(state_code))\\n\\n # Merge friends-only positions - DALE 2020-06-04 I think we will want to alter this soon\\n friends_positions_results = move_positions_to_another_office(contest_office2_id, contest_office2_we_vote_id,\\n contest_office1_id, contest_office1_we_vote_id,\\n False)\\n if not friends_positions_results['success']:\\n messages.add_message(request, messages.ERROR, friends_positions_results['status'])\\n return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n \\\"&state_code=\\\" + str(state_code))\\n\\n # TODO: Migrate images?\\n\\n # Finally, move candidates last\\n candidates_results = move_candidates_to_another_office(contest_office2_id, contest_office2_we_vote_id,\\n contest_office1_id, contest_office1_we_vote_id)\\n if not candidates_results['success']:\\n messages.add_message(request, messages.ERROR, candidates_results['status'])\\n return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n \\\"&state_code=\\\" + str(state_code))\\n\\n # Save contest_office2_on_stage to remove maplight_id, which much be unique,\\n # before we try to save contest_office1_on_stage below\\n if positive_value_exists(contest_office2_on_stage.maplight_id):\\n contest_office2_on_stage.maplight_id = None\\n contest_office2_on_stage.save()\\n\\n # Note: wait to wrap in try/except block\\n contest_office1_on_stage.save()\\n # There isn't any office data to refresh from other master tables\\n\\n # Remove contest office 2\\n contest_office2_on_stage.delete()\\n\\n if redirect_to_contest_office_list:\\n return HttpResponseRedirect(reverse('office:office_list', args=()) +\\n '?google_civic_election_id=' + str(google_civic_election_id) +\\n '&state_code=' + str(state_code))\\n\\n if remove_duplicate_process:\\n return HttpResponseRedirect(reverse('office:find_and_merge_duplicate_offices', args=()) +\\n \\\"?google_civic_election_id=\\\" + str(google_civic_election_id) +\\n \\\"&state_code=\\\" + str(state_code))\\n\\n return HttpResponseRedirect(reverse('office:office_summary', args=(contest_office1_on_stage.id,)))\",\n \"def make_po(self, cr, uid, ids, context=None):\\n res = super(procurement_order, self).make_po(cr, uid, ids, context=None)\\n for procurement in self.browse(cr, uid, ids, context=context):\\n # da procurement prendo id ordine x ripassare le righe e vedere il listino for\\n pricelist_item = self.pool.get('product.pricelist').price_get(cr, uid, [procurement.purchase_id.pricelist_id.id], procurement.purchase_id.product_id.id, procurement.product_qty or 1.0, procurement.purchase_id.partner_id.id)\\n pricelist_item_id = pricelist_item['item_id'][procurement.purchase_id.pricelist_id.id]\\n price_item = self.pool.get('product.pricelist.item').browse(cr, uid, pricelist_item_id, context=context)\\n \\n if price_item:\\n for line in procurement.purchase_id.order_line:\\n vals = {\\n 'discount': price_item.discount_line,\\n 'discount2': price_item.discount2_line\\n }\\n self.pool.get('purchase.order.line').write(cr, uid, [line.id], vals)\\n \\n return res\",\n \"def _set_additional_po_order_fields(self, invoice):\\n\\t\\tpass\",\n \"def test_invoice_update(self):\\n # first we create a customer\\n id = self._create_model(\\\"customer\\\", self.customer_data, [\\\"name\\\", \\\"email\\\", \\\"phone\\\"])\\n if id:\\n # then we can create the invoice\\n data = self.invoice_data\\n data[\\\"customer_id\\\"] = id\\n id_inv = self._create_model(\\\"invoice\\\", data, [])\\n if id_inv:\\n # create another customer\\n id_other = self._create_model(\\\"customer\\\", self.customer_data, [\\\"name\\\", \\\"email\\\", \\\"phone\\\"])\\n if id_other:\\n # then performe update\\n data = self.invoice_data\\n data[\\\"customer_id\\\"] = id_other\\n self._update_model(\\\"invoice\\\", id, data, [])\\n self.assertIsNotNone(id_other)\\n self.assertIsNotNone(id_inv)\\n self.assertIsNotNone(id)\",\n \"def action_generate_lines_txt(self):\\n rp_obj = self.env['res.partner']\\n voucher_obj = self.env['account.wh.iva']\\n txt_iva_obj = self.env['txt.iva.line']\\n vouchers = []\\n txt_brw = self.browse(self._ids)[0]\\n txt_ids = txt_iva_obj.search([('txt_id', '=', txt_brw.id)])\\n if txt_ids:\\n txt_ids.unlink()\\n\\n if txt_brw.type:\\n vouchers = voucher_obj.search([\\n ('date_ret', '>=', txt_brw.date_start),\\n ('date_ret', '<=', txt_brw.date_end),\\n ('period_id', '=', txt_brw.period_id.id),\\n ('state', '=', 'done'),\\n ('type', 'in', ['in_invoice', 'in_refund'])])\\n else:\\n vouchers = voucher_obj.search([\\n ('date_ret', '>=', txt_brw.date_start),\\n ('date_ret', '<=', txt_brw.date_end),\\n ('period_id', '=', txt_brw.period_id.id),\\n ('state', '=', 'done'),\\n ('type', 'in', ['out_invoice', 'out_refund'])])\\n\\n for voucher in vouchers:\\n acc_part_id = rp_obj._find_accounting_partner(voucher.partner_id)\\n for voucher_lines in voucher.wh_lines:\\n if voucher_lines.invoice_id.state not in ['open', 'paid']:\\n continue\\n for voucher_tax_line in voucher_lines.tax_line:\\n txt_iva_obj.create(\\n {'partner_id': acc_part_id.id,\\n 'voucher_id': voucher.id,\\n 'invoice_id': voucher_lines.invoice_id.id,\\n 'txt_id': txt_brw.id,\\n 'untaxed': voucher_tax_line.base,\\n 'amount_withheld': voucher_tax_line.amount_ret,\\n 'tax_wh_iva_id': voucher_tax_line.id,\\n })\\n return True\",\n \"def prepare_draft_rulings(self):\\r\\n records = self.retrieve_cached_records()\\r\\n if records:\\r\\n records = self.apply_rulings(records)\\r\\n records = u.apply_aggregators(\\r\\n map(lambda rc: (rc[0], rc[2]), self.ruling_columns),\\r\\n records\\r\\n )\\r\\n else:\\r\\n records = [] # might be None\\r\\n\\r\\n u.write_excel(\\r\\n records,\\r\\n self.draft_ruling_path,\\r\\n OrderedDict(map(lambda rc: (rc[0], rc[1]), self.ruling_columns)),\\r\\n )\",\n \"def ir_action_cancel_draft(self, cr, uid, ids, context=None):\\n if not len(ids):\\n return False\\n wf_service = netsvc.LocalService(\\\"workflow\\\")\\n for s_id in ids:\\n self.write(cr, uid, s_id, {'state':'draft'})\\n wf_service.trg_delete(uid, 'services.contracts.archive', s_id, cr) \\n wf_service.trg_create(uid, 'services.contracts.archive', s_id, cr)\\n return True\",\n \"def _prepare_invoice(self):\\n self.ensure_one()\\n # journal_id = self.env['account.invoice'].with_context(force_company=self.env.user.company_id.id).default_get(['journal_id'])['journal_id']\\n journal_id = self.company_id.journal_id.id\\n if not journal_id:\\n raise UserError(_('Please define an accounting sales journal for this company.'))\\n invoice_vals = {\\n 'name': self.client_order_ref or '',\\n 'origin': self.name,\\n 'type': 'out_invoice',\\n 'account_id': self.partner_invoice_id.property_account_receivable_id.id,\\n 'partner_id': self.partner_invoice_id.id,\\n 'partner_shipping_id': self.partner_shipping_id.id,\\n 'journal_id': journal_id,\\n 'currency_id': self.pricelist_id.currency_id.id,\\n 'comment': self.note,\\n 'payment_term_id': self.payment_term_id.id,\\n 'fiscal_position_id': self.fiscal_position_id.id or self.partner_invoice_id.property_account_position_id.id,\\n 'company_id': self.company_id.id,\\n 'user_id': self.user_id and self.user_id.id,\\n 'team_id': self.team_id.id\\n }\\n return invoice_vals\",\n \"def process_reconciliations(self, data):\\n AccountMoveLine = self.env['account.move.line']\\n for st_line, datum in zip(self, data):\\n payment_aml_rec = AccountMoveLine.browse(datum.get('payment_aml_ids', []))\\n for aml_dict in datum.get('counterpart_aml_dicts', []):\\n # aml_dict['counterpart_aml_id'] sering error\\n if aml_dict.get('counterpart_aml_id',False) :\\n aml_dict['move_line'] = AccountMoveLine.browse(aml_dict['counterpart_aml_id'])\\n del aml_dict['counterpart_aml_id']\\n st_line.process_reconciliation(datum.get('counterpart_aml_dicts', []), payment_aml_rec, datum.get('new_aml_dicts', []))\",\n \"def action_move_create(self):\\n\\n res = super(account_invoice, self).action_move_create()\\n\\n for inv in self:\\n if not inv.move_id:\\n return res\\n for ml in inv.move_id.line_id:\\n ml_vals = {\\n 'emp_police': inv.pol_numpol,\\n 'emp_quittance': inv.prm_numero_quittance,\\n 'emp_effet': datetime.datetime.strptime(inv.prm_datedeb, '%Y-%m-%d').date() if inv.prm_datedeb else datetime.datetime.today(),\\n 'emp_datech': datetime.datetime.strptime(inv.prm_datefin, '%Y-%m-%d').date() if inv.prm_datefin else datetime.datetime.today(),\\n }\\n ml.update(ml_vals)\\n move_vals = {\\n 'num_police': inv.pol_numpol,\\n 'num_quittance': inv.prm_numero_quittance,\\n 'date_effect': datetime.datetime.strptime(inv.prm_datedeb, '%Y-%m-%d').date() if inv.prm_datedeb else datetime.datetime.today(),\\n 'date_end': datetime.datetime.strptime(inv.prm_datefin, '%Y-%m-%d').date() if inv.prm_datefin else datetime.datetime.today(),\\n }\\n inv.move_id.update(move_vals)\\n self._log_event()\\n return res\",\n \"def open_invoices(self):\\n return {\\n 'domain': \\\"[('id', 'in', \\\" + str(self.invoice_ids.ids) + \\\" )]\\\",\\n 'name': 'Invoices',\\n 'view_mode': 'tree,form',\\n 'res_model': 'account.move',\\n 'type': 'ir.actions.act_window',\\n }\",\n \"def done(self, cr, uid, ids, context=None):\\n \\n voucher_obj = self.pool.get('account.voucher')\\n voucher_line_obj = self.pool.get('account.voucher.line')\\n admin_affairs_model_obj = self.pool.get('admin.affairs.model')\\n affairs_account_obj = self.pool.get('admin_affairs.account') \\n model_id = admin_affairs_model_obj.search(cr, uid, [('model','=','environment.and.safety')], context=context)[0] \\n affairs_account = affairs_account_obj.search(cr, uid, [('model_id','=',model_id)], context=context)\\n if not affairs_account:\\n raise osv.except_osv(_('Warning !'), _('Please insert account configuration For Environment and safety'))\\n affairs_account_id = affairs_account[0]\\n \\n affairs_account_record = affairs_account_obj.browse(cr, uid, affairs_account_id,context=context) \\n for record in self.browse(cr, uid, ids, context=context):\\n if not record.allowances_lines_after :\\n raise osv.except_osv(_('Partner Amount !'), _('Sorry no partner Amount After Rate To Transfer!'))\\n notes = _(\\\"Enviroment and Safety allowances Contract: %s\\\")%(record.name)\\n \\n journal_id = affairs_account_record.journal_id\\n analytic_id = affairs_account_record.analytic_id\\n account_id = affairs_account_record.account_id\\n\\n\\t\\t# Creating Voucher / Ratitication\\n voucher_id = voucher_obj.create(cr, uid, {\\n 'amount': record.amount_total,\\n 'type': 'ratification',\\n 'date': time.strftime('%Y-%m-%d'),\\n 'partner_id': record.partner_id.id,\\n 'journal_id': journal_id and journal_id.id , \\n 'state': 'draft',\\n\\t\\t\\t\\t\\t 'notes':record.notes,\\n\\t\\t\\t\\t\\t 'narration':notes ,\\n \\t 'company_id':record.company_id.id,\\n })\\n \\t# Creating Voucher / Ratitication Lines\\n for line in record.allowances_lines_after:\\n '''account_id =line.category_id.account_id\\n if not account_id:\\n account_id = line.category_id.parent_id.account_id\\n \\n if not account_id:\\n account_id = affairs_account_record.account_id \\n\\n if not account_id:\\n raise osv.except_osv(_('Invalid action !'), _('Please insert Account configuration For Environment and safety Service')) ''' \\n \\n account_analytic_id =line.category_id.analytic_id\\n if not account_analytic_id:\\n account_analytic_id = line.category_id.parent_id.analytic_id \\n \\n if not account_analytic_id:\\n account_analytic_id = affairs_account_record.analytic_id\\n \\n vocher_line_id = voucher_line_obj.create(cr, uid, {\\n 'amount': record.amount_total,\\n 'voucher_id': voucher_id,\\n\\t\\t\\t\\t\\t 'account_id':account_id and account_id.id,\\n\\t\\t\\t\\t\\t 'account_analytic_id':account_analytic_id and account_analytic_id.id ,\\n 'type': 'dr',\\n 'name':'environment and Safety allowances :' + record.name,\\n })\\n\\t\\t\\n\\t\\t# Selecting Voucher Number / Refernece \\n\\n voucher_number = self.pool.get('account.voucher').browse(cr,uid,voucher_id)\\n\\n copy_attachments(self,cr,uid,[record.id],'services.contracts.archive',voucher_id,'account.voucher', context)\\n self.write(cr, uid, ids, {'state':'done','transfer':True,'voucher_no':voucher_number.number}) \\n return True\",\n \"def onchange_partner_id(self\\n ):\\n if self._context is None:\\n context = {}\\n acc_part_brw = False\\n acc_id = False\\n rp_obj = self.env['res.partner']\\n wh_line_obj = self.env['account.wh.src.line']\\n\\n if self.partner_id:\\n #partner = rp_obj.browse(self.partner_id)\\n acc_part_brw = rp_obj._find_accounting_partner(self.partner_id)\\n if self.type and self.type in ('out_invoice', 'out_refund'):\\n acc_id = acc_part_brw.property_account_receivable_id \\\\\\n and acc_part_brw.property_account_receivable_id.id or False\\n else:\\n acc_id = acc_part_brw.property_account_payable_id \\\\\\n and acc_part_brw.property_account_payable_id.id or False\\n\\n # part_brw = self.ids and rp_obj._find_accounting_partner(self.browse(\\n # self, self.ids[0]).partner_id)\\n wh_lines = self.ids and wh_line_obj.search(\\n [('wh_id', '=', self.ids[0])])\\n if not self.partner_id:\\n if wh_lines:\\n wh_line_obj.unlink(wh_lines)\\n wh_lines = []\\n if self.partner_id and acc_part_brw and self.partner_id.id != acc_part_brw.id:\\n if wh_lines:\\n wh_line_obj.unlink(wh_lines)\\n wh_lines = []\\n\\n return {'value': {\\n 'line_ids': wh_lines,\\n 'account_id': acc_id,\\n }\\n }\",\n \"def _actualizar_precios(self, request, presup_id, *args, **kwargs):\\n obj_presup = Presupuesto.objects.get(pk=presup_id)\\n lineas_actualizadas = []\\n if not obj_presup._vigente():\\n turnoList = obj_presup.get_turnos_activos()\\n for turno in turnoList:\\n kwargs['pk'] = presup_id\\n for linea in turno.ofertatec_linea_set.all():\\n obj_ofertatec = OfertaTec.objects.get(pk=linea.ofertatec.id)\\n if linea.precio != obj_ofertatec.precio:\\n linea.precio = obj_ofertatec.precio\\n cantidad = linea.cantidad or 1\\n horas = linea.cant_horas or 1\\n linea.precio_total = linea.precio * cantidad * horas\\n lineas_actualizadas.append(linea)\\n if len(lineas_actualizadas) > 0 and obj_presup.fecha_realizado:\\n for turno in turnoList:\\n lab.views.createRevision(request, pk=turno.pk)\\n createRevision(request, pk=obj_presup.pk)\\n for linea in lineas_actualizadas:\\n linea.save()\\n return True\\n # Si el presupuesto esta vigente no le hago modificaciones\\n else:\\n return False\",\n \"def process_reconciliation(self, counterpart_aml_dicts=None, payment_aml_rec=None, new_aml_dicts=None):\\n\\t\\tcounterpart_aml_dicts = counterpart_aml_dicts or []\\n\\t\\tpayment_aml_rec = payment_aml_rec or self.env['account.move.line']\\n\\t\\tnew_aml_dicts = new_aml_dicts or []\\n\\n\\t\\taml_obj = self.env['account.move.line']\\n\\n\\t\\tcompany_currency = self.journal_id.company_id.currency_id\\n\\t\\tstatement_currency = self.journal_id.currency_id or company_currency\\n\\t\\tst_line_currency = self.currency_id or statement_currency\\n\\n\\t\\tcounterpart_moves = self.env['account.move']\\n\\n\\t\\t# Check and prepare received data\\n\\t\\tif any(rec.statement_id for rec in payment_aml_rec):\\n\\t\\t\\traise UserError(_('A selected move line was already reconciled.'))\\n\\t\\tfor aml_dict in counterpart_aml_dicts:\\n\\t\\t\\tif aml_dict['move_line'].reconciled:\\n\\t\\t\\t\\traise UserError(_('A selected move line was already reconciled.'))\\n\\t\\t\\tif isinstance(aml_dict['move_line'], pycompat.integer_types):\\n\\t\\t\\t\\taml_dict['move_line'] = aml_obj.browse(aml_dict['move_line'])\\n\\t\\tfor aml_dict in (counterpart_aml_dicts + new_aml_dicts):\\n\\t\\t\\tif aml_dict.get('tax_ids') and isinstance(aml_dict['tax_ids'][0], pycompat.integer_types):\\n\\t\\t\\t\\t# Transform the value in the format required for One2many and Many2many fields\\n\\t\\t\\t\\taml_dict['tax_ids'] = [(4, id, None) for id in aml_dict['tax_ids']]\\n\\t\\tif any(line.journal_entry_ids for line in self):\\n\\t\\t\\traise UserError(_('A selected statement line was already reconciled with an account move.'))\\n\\n\\t\\t# Fully reconciled moves are just linked to the bank statement\\n\\t\\ttotal = self.amount\\n\\t\\tfor aml_rec in payment_aml_rec:\\n\\t\\t\\ttotal -= aml_rec.debit - aml_rec.credit\\n\\t\\t\\taml_rec.with_context(check_move_validity=False).write({'statement_line_id': self.id})\\n\\t\\t\\tcounterpart_moves = (counterpart_moves | aml_rec.move_id)\\n\\n\\t\\t# Create move line(s). Either matching an existing journal entry (eg. invoice), in which\\n\\t\\t# case we reconcile the existing and the new move lines together, or being a write-off.\\n\\t\\tif counterpart_aml_dicts or new_aml_dicts:\\n\\t\\t\\tst_line_currency = self.currency_id or statement_currency\\n\\t\\t\\tst_line_currency_rate = self.currency_id and (self.amount_currency / self.amount) or False\\n\\n\\t\\t\\t# Create the move\\n\\t\\t\\tself.sequence = self.statement_id.line_ids.ids.index(self.id) + 1\\n\\t\\t\\tmove_vals = self._prepare_reconciliation_move(self.statement_id.name)\\t\\n\\t\\t\\t\\n\\t\\t\\t###################### Added search line and make create conditional #############################\\n\\t\\t\\t#move = self.env['account.move'].create(move_vals)\\n\\t\\t\\tmove = self.env['account.move'].search([('statement_id','=',move_vals['statement_id']),('voucher_seq','=',move_vals['voucher_seq'])])\\n\\t\\t\\tif not move:\\n\\t\\t\\t\\tmove = self.env['account.move'].create(move_vals)\\n\\t\\t\\t################ End Change #############################\\n\\t\\t\\t\\n\\t\\t\\tcounterpart_moves = (counterpart_moves | move)\\n\\n\\t\\t\\t# Create The payment\\n\\t\\t\\tpayment = self.env['account.payment']\\n\\t\\t\\tif abs(total)>0.00001:\\n\\t\\t\\t\\tpartner_id = self.partner_id and self.partner_id.id or False\\n\\t\\t\\t\\tpartner_type = False\\n\\t\\t\\t\\tif partner_id:\\n\\t\\t\\t\\t\\tif total < 0:\\n\\t\\t\\t\\t\\t\\tpartner_type = 'supplier'\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tpartner_type = 'customer'\\n\\n\\t\\t\\t\\tpayment_methods = (total>0) and self.journal_id.inbound_payment_method_ids or self.journal_id.outbound_payment_method_ids\\n\\t\\t\\t\\tcurrency = self.journal_id.currency_id or self.company_id.currency_id\\n\\t\\t\\t\\tpayment = self.env['account.payment'].create({\\n\\t\\t\\t\\t\\t'payment_method_id': payment_methods and payment_methods[0].id or False,\\n\\t\\t\\t\\t\\t'payment_type': total >0 and 'inbound' or 'outbound',\\n\\t\\t\\t\\t\\t'partner_id': self.partner_id and self.partner_id.id or False,\\n\\t\\t\\t\\t\\t'partner_type': partner_type,\\n\\t\\t\\t\\t\\t'journal_id': self.statement_id.journal_id.id,\\n\\t\\t\\t\\t\\t'payment_date': self.date,\\n\\t\\t\\t\\t\\t'state': 'reconciled',\\n\\t\\t\\t\\t\\t'currency_id': currency.id,\\n\\t\\t\\t\\t\\t'amount': abs(total),\\n\\t\\t\\t\\t\\t'communication': self._get_communication(payment_methods[0] if payment_methods else False),\\n\\t\\t\\t\\t\\t'name': self.statement_id.name,\\n\\t\\t\\t\\t})\\n\\n\\t\\t\\t# Complete dicts to create both counterpart move lines and write-offs\\n\\t\\t\\tto_create = (counterpart_aml_dicts + new_aml_dicts)\\n\\t\\t\\tctx = dict(self._context, date=self.date)\\n\\t\\t\\tfor aml_dict in to_create:\\n\\t\\t\\t\\taml_dict['move_id'] = move.id\\n\\t\\t\\t\\taml_dict['partner_id'] = self.partner_id.id\\n\\t\\t\\t\\taml_dict['statement_line_id'] = self.id\\n\\t\\t\\t\\tif st_line_currency.id != company_currency.id:\\n\\t\\t\\t\\t\\taml_dict['amount_currency'] = aml_dict['debit'] - aml_dict['credit']\\n\\t\\t\\t\\t\\taml_dict['currency_id'] = st_line_currency.id\\n\\t\\t\\t\\t\\tif self.currency_id and statement_currency.id == company_currency.id and st_line_currency_rate:\\n\\t\\t\\t\\t\\t\\t# Statement is in company currency but the transaction is in foreign currency\\n\\t\\t\\t\\t\\t\\taml_dict['debit'] = company_currency.round(aml_dict['debit'] / st_line_currency_rate)\\n\\t\\t\\t\\t\\t\\taml_dict['credit'] = company_currency.round(aml_dict['credit'] / st_line_currency_rate)\\n\\t\\t\\t\\t\\telif self.currency_id and st_line_currency_rate:\\n\\t\\t\\t\\t\\t\\t# Statement is in foreign currency and the transaction is in another one\\n\\t\\t\\t\\t\\t\\taml_dict['debit'] = statement_currency.with_context(ctx).compute(aml_dict['debit'] / st_line_currency_rate, company_currency)\\n\\t\\t\\t\\t\\t\\taml_dict['credit'] = statement_currency.with_context(ctx).compute(aml_dict['credit'] / st_line_currency_rate, company_currency)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t# Statement is in foreign currency and no extra currency is given for the transaction\\n\\t\\t\\t\\t\\t\\taml_dict['debit'] = st_line_currency.with_context(ctx).compute(aml_dict['debit'], company_currency)\\n\\t\\t\\t\\t\\t\\taml_dict['credit'] = st_line_currency.with_context(ctx).compute(aml_dict['credit'], company_currency)\\n\\t\\t\\t\\telif statement_currency.id != company_currency.id:\\n\\t\\t\\t\\t\\t# Statement is in foreign currency but the transaction is in company currency\\n\\t\\t\\t\\t\\tprorata_factor = (aml_dict['debit'] - aml_dict['credit']) / self.amount_currency\\n\\t\\t\\t\\t\\taml_dict['amount_currency'] = prorata_factor * self.amount\\n\\t\\t\\t\\t\\taml_dict['currency_id'] = statement_currency.id\\n\\n\\t\\t\\t# Create write-offs\\n\\t\\t\\t# When we register a payment on an invoice, the write-off line contains the amount\\n\\t\\t\\t# currency if all related invoices have the same currency. We apply the same logic in\\n\\t\\t\\t# the manual reconciliation.\\n\\t\\t\\tcounterpart_aml = self.env['account.move.line']\\n\\t\\t\\tfor aml_dict in counterpart_aml_dicts:\\n\\t\\t\\t\\tcounterpart_aml |= aml_dict.get('move_line', self.env['account.move.line'])\\n\\t\\t\\tnew_aml_currency = False\\n\\t\\t\\tif counterpart_aml\\\\\\n\\t\\t\\t\\t\\tand len(counterpart_aml.mapped('currency_id')) == 1\\\\\\n\\t\\t\\t\\t\\tand counterpart_aml[0].currency_id\\\\\\n\\t\\t\\t\\t\\tand counterpart_aml[0].currency_id != company_currency:\\n\\t\\t\\t\\tnew_aml_currency = counterpart_aml[0].currency_id\\n\\t\\t\\tfor aml_dict in new_aml_dicts:\\n\\t\\t\\t\\taml_dict['payment_id'] = payment and payment.id or False\\n\\t\\t\\t\\tif new_aml_currency and not aml_dict.get('currency_id'):\\n\\t\\t\\t\\t\\taml_dict['currency_id'] = new_aml_currency.id\\n\\t\\t\\t\\t\\taml_dict['amount_currency'] = company_currency.with_context(ctx).compute(aml_dict['debit'] - aml_dict['credit'], new_aml_currency)\\n\\t\\t\\t\\taml_obj.with_context(check_move_validity=False, apply_taxes=True).create(aml_dict)\\n\\n\\t\\t\\t# Create counterpart move lines and reconcile them\\n\\t\\t\\tfor aml_dict in counterpart_aml_dicts:\\n\\t\\t\\t\\tif aml_dict['move_line'].partner_id.id:\\n\\t\\t\\t\\t\\taml_dict['partner_id'] = aml_dict['move_line'].partner_id.id\\n\\t\\t\\t\\taml_dict['account_id'] = aml_dict['move_line'].account_id.id\\n\\t\\t\\t\\taml_dict['payment_id'] = payment and payment.id or False\\n\\n\\t\\t\\t\\tcounterpart_move_line = aml_dict.pop('move_line')\\n\\t\\t\\t\\tif counterpart_move_line.currency_id and counterpart_move_line.currency_id != company_currency and not aml_dict.get('currency_id'):\\n\\t\\t\\t\\t\\taml_dict['currency_id'] = counterpart_move_line.currency_id.id\\n\\t\\t\\t\\t\\taml_dict['amount_currency'] = company_currency.with_context(ctx).compute(aml_dict['debit'] - aml_dict['credit'], counterpart_move_line.currency_id)\\n\\t\\t\\t\\tnew_aml = aml_obj.with_context(check_move_validity=False).create(aml_dict)\\n\\n\\t\\t\\t\\t(new_aml | counterpart_move_line).reconcile()\\n\\n\\t\\t\\t# Balance the move\\n\\t\\t\\tst_line_amount = -sum([x.balance for x in move.line_ids])\\n\\t\\t\\taml_dict = self._prepare_reconciliation_move_line(move, st_line_amount)\\n\\t\\t\\taml_dict['payment_id'] = payment and payment.id or False\\n\\t\\t\\taml_obj.with_context(check_move_validity=False).create(aml_dict)\\n\\n\\t\\t\\t#################### Remarked Post Call ############################\\n\\t\\t\\t#move.post()\\n\\t\\t\\t#record the move name on the statement line to be able to retrieve it in case of unreconciliation\\n\\t\\t\\tself.write({'move_name': move.name})\\n\\t\\t\\tpayment and payment.write({'payment_reference': move.name})\\n\\t\\telif self.move_name:\\n\\t\\t\\traise UserError(_('Operation not allowed. Since your statement line already received a number, you cannot reconcile it entirely with existing journal entries otherwise it would make a gap in the numbering. You should book an entry and make a regular revert of it in case you want to cancel it.'))\\n\\t\\tcounterpart_moves.assert_balanced()\\n\\t\\treturn counterpart_moves\",\n \"def pre_approve(self, cr, uid, ids, context={}):\\n \\tfor voucher in self.browse(cr, uid, ids, context=context):\\n \\t if not voucher.department_id.analytic_account_id:\\n \\t raise osv.except_osv(_('Configration Check!'), _(\\\"Please add cost center for your department!\\\"))\\n \\t periods = self.pool.get('account.period').search(cr, uid, [('date_start','<=',voucher.date),('date_stop','>=',voucher.date),('company_id','=',voucher.company_id.id)], context=context)\\n\\n\\n res=0.0\\n if voucher.purpose:\\n if not voucher.purpose.account_id: raise osv.except_osv(_('Warning!'), _('Please configure account for this purpose!')) \\n voucher_line = {\\n \\t\\t'voucher_id': voucher.id,\\n \\t\\t'partner_id': voucher.partner_id.id,\\n \\t\\t'untax_amount': voucher.amount,\\n \\t\\t'amount': voucher.amount,\\n 'name': voucher.narration,\\n \\t\\t'type': 'dr',\\n \\t\\t'account_analytic_id': voucher.department_id.analytic_account_id and voucher.department_id.analytic_account_id.id,\\n 'account_id': voucher.purpose.account_id.id,\\n \\t }\\n new_amount = res and res or voucher.amount \\n voucher_line.update({'amount':new_amount,'untax_amount':new_amount})\\n \\t if voucher.line_ids :\\n for line in voucher.line_ids:\\n \\t\\t self.pool.get('account.voucher.line').write(cr, uid, line.id, {\\n \\t\\t'voucher_id': voucher.id,\\n \\t\\t'partner_id': voucher.partner_id.id,\\n \\t\\t'untax_amount': res or line.amount,\\n \\t\\t'amount': line.amount,\\n 'name': voucher.narration,\\n \\t\\t'type': 'dr',\\n \\t\\t'account_analytic_id': line.account_analytic_id and line.account_analytic_id.id or voucher.department_id.analytic_account_id.id,\\n 'account_id': voucher.purpose.account_id.id or line.account_id.id,\\n \\t }, context=context)\\n \\t else:\\n\\n \\t\\t new_voucher_line = self.pool.get('account.voucher.line').create(cr, uid, voucher_line, context=context)\\n context.update({'purchase':True})\\n self.create_budget_confirmation(cr, uid, [voucher.id], context)\\n \\tself.write(cr, uid, ids,{'state': 'preapprove','type':'purchase','ratification':True}, context=context)\\n #cxt = context.copy()\\n #cxt.update({'type':'ratification'})\\n if not super(account_voucher, self).create_budget_confirmation(cr, uid, ids, context=context):\\n self.write(cr, uid, ids, {'state': 'approved'}, context=context)\\n\\n \\t'''self.write(cr, uid, ids, {'state': 'preapprove'})\\n if not super(account_voucher, self).create_budget_confirmation(cr, uid, ids, context=context):\\n self.write(cr, uid, ids, {'state': 'approve','type':'purchase','ratification':True}, context=context)'''\\n return True\",\n \"def do_merge(self, line):\\n self.review.merge()\",\n \"def invoices(self):\\r\\n return inv.Invoices(self)\",\n \"def finish(self, closed=False, cont=False):\\n self.removeTemporaryObject()\\n if self.oldWP:\\n App.DraftWorkingPlane = self.oldWP\\n if hasattr(Gui, \\\"Snapper\\\"):\\n Gui.Snapper.setGrid()\\n Gui.Snapper.restack()\\n self.oldWP = None\\n\\n if len(self.node) > 1:\\n\\n if True:\\n FreeCADGui.addModule(\\\"Draft\\\")\\n # The command to run is built as a series of text strings\\n # to be committed through the `draftutils.todo.ToDo` class.\\n if (len(self.node) == 2\\n and utils.getParam(\\\"UsePartPrimitives\\\", False)):\\n # Insert a Part::Primitive object\\n p1 = self.node[0]\\n p2 = self.node[-1]\\n\\n _cmd = 'FreeCAD.ActiveDocument.'\\n _cmd += 'addObject(\\\"Part::Line\\\", \\\"Line\\\")'\\n _cmd_list = ['line = ' + _cmd,\\n 'line.X1 = ' + str(p1.x),\\n 'line.Y1 = ' + str(p1.y),\\n 'line.Z1 = ' + str(p1.z),\\n 'line.X2 = ' + str(p2.x),\\n 'line.Y2 = ' + str(p2.y),\\n 'line.Z2 = ' + str(p2.z),\\n 'Draft.autogroup(line)',\\n 'FreeCAD.ActiveDocument.recompute()']\\n self.commit(translate(\\\"draft\\\", \\\"Create Line\\\"),\\n _cmd_list)\\n else:\\n # Insert a Draft line\\n rot, sup, pts, fil = self.getStrings()\\n\\n _base = DraftVecUtils.toString(self.node[0])\\n _cmd = 'Draft.makeWire'\\n _cmd += '('\\n _cmd += 'points, '\\n _cmd += 'placement=pl, '\\n _cmd += 'closed=' + str(closed) + ', '\\n _cmd += 'face=' + fil + ', '\\n _cmd += 'support=' + sup\\n _cmd += ')'\\n _cmd_list = ['pl = FreeCAD.Placement()',\\n 'pl.Rotation.Q = ' + rot,\\n 'pl.Base = ' + _base,\\n 'points = ' + pts,\\n 'line = ' + _cmd,\\n 'Draft.autogroup(line)',\\n 'FreeCAD.ActiveDocument.recompute()']\\n self.commit(translate(\\\"draft\\\", \\\"Create Wire\\\"),\\n _cmd_list)\\n else:\\n import Draft\\n self.path = Draft.makeWire(self.node, closed=False, face=False)\\n\\n if self.ui and self.ui.continueMode:\\n self.Activated()\\n\\n self.makeTrench()\",\n \"def invoice_items(self,org_id=None,query={}):\\n if org_id is None:\\n org_id = self.org_id\\n query_end_date = datetime.strptime(query['endDate'],'%Y-%m-%dT%H:%M:%SZ')\\n # Given a 'query_end_date' to find the invoice containing the\\n # line items for that date we need to find the invoice which \\n # has 'endDate' equal to the end of the month of the `query_end_date`\\n query_first_next_month = query_end_date + relativedelta(months=+1) - relativedelta(days=(query_end_date.day-1))\\n target_invoices = []\\n invoices = self.invoices(org_id)\\n if self.verbose:\\n print('Searching invoices org_id={}'.format(org_id))\\n print('query={} query_end_date={}'.format(query,query_end_date))\\n print('Result keys: {}'.format( invoices['content'].keys() ))\\n print('Total result count: {}'.format( invoices['content']['totalCount'] ))\\n for invoice in invoices['content']['results']:\\n #pprint.pprint(invoice)\\n end_date = datetime.strptime(invoice['endDate'],'%Y-%m-%dT%H:%M:%SZ')\\n if self.verbose: \\n print('invoice({})[\\\\'endDate\\\\']={} end_date={}'.format(invoice['id'],invoice['endDate'],end_date))\\n if end_date == query_first_next_month:\\n target_invoices.append(invoice)\\n \\n if self.verbose: \\n print('Target invoices: {}'.format(target_invoices))\\n \\n\\n target_line_items = []\\n for invoice in target_invoices:\\n invoice_details = self.invoices(org_id,invoice['id']) \\n print('invoice_details: {}'.format(invoice_details))\\n for item in invoice_details['content']['lineItems']:\\n end_date = datetime.strptime(item['endDate'],'%Y-%m-%dT%H:%M:%SZ')\\n if end_date == query_end_date:\\n target_line_items.append(item)\\n if self.verbose:\\n print('target_line_items: {}'.format(target_line_items)) \\n return target_line_items\",\n \"def write(self, cr, uid, ids, vals, context=None):\\n new_accounts = {}\\n deleted = []\\n if 'line_id' in vals:\\n for val in vals['line_id']:\\n #the line changed\\n if val[2]:\\n if 'analytic_account_id' in val[2] or 'account_id' in val[2]:\\n new_accounts[val[1]] = val[2]\\n if val[0] == 2:\\n #for delete case\\n deleted.append(val[1])\\n budget_line_obj = self.pool.get('account.budget.lines')\\n\\n analytic_obj = self.pool.get('account.analytic.account')\\n account_obj = self.pool.get('account.account')\\n for acc_move in self.browse(cr, uid, ids, context=context):\\n for line in acc_move.line_id:\\n account_id = line.account_id.id\\n analytic_account_id = line.analytic_account_id.id\\n budget = line.analytic_account_id.budget\\n analytic_required = line.account_id.user_type.analytic_required \\n if line.id in deleted:\\n continue\\n if line.id in new_accounts:\\n if 'analytic_account_id' in new_accounts[line.id]:\\n if new_accounts[line.id]['analytic_account_id']:\\n analytic_account_id = new_accounts[line.id]['analytic_account_id']\\n analytic_account = analytic_obj.browse(cr,uid,analytic_account_id,context=context)\\n budget = analytic_account.budget\\n else:\\n #empty analytic account entered\\n budget = analytic_account_id = False\\n\\n if 'account_id' in new_accounts[line.id]:\\n account_id = new_accounts[line.id]['account_id']\\n account_rec = account_obj.browse(cr,uid,account_id,context=context)\\n analytic_required = account_rec.user_type.analytic_required\\n line_ids = budget_line_obj.search(cr, uid, [('general_account_id','=',account_id),\\n ('analytic_account_id', '=', analytic_account_id),\\n ('period_id', '=', line.period_id.id)],\\n context=context)\\n if not analytic_account_id and analytic_required:\\n raise orm.except_orm(_('Warning!'), _('Analytic Account Required!'))\\n\\n if not line_ids and budget:\\n raise orm.except_orm(_('Warning!'), _('This account has noo budget!'))\\n budget_line_vals = (vals.get('state','') in ['completed','closed','posted'] and \\\\\\n {'move_line_ids':[(1,line.id,{'budget_line_id':line_ids and line_ids[0]})]}) or \\\\\\n (line.budget_line_id and {'move_line_ids':[(3,line.id)]}) or {}\\n budget_line_obj.write(cr, uid, line_ids and line_ids[0] or [], budget_line_vals,context=context)\\n return super(account_move,self).write(cr, uid, ids, vals, context=context)\",\n \"def _prepare_order_line_invoice_line(self, cr, uid, line, account_id=False, context=None):\\n res = super(sale_order_line, self)._prepare_order_line_invoice_line(cr, uid, line, account_id=account_id, context=context)\\n \\n res.update({'part_number': line.part_number, 'internal_part_number' : line.internal_part_number})\\n return res\",\n \"def action_create_invoices(self, data):\\n invoice_obj = self.env['account.invoice']\\n values = {}\\n for val in data:\\n values.setdefault(val['invoice_type'], {\\n 'order': val.get('sale', val.get('purchase')),\\n 'values': []\\n })\\n values[val['invoice_type']]['values'].append((0, 0, val['values']))\\n\\n for inv_type, inv_data in values.items():\\n invoice = invoice_obj.new(self._prepare_invoice(inv_type))\\n invoice._onchange_partner_id()\\n inv = invoice._convert_to_write({\\n name: invoice[name] for name in invoice._cache\\n })\\n for _, _, line in inv_data['values']:\\n line['account_id'] = inv['account_id']\\n inv['invoice_line_ids'] = inv_data['values']\\n new_invoice = invoice_obj.sudo().create(inv)\\n new_invoice.action_invoice_open()\\n inv_data['order'].write({\\n 'exchange_invoice_ids': [(4, new_invoice.id)]\\n })\",\n \"def finish(self, closed=False, cont=False):\\n self.removeTemporaryObject()\\n if self.oldWP:\\n App.DraftWorkingPlane = self.oldWP\\n if hasattr(Gui, \\\"Snapper\\\"):\\n Gui.Snapper.setGrid()\\n Gui.Snapper.restack()\\n self.oldWP = None\\n\\n if len(self.node) > 1:\\n\\n if False:\\n Gui.addModule(\\\"Draft\\\")\\n # The command to run is built as a series of text strings\\n # to be committed through the `draftutils.todo.ToDo` class.\\n if (len(self.node) == 2\\n and utils.getParam(\\\"UsePartPrimitives\\\", False)):\\n # Insert a Part::Primitive object\\n p1 = self.node[0]\\n p2 = self.node[-1]\\n\\n _cmd = 'FreeCAD.ActiveDocument.'\\n _cmd += 'addObject(\\\"Part::Line\\\", \\\"Line\\\")'\\n _cmd_list = ['line = ' + _cmd,\\n 'line.X1 = ' + str(p1.x),\\n 'line.Y1 = ' + str(p1.y),\\n 'line.Z1 = ' + str(p1.z),\\n 'line.X2 = ' + str(p2.x),\\n 'line.Y2 = ' + str(p2.y),\\n 'line.Z2 = ' + str(p2.z),\\n 'Draft.autogroup(line)',\\n 'FreeCAD.ActiveDocument.recompute()']\\n self.commit(translate(\\\"draft\\\", \\\"Create Line\\\"),\\n _cmd_list)\\n else:\\n # Insert a Draft line\\n rot, sup, pts, fil = self.getStrings()\\n\\n _base = DraftVecUtils.toString(self.node[0])\\n _cmd = 'Draft.makeWire'\\n _cmd += '('\\n _cmd += 'points, '\\n _cmd += 'placement=pl, '\\n _cmd += 'closed=' + str(closed) + ', '\\n _cmd += 'face=' + fil + ', '\\n _cmd += 'support=' + sup\\n _cmd += ')'\\n _cmd_list = ['pl = FreeCAD.Placement()',\\n 'pl.Rotation.Q = ' + rot,\\n 'pl.Base = ' + _base,\\n 'points = ' + pts,\\n 'line = ' + _cmd,\\n 'Draft.autogroup(line)',\\n 'FreeCAD.ActiveDocument.recompute()']\\n self.commit(translate(\\\"draft\\\", \\\"Create Wire\\\"),\\n _cmd_list)\\n else:\\n import Draft\\n self.path = Draft.makeWire(self.node, closed=False, face=False)\\n\\n # super(_CommandTrench, self).finish()\\n gui_base_original.Creator.finish(self)\\n if self.ui and self.ui.continueMode:\\n self.Activated()\\n\\n self.makeTrench()\",\n \"def _prepare_invoice_line(self, inv_id):\\n res = {}\\n account_id = self.product_id.property_account_income_id.id or self.product_id.categ_id.property_account_income_categ_id.id\\n if not account_id:\\n raise UserError(_('Please define income account for this product: \\\"%s\\\" (id:%d).') % \\\\\\n (self.product_id.name, self.product_id.id,))\\n price_unit = self.product_id.lst_price\\n res = {\\n 'invoice_id': inv_id.id,\\n 'name': self.name,\\n 'origin': self.order_id.name,\\n 'account_id': account_id,\\n 'uom_id': self.product_uom_id.id,\\n 'quantity': self.product_uom_qty,\\n 'price_unit': price_unit,\\n 'product_id': self.product_id.id,\\n 'invoice_line_tax_id': False,\\n 'order_line_id': self.id\\n }\\n return res\",\n \"def invoices(self):\\r\\n return Invoices(self)\",\n \"def _prepare_invoice_lines(self, exchange_line, order_line):\\n invoice_type = {\\n 'sale.order.line': {\\n 'higher': 'out_invoice', 'lower': 'out_refund',\\n 'type': 'sale', 'field': 'exchange_sale_line_id'\\n },\\n 'purchase.order.line': {\\n 'higher': 'in_invoice', 'lower': 'in_refund',\\n 'type': 'purchase', 'field': 'exchange_purchase_line_id'\\n },\\n }\\n product = exchange_line.exchange_product_id or exchange_line.product_id\\n data = {\\n 'invoice_type': False,\\n 'values': {\\n 'product_id': product.id,\\n 'quantity': exchange_line.quantity,\\n 'name': 'Exchange for [%s]' % exchange_line.product_id.display_name,\\n }\\n }\\n if exchange_line.exchange_product_id or \\\\\\n exchange_line.price_subtotal > order_line.price_subtotal:\\n data['invoice_type'] = invoice_type[order_line._name]['higher']\\n elif exchange_line.price_subtotal < order_line.price_subtotal:\\n data['invoice_type'] = invoice_type[order_line._name]['lower']\\n else:\\n return {}\\n data[invoice_type[order_line._name]['type']] = order_line.order_id\\n data['values'][invoice_type[order_line._name]['field']] = order_line.id\\n data['values']['price_unit'] = exchange_line.price_unit\\n # TODO i think we should take the different between prices NOT the all price\\n # abs(exchange_line.price_unit - order_line.price_unit)\\n return data\",\n \"def confirmed(self, cr, uid, ids, context=None):\\n\\tallow_archive_line_obj = self.pool.get('services.contracts.allowances.lines')\\n for record in self.browse(cr, uid, ids, context=context):\\n\\t\\tif not record.allowances_lines_before :\\n \\traise osv.except_osv(_('Partner Lines !'), _('Sorry no partner Lines!'))\\n\\n\\t \\tlines_ids = [line.id for line in record.allowances_lines_after]\\n \\tallow_archive_line_obj.unlink(cr,uid,lines_ids,context=context)\\n\\n\\t\\tfor lines in record.allowances_lines_before:\\n\\t\\t\\tif lines.percentage_rating < 0 or lines.percentage_rating > 100 :\\n \\t\\traise osv.except_osv(_('Rate Error !'), _('Sorry you insert wrong rate ... rate is between (0,100)!'))\\n \\t\\tamount_after_rate_id = allow_archive_line_obj.create(cr, uid, {\\n \\t\\t\\t\\t'cost_of_rent':lines.cost_of_rent,\\n \\t\\t\\t\\t'amount_untaxed':round (lines.amount_untaxed*lines.percentage_rating/100,2),\\n \\t\\t\\t\\t'amount_tax':round(lines.amount_tax*lines.percentage_rating/100,2),\\n \\t\\t\\t\\t'amount_total':round(lines.amount_total*lines.percentage_rating/100,2),\\n \\t\\t\\t\\t'deduct_days':lines.deduct_days,\\n \\t\\t\\t\\t'deduct_amount':lines.deduct_amount,\\n \\t\\t\\t\\t'contract_id':lines.contract_id.id,\\n\\t\\t\\t\\t\\t'env_allow_id_after_rate':record.id,\\n\\t\\t\\t\\t\\t'type': 'after',\\n 'category_id':lines.category_id.id,\\n\\t\\t\\t\\t\\t'percentage_rating':lines.percentage_rating,\\n\\n })\\n\\t\\t\\n \\n self.write(cr, uid, ids, {'state':'confirmed'})\\n return True\",\n \"def complete(self, cr, uid, ids, context={}):\\n budget_pool = self.pool.get('account.budget')\\n budget_line_pool = self.pool.get('account.budget.lines')\\n for r in self.browse(cr, uid, ids, context=context):\\n if r.type=='transfer' and not r.line_ids:\\n raise osv.except_osv(_('Error!'),_('You cannot complete Transfer Operations without any Budget line.'))\\n if r.budget_type=='cash':\\n budget_ids = budget_pool.search(cr, uid,[('analytic_account_id', '=', r.analytic_account_id.id), \\n ('period_id', '=', r.period_id.id)], context=context)\\n budget_line_id = budget_line_pool.search(cr, uid,[('general_account_id', '=', r.account_id.id), \\n ('account_budget_id', 'in', tuple(budget_ids))], context=context)\\n if budget_line_id:\\n line=budget_line_pool.browse(cr, uid, budget_line_id, context=context)[0]\\n if line.planned_amount+line.total_operation < line.cash_total_operation + r.amount:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"Cash budget (%s) can't be more than planned budget (%s)!\\\") % \\\\\\n ( line.cash_total_operation+ r.amount,line.planned_amount+line.total_operation ,))\\n if line.cash_residual_balance + r.amount <=0:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"The amount you try to transfer (%s) is more than %s residual (%s)!\\\") % \\\\\\n (r.amount, line.name, line.cash_residual_balance,))\\n for e in r.line_ids:\\n if line.planned_amount+line.total_operation < line.cash_total_operation - r.amount:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"Cash budget (%s) can't be more than planned budget (%s)!\\\") % \\\\\\n ( e.cash_total_operation- r.amount,line.planned_amount+line.total_operation ,))\\n if e.line_id.cash_residual_balance - e.amount <=0:\\n raise orm.except_orm(_('Error!'),\\n _(\\\"The amount you try to transfer (%s) is more than %s residual (%s)!\\\") % \\\\\\n (e.amount, e.line_id.name, e.line_id.cash_residual_balance,))\\n return self.write(cr, uid, ids,{'state':'complete','name': r.name == '/' and \\n self.pool.get('ir.sequence').get(cr, uid, 'account.budget.operation') or \\n r.name, 'amount': r.type=='increase' and r.amount or sum([l.amount for l in r.line_ids])}, context=context)\\n \\n return super(account_budget_operation, self).complete(cr, uid, ids, context=context)\",\n \"def copy(self, cr, uid, id, default=None, context=None):\\n if default is None:\\n default = {}\\n default.update({'name': self.pool.get('ir.sequence').get(cr, uid, 'payment.enrich'),'state':'draft','month':None,'enrich_lines':None,\\n 'expenditure_voucher_id':None,'voucher_id':None,'approved_date':None})\\n return super(payment_enrich, self).copy(cr, uid, id, default, context)\",\n \"def lines(self, form, ids=None, done=None):\\n moveline_obj = self.pool.get('account.move.line')\\n cr,uid = self.cr,self.uid\\n ctx = self.context.copy()\\n ctx['fiscalyear'] = form['fiscalyear_id']\\n if form['filter'] == 'filter_period':\\n ctx['period_from'] = form['period_from']\\n ctx['period_to'] = form['period_to']\\n elif form['filter'] == 'filter_date':\\n ctx['date_from'] = form['date_from']\\n ctx['date_to'] = form['date_to']\\n ctx['state'] = form['target_move']\\n\\n account_ids = self.pool.get('account.account')._get_children_and_consol(cr, uid, [form['account_id'][0]], context=ctx)\\n if not account_ids: return []\\n move_query = moveline_obj._query_get(cr, uid, obj='l', context=ctx)\\n\\n cr.execute(\\\"\\\"\\\"\\n select\\n min(l.id) as id,\\n to_char(date,'MONTH') as name,\\n sum(l.debit-l.credit) as balance,\\n sum(l.debit) as debit,\\n sum(l.credit) as credit \\n from\\n account_move_line l\\n left join\\n account_account a on (l.account_id=a.id)\\n where \\n l.account_id in %s \\n AND \\\"\\\"\\\"+move_query+\\\"\\\"\\\"\\n group by\\n to_char(date,'MONTH'),to_char(date,'MM') \\n ORDER BY to_char(date,'MM')\\n \\\"\\\"\\\", (tuple(account_ids),))\\n\\n self.data = cr.dictfetchall()\\n return self.data\",\n \"def create_invoice(self, order): # noqa:max-complexity=18\\n\\n if len(order['order_lines']) == 0:\\n raise RuntimeError(\\n \\\"Expected 1 order_lines in order {}, got: {}\\\".format(\\n order['order_id'],\\n order['order_lines']\\n )\\n )\\n\\n order_id = order['order_id']\\n\\n refund = False\\n if order['state'] == 'REFUND':\\n refund = True\\n self.stdout.write(self.style.WARNING(\\\"Refunded order: {}\\\".format(order_id)))\\n elif order['state'] == 'PAID':\\n pass\\n else:\\n self.stdout.write(self.style.WARNING(\\\"Not processing unknown order state {} for: {}\\\".format(order['state'], order_id)))\\n return\\n\\n if self.only_known and order_id not in billy.TICKETBUTLER_IGNORE_LIST:\\n self.stdout.write(self.style.WARNING(\\\"Only processing known invoices, skipping {}\\\".format(order_id)))\\n return\\n\\n # Object containing all created tickets, to have an invoice relation\\n # appended later\\n ticketbutler_tickets = []\\n\\n for ticket in order['tickets']:\\n\\n sprints = list(filter(\\n lambda q: q['question'] == 148,\\n ticket['answers']\\n ))[0]\\n\\n if any(filter(lambda c: c['choice_heading'].lower() == 'no', sprints['answered_choices'])):\\n sprints = models.TicketbutlerTicket.SPRINTS_NO\\n elif any(filter(lambda c: c['choice_heading'].lower() == 'maybe', sprints['answered_choices'])):\\n sprints = models.TicketbutlerTicket.SPRINTS_MAYBE\\n elif any(filter(lambda c: c['choice_heading'].lower() == 'yes', sprints['answered_choices'])):\\n sprints = models.TicketbutlerTicket.SPRINTS_YES\\n\\n ticketbutler_ticket = models.TicketbutlerTicket.get_or_create(\\n ticket['email'],\\n ticket['full_name'],\\n order_id,\\n sprints,\\n ticket['ticket_type_name'],\\n )\\n if refund:\\n self.stdout.write(self.style.WARNING(\\\"This ticket was marked refunded: {}\\\".format(order_id)))\\n ticketbutler_ticket.refunded = True\\n ticketbutler_ticket.save()\\n else:\\n ticketbutler_ticket.refunded = False\\n ticketbutler_ticket.save()\\n\\n ticketbutler_tickets.append(ticketbutler_ticket)\\n\\n if refund:\\n self.stdout.write(self.style.WARNING(\\\"Skipping refunded order: {}\\\".format(order_id)))\\n return\\n\\n # If an email is changed on a TicketButler ticket and an old user exists without any other tickets,\\n # then disable this user's account and delete the ticket from the system\\n all_order_tickets = models.TicketbutlerTicket.objects.filter(ticketbutler_orderid=order_id)\\n\\n for ticket in order['tickets']:\\n\\n for verify_ticket in all_order_tickets:\\n # Check if the ticket is active in the current order, if it is\\n # then skip it.\\n if any(active.id == verify_ticket.id for active in ticketbutler_tickets):\\n continue\\n # Yeah, it's not active anymore, so delete it and potentially\\n # disable the user account\\n inactive_ticket = verify_ticket\\n self.stdout.write(self.style.WARNING(\\\"Going to remove ticket for {}, order_id: {}\\\".format(inactive_ticket.user.email, order_id)))\\n if inactive_ticket.user.tickets.all().exclude(id=inactive_ticket.id).exists():\\n # Just remove the ticket\\n self.stdout.write(self.style.WARNING(\\\"Found another ticket for user {} and deleted the inactive ticket in question but not the user\\\".format(inactive_ticket.user.email)))\\n if inactive_ticket.pk:\\n inactive_ticket.delete()\\n continue\\n else:\\n # Remove the user account too if there are no submissions and it's not a superuser\\n if not inactive_ticket.user.is_superuser and not inactive_ticket.user.submissions.all().exists():\\n if inactive_ticket.user.is_active:\\n self.stdout.write(self.style.WARNING(\\\"Also disabling user account for: {}\\\".format(inactive_ticket.user.email)))\\n inactive_ticket.user.is_active = False\\n inactive_ticket.user.save()\\n else:\\n self.stdout.write(self.style.WARNING(\\\"User was already inactive: {}\\\".format(inactive_ticket.user.email)))\\n # In case the user had several tickets, and one of them was already deleted\\n if inactive_ticket.pk:\\n inactive_ticket.delete()\\n\\n if 'discount' in order:\\n if order['discount']['amount'] == 100:\\n\\n for ticket in ticketbutler_tickets:\\n ticket.free_ticket = True\\n ticket.save()\\n\\n self.stdout.write(self.style.SUCCESS(\\\"Skipping invoice for free ticket for order id: {}\\\".format(order_id)))\\n return\\n else:\\n self.stdout.write(self.style.ERROR(\\\"!!! Order id {} will have an invoice generated with missing information, Ticketbutler said the discount was: {}\\\".format(order_id, order['discount']['amount'])))\\n\\n for ticketbutler_order_line_no, order_line in enumerate(order['order_lines']):\\n\\n self.process_order_line(order, order_line, ticketbutler_tickets, ticketbutler_order_line_no=ticketbutler_order_line_no)\",\n \"def process(invoices, output):\\n with open(output[\\\"fname\\\"], 'w', encoding=output[\\\"encoding\\\"]) as f:\\n for invoice in invoices.values():\\n flag = False\\n repeating_entries = set()\\n\\n for key, entry in invoice.entries.items():\\n if invoice.number_of_repeats[entry.name] > 1:\\n flag = True\\n repeating_entries.add((key, entry))\\n\\n if flag:\\n f.write(str(invoice))\\n for key, entry in sorted(repeating_entries, key=key_func):\\n f.write(f'\\\\t{str(entry)}\\\\t{str(key)}\\\\n')\",\n \"def refund(self, cr, uid, ids, context=None):\\n clone_list = []\\n line_obj = self.pool.get('pos.order.line')\\n \\n for order in self.browse(cr, uid, ids, context=context):\\n current_session_ids = self.pool.get('pos.session').search(cr, uid, [\\n ('state', '!=', 'closed'),\\n ('user_id', '=', uid)], context=context)\\n if not current_session_ids:\\n raise osv.except_osv(_('Error!'), _('To return product(s), you need to open a session that will be used to register the refund.'))\\n\\n clone_id = self.copy(cr, uid, order.id, {\\n 'name': order.name + ' REFUND', # not used, name forced by create\\n 'session_id': current_session_ids[0],\\n 'date_order': time.strftime('%Y-%m-%d %H:%M:%S'),\\n 'parent_id': order.id,\\n }, context=context)\\n clone_list.append(clone_id)\\n\\n for clone in self.browse(cr, uid, clone_list, context=context):\\n for order_line in clone.lines:\\n print order_line.available_qty\\n line_obj.write(cr, uid, [order_line.id], {\\n 'return_qty': 0.0,\\n 'qty': -(order_line.parent_id.available_qty),\\n }, context=context)\\n\\n abs = {\\n 'name': _('Return Products'),\\n 'view_type': 'form',\\n 'view_mode': 'form',\\n 'res_model': 'pos.order',\\n 'res_id':clone_list[0],\\n 'view_id': False,\\n 'context':context,\\n 'type': 'ir.actions.act_window',\\n 'nodestroy': True,\\n 'target': 'current',\\n }\\n return abs\",\n \"def _create_normalBom(self, idd, processedIds=[]):\\n default = {}\\n \\n if idd in processedIds:\\n return False\\n checkObj=self.browse(idd)\\n if not checkObj:\\n return False\\n bomType = self.env['mrp.bom']\\n objBoms = bomType.search([('product_tmpl_id', '=', checkObj.product_tmpl_id.id), ('type', '=', 'normal'), ('active', '=', True)])\\n idBoms = bomType.search([('product_tmpl_id', '=', checkObj.product_tmpl_id.id), ('type', '=', 'ebom'), ('active', '=', True)])\\n\\n if not objBoms:\\n if idBoms:\\n default={'product_tmpl_id': idBoms[0].product_tmpl_id.id,\\n 'type': 'normal', 'active': True, }\\n if idBoms[0].product_id:\\n default.update({'product_id': idBoms[0].product_id.id})\\n processedIds.append(idd)\\n newidBom = idBoms[0].with_context({'internal_writing':True}).copy(default)\\n if newidBom:\\n newidBom.with_context({'internal_writing':True}).write(default)\\n ok_rows = self._summarizeBom(newidBom.bom_line_ids)\\n for bom_line in list(set(newidBom.bom_line_ids) ^ set(ok_rows)):\\n bom_line.unlink()\\n for bom_line in ok_rows:\\n bom_line.with_context({'internal_writing':True}).write(\\n { 'type': 'normal', 'source_id': False, \\n 'product_qty': bom_line.product_qty, } )\\n self._create_normalBom(bom_line.product_id.id, processedIds=processedIds)\\n else:\\n for bom_line in bomType.browse(objBoms[0].id).bom_line_ids:\\n self._create_normalBom(bom_line.product_id.id, processedIds=processedIds)\\n return False\",\n \"def action_done(self):\\n result = super(StockPicking, self).action_done()\\n if self.picking_type_code == 'outgoing' and self.group_id.sale_id:\\n for line in self.move_line_ids.filtered(\\n lambda x: x.lot_id and x.lot_id.plan_type == 'sim'):\\n line.lot_id.write({'partner_id': self.partner_id.id})\\n\\n return result\",\n \"def batch_transfer(self):\\n ticket_range = self.zendesk.ticket_range()\\n for i in range(1, ticket_range):\\n tickets = self.zendesk.get_list_of_tickets(i)\\n for ticket in tickets[\\\"tickets\\\"]:\\n ticket_id = ticket[\\\"id\\\"]\\n self.transfer_ticket(ticket_id)\",\n \"def merge_object(self, obj):\\n for key, value in obj.lines.items():\\n if key not in self.lines:\\n self.lines[key] = value\\n self.lines[key] = self.lines[key] + value\",\n \"def _prepare_invoice(self):\\n self.ensure_one()\\n result = super(SaleOrder, self)._prepare_invoice()\\n result.update({\\n 'cost_center_id': self.cost_center_id and self.cost_center_id.id or False\\n })\\n return result\",\n \"def prep_incorporation_correction_filing(session, business, original_filing_id, payment_id, option):\\n filing_template = copy.deepcopy(CORRECTION_INCORPORATION)\\n filing_template['filing']['business'] = {'identifier': business.identifier}\\n for party in filing_template['filing']['correction']['parties']:\\n for role in party['roles']:\\n if role['roleType'] == 'Completing Party':\\n party['officer']['email'] = 'comp_party@email.com'\\n filing_template['filing']['correction']['contactPoint']['email'] = 'test@test.com'\\n filing_template['filing']['correction']['correctedFilingId'] = original_filing_id\\n filing = create_filing(token=payment_id, filing_json=filing_template, business_id=business.id)\\n filing.payment_completion_date = filing.filing_date\\n filing.save()\\n if option in ['COMPLETED']:\\n uow = versioning_manager.unit_of_work(session)\\n transaction = uow.create_transaction(session)\\n filing.transaction_id = transaction.id\\n filing.save()\\n return filing\",\n \"def receive_voucher(self, cr, uid, ids, context=None):\\n super(account_voucher, self).receive_voucher(cr, uid, ids, context=context)\\n if self.browse(cr, uid, ids, context=context)[0].operation_type == 'treasury':\\n self.action_move_line_create(cr, uid, ids, context=context)\\n return self.write(cr, uid, ids, {'state': 'receive'}, context=context)\",\n \"def merge_recs(part_one, part_two, output):\\n start_op_length = 28\\n with open(part_one, 'rb') as a_handle, \\\\\\n open(part_two, 'rb') as b_handle, \\\\\\n open(output, 'wb') as merged:\\n\\n a_data = a_handle.read()\\n b_data = b_handle.read()\\n\\n postgame_pos, _ = find_postgame(a_data, len(a_data))\\n if postgame_pos:\\n a_data_end = postgame_pos - LOOKAHEAD\\n else:\\n a_data_end = len(a_data)\\n b_header_len, = struct.unpack('<I', b_data[:4])\\n chapter = mgz.body.operation.build({\\n 'type': 'action',\\n 'op': 1,\\n 'length': 2,\\n 'action': {\\n 'type': 'chapter',\\n 'player_id': 0xff # our merge marker\\n }\\n })\\n\\n # part A with no postgame struct\\n merged.write(a_data[:a_data_end])\\n # chapter action\\n merged.write(chapter)\\n # offset to start of part B operations\\n merged.write(struct.pack('<I', a_data_end + len(chapter) + b_header_len))\\n # part B header (now a \\\"saved chapter\\\")\\n merged.write(b_data[4:b_header_len])\\n # part B operations with no start operation\\n merged.write(b_data[b_header_len + start_op_length:])\",\n \"def _reset_invoices_and_references_to_created(cls, routing_slip: RoutingSlipModel):\\n invoices: List[InvoiceModel] = db.session.query(InvoiceModel) \\\\\\n .filter(InvoiceModel.routing_slip == routing_slip.number) \\\\\\n .filter(InvoiceModel.invoice_status_code == InvoiceStatus.PAID.value) \\\\\\n .all()\\n for inv in invoices:\\n # Reset the statuses\\n inv.invoice_status_code = InvoiceStatus.CREATED.value\\n inv_ref = InvoiceReferenceModel.find_by_invoice_id_and_status(\\n inv.id, InvoiceReferenceStatus.COMPLETED.value\\n )\\n inv_ref.status_code = InvoiceReferenceStatus.ACTIVE.value\\n # Delete receipts as receipts are reversed in CFS.\\n for receipt in ReceiptModel.find_all_receipts_for_invoice(inv.id):\\n db.session.delete(receipt)\",\n \"def update_invoice(cls, invoice_id: int, payment_request: Tuple[Dict[str, Any]], is_apply_credit: bool = False):\\n current_app.logger.debug('<update_invoice')\\n\\n invoice: Invoice = Invoice.find_by_id(invoice_id, skip_auth_check=False)\\n # If the call is to apply credit, apply credit and release records.\\n if is_apply_credit:\\n credit_balance = Decimal('0')\\n payment_account: PaymentAccount = PaymentAccount.find_by_id(invoice.payment_account_id)\\n invoice_balance = invoice.total - (invoice.paid or 0)\\n if (payment_account.credit or 0) >= invoice_balance:\\n pay_service: PaymentSystemService = PaymentSystemFactory.create_from_payment_method(\\n invoice.payment_method_code)\\n # Only release records, as the actual status change should happen during reconciliation.\\n pay_service.apply_credit(invoice)\\n credit_balance = payment_account.credit - invoice_balance\\n invoice.paid = invoice.total\\n invoice.save()\\n elif (payment_account.credit or 0) <= invoice_balance:\\n invoice.paid = (invoice.paid or 0) + (payment_account.credit or 0)\\n invoice.save()\\n\\n payment_account.credit = credit_balance\\n payment_account.save()\\n else:\\n payment_method = get_str_by_path(payment_request, 'paymentInfo/methodOfPayment')\\n\\n is_not_currently_on_ob = invoice.payment_method_code != PaymentMethod.ONLINE_BANKING.value\\n is_not_changing_to_cc = payment_method not in (PaymentMethod.CC.value, PaymentMethod.DIRECT_PAY.value)\\n # can patch only if the current payment method is OB\\n if is_not_currently_on_ob or is_not_changing_to_cc:\\n raise BusinessException(Error.INVALID_REQUEST)\\n\\n # check if it has any invoice references already created\\n # if there is any invoice ref , send them to the invoiced credit card flow\\n\\n invoice_reference = InvoiceReference.find_active_reference_by_invoice_id(invoice.id)\\n if invoice_reference:\\n invoice.payment_method_code = PaymentMethod.CC.value\\n else:\\n pay_service: PaymentSystemService = PaymentSystemFactory.create_from_payment_method(\\n PaymentMethod.DIRECT_PAY.value)\\n payment_account = PaymentAccount.find_by_id(invoice.payment_account_id)\\n pay_service.create_invoice(payment_account, invoice.payment_line_items, invoice,\\n corp_type_code=invoice.corp_type_code)\\n\\n invoice.payment_method_code = PaymentMethod.DIRECT_PAY.value\\n invoice.save()\\n current_app.logger.debug('>update_invoice')\\n return invoice.asdict()\",\n \"def action_process(self):\\n self.check_difference_balance()\\n for statement in self:\\n statement_lines = statement.credit_move_line_ids + statement.debit_move_line_ids\\n for statement_line in statement_lines:\\n if statement_line.move_line_id:\\n statement_line.move_line_id.write({'cleared_bank_account': statement_line.cleared_bank_account,\\n 'bank_acc_rec_statement_id': statement_line.cleared_bank_account and statement.id or False\\n })\\n statement.write({'state': 'done',\\n 'verified_by_user_id': self._uid,\\n 'verified_date': time.strftime('%Y-%m-%d')\\n })\\n for debit_line in statement.debit_move_line_ids:\\n if debit_line.move_line_id.cleared_bank_account:\\n debit_line.move_line_id.move_id.is_reconciled = True\\n return True\",\n \"def _inline_draft(request):\\n # TODO(guido): turn asserts marked with XXX into errors\\n # Don't use @login_required, since the JS doesn't understand redirects.\\n if not request.user:\\n # Don't log this, spammers have started abusing this.\\n return HttpTextResponse('Not logged in')\\n snapshot = request.POST.get('snapshot')\\n assert snapshot in ('old', 'new'), repr(snapshot)\\n left = (snapshot == 'old')\\n side = request.POST.get('side')\\n assert side in ('a', 'b'), repr(side) # Display left (a) or right (b)\\n issue_id = int(request.POST['issue'])\\n issue = models.Issue.get_by_id(issue_id)\\n assert issue # XXX\\n patchset_id = int(request.POST.get('patchset') or\\n request.POST[side == 'a' and 'ps_left' or 'ps_right'])\\n patchset = models.PatchSet.get_by_id(int(patchset_id), parent=issue.key)\\n assert patchset # XXX\\n patch_id = int(request.POST.get('patch') or\\n request.POST[side == 'a' and 'patch_left' or 'patch_right'])\\n patch = models.Patch.get_by_id(int(patch_id), parent=patchset.key)\\n assert patch # XXX\\n text = request.POST.get('text')\\n lineno = int(request.POST['lineno'])\\n message_id = request.POST.get('message_id')\\n comment = _add_or_update_comment(user=request.user, issue=issue, patch=patch,\\n lineno=lineno, left=left,\\n text=text, message_id=message_id)\\n issue.calculate_draft_count_by_user()\\n issue_fut = issue.put_async()\\n\\n query = models.Comment.query(\\n models.Comment.patch_key == patch.key, models.Comment.lineno == lineno,\\n models.Comment.left == left).order(models.Comment.date)\\n comments = list(c for c in query if not c.draft or c.author == request.user)\\n if comment is not None and comment.author is None:\\n # Show anonymous draft even though we don't save it\\n comments.append(comment)\\n issue_fut.get_result()\\n if not comments:\\n return HttpTextResponse(' ')\\n for c in comments:\\n c.complete()\\n return render_to_response('inline_comment.html',\\n {'user': request.user,\\n 'patch': patch,\\n 'patchset': patchset,\\n 'issue': issue,\\n 'comments': comments,\\n 'lineno': lineno,\\n 'snapshot': snapshot,\\n 'side': side,\\n },\\n context_instance=RequestContext(request))\",\n \"def action_view_invoice_salon(self):\\n return {\\n 'name': 'Invoices',\\n 'domain': [('invoice_origin', '=', self.name)],\\n 'res_model': 'account.move',\\n 'view_id': False,\\n 'view_mode': 'tree,form',\\n 'type': 'ir.actions.act_window',\\n }\",\n \"def test_duplicate_invoices(self):\\n biling_info = baker.make(BillingInfo)\\n for i in range(20): # Try this more times to increase chance of failure\\n order = baker.make(Order, user=biling_info.user)\\n Invoice.objects.all().delete()\\n call_concurrently(3, complete_concrete_order, order_id=order.id)\\n self.assertEqual(Invoice.objects.count(), 1)\",\n \"def get_partial_books(self, fb_brw):\\n cr, uid = self.cr, self.uid\\n fb_obj = self.pool.get('fiscal.book')\\n if not fb_brw.fbl_ids:\\n return [{'init': [], 'lines': [], 'partial_total': []}]\\n\\n line_groups = self.get_line_groups(fb_brw)\\n last_page = len(line_groups)\\n if last_page == 1:\\n # self._print_book(\\n # [], line_groups[0].get('report_lines'), [], line_groups[0])\\n return [{'init': [],\\n 'lines': line_groups[0].get('report_lines'),\\n 'partial_total': []}]\\n res = []\\n for subgroup in line_groups:\\n cr.execute('SAVEPOINT report_original_fb_' + str(\\n subgroup.get('page')))\\n inv_ids = [line.get('invoice_id')[0]\\n for line in subgroup.get('report_lines')\\n if line.get('invoice_id')]\\n self.context.update(\\n call_from_report=1, report_group_inv_ids=inv_ids)\\n fb_obj.update_book(cr, uid, [fb_brw.id], context=self.context)\\n fb_brw.refresh()\\n begin_line = self.get_begin_line(res)\\n partial_total = (subgroup.get('page') != last_page and\\n self.get_partial_total(fb_brw, begin_line) or [])\\n res.append({'init': begin_line,\\n 'lines': subgroup.get('report_lines'),\\n 'partial_total': partial_total})\\n # self._print_book(\\n # begin_line, subgroup.get('report_lines'), partial_total,\\n # subgroup)\\n cr.execute('ROLLBACK TO SAVEPOINT report_original_fb_' + str(\\n subgroup.get('page')))\\n return res\",\n \"def _prepare_invoice_line(self, cr, uid, group, picking, move_line, invoice_id,\\n invoice_vals, context=None):\\n result = super(stock_picking, self)._prepare_invoice_line(cr, uid, group, picking, move_line, invoice_id,\\n invoice_vals, context=None)\\n \\n result['discount'] = self._get_discount_invoice(cr, uid, move_line)\\n result['discount2'] = self._get_discount2_invoice(cr, uid, move_line)\\n result['price_unit'] = self._get_price_unit_invoice(cr, uid, move_line, invoice_vals['type'], context=None)\\n return result\",\n \"def UpdateInvoice(self):\\n self.builder.get_object('GuiInvProd').get_buffer().set_text(\\\"Product:\\\\n\\\")\\n self.builder.get_object('GuiInvPrice').get_buffer().set_text(\\\"Price:\\\\n\\\")\\n self.amount = 0\\n for items in self.prod_list:\\n self.builder.get_object('GuiInvProd').get_buffer().insert_at_cursor(\\n u\\\"%s\\\\n\\\" % items['name'])\\n if self.is_member:\\n self.builder.get_object('GuiInvPrice').get_buffer().insert_at_cursor(\\n config.CURRENCY_SYMBOL + u\\\"%.2f\\\\n\\\" % items[2])\\n self.amount = self.amount + items[2]\\n else:\\n self.builder.get_object('GuiInvPrice').get_buffer().insert_at_cursor(\\n config.CURRENCY_SYMBOL + u\\\"%.2f\\\\n\\\" % items[3])\\n self.amount = self.amount + items[3]\\n if self.is_member:\\n self.builder.get_object('GuiInvProd').get_buffer().insert_at_cursor(\\n u\\\"\\\\nYou are a member.\\\")\\n self.builder.get_object('GuiTotal').set_text(config.CURRENCY_SYMBOL + u\\\"%.2f\\\" % self.amount)\\n self.builder.get_object('GuiInput').set_text(\\\"\\\")\",\n \"def unlink(self, cr, uid, ids, context=None):\\n payenrich = self.read(cr, uid, ids, ['state'], context=context)\\n for s in payenrich:\\n if s['state'] not in ['draft', 'cancel']:\\n raise osv.except_osv(_('Invalid Action Error'), _('In Order To Delete A Service Request Order(s), It Must Be Cancelled First!'))\\n return super(payment_enrich, self).unlink(cr, uid, ids, context=context)\",\n \"def _prepare_invoice(self):\\n # get current logged in user's timezone\\n local = pytz.timezone(self.env['res.users'].browse(self._uid).tz) or pytz.utc\\n\\n self.ensure_one()\\n journal_id = self.env['account.journal'].search([('type', '=', 'purchase')], limit=1).id\\n if not journal_id:\\n raise UserError(_('Please define an accounting purchase journal for this company.'))\\n invoice_vals = {\\n 'name': self.partner_ref or '',\\n 'origin': self.name,\\n 'type': 'in_invoice',\\n 'account_id': self.partner_id.property_account_payable_id.id,\\n 'partner_id': self.partner_id.id,\\n 'journal_id': journal_id,\\n 'currency_id': self.currency_id.id,\\n 'comment': self.notes,\\n 'payment_term_id': self.payment_term_id.id,\\n 'fiscal_position_id': self.fiscal_position_id.id or self.partner_id.property_account_position_id.id,\\n 'company_id': self.company_id.id,\\n 'purchase_id': self.id,\\n 'date_invoice':pytz.utc.localize(datetime.datetime.now()).astimezone(local).strftime('%Y-%m-%d'),\\n }\\n return invoice_vals\",\n \"def generate_eob(\\n self, date_of_service, date_of_eob, insured, invoice_id, cpt_code, charge_amount\\n ):\\n if insured == \\\"insured\\\":\\n # first copayments\\n copay_amount = np.random.choice(\\n self.distributions[\\\"copay_amounts\\\"],\\n 1,\\n p=self.distributions[\\\"copay_distribution\\\"],\\n )[0]\\n if copay_amount > 0:\\n invoicelineitemeob = pd.DataFrame(\\n {\\n \\\"invoice_id\\\": [invoice_id],\\n \\\"cpt_code\\\": [cpt_code],\\n \\\"created_on\\\": [date_of_service],\\n \\\"copay_amount\\\": [copay_amount],\\n \\\"adjustment_amount\\\": [0],\\n \\\"paid_amount\\\": [0],\\n }\\n )\\n self.InvoiceLineItemsEob = self.InvoiceLineItemsEob.append(\\n invoicelineitemeob\\n )\\n remaining_charge = charge_amount - copay_amount\\n else:\\n remaining_charge = charge_amount\\n # next eob discounts\\n eob_discount_percent = np.random.choice(\\n self.distributions[\\\"eob_discount_percentages\\\"],\\n 1,\\n p=self.distributions[\\\"eob_discount_distribution\\\"],\\n )[0]\\n if eob_discount_percent > 0:\\n insurance_adjustment = remaining_charge * eob_discount_percent / 100\\n remaining_charge = remaining_charge - insurance_adjustment\\n invoicelineitemeob = pd.DataFrame(\\n {\\n \\\"invoice_id\\\": [invoice_id],\\n \\\"cpt_code\\\": [cpt_code],\\n \\\"created_on\\\": [date_of_eob],\\n \\\"copay_amount\\\": [0],\\n \\\"adjustment_amount\\\": [insurance_adjustment],\\n \\\"paid_amount\\\": [0],\\n }\\n )\\n self.InvoiceLineItemsEob = self.InvoiceLineItemsEob.append(\\n invoicelineitemeob\\n )\\n # next handle eob payments where relevant\\n eob_payment_percentage = np.random.choice(\\n self.distributions[\\\"eob_payment_percentages\\\"],\\n 1,\\n p=self.distributions[\\\"eob_payment_distribution\\\"],\\n )[0]\\n eob_payment_amount = remaining_charge * (eob_payment_percentage / 100.0)\\n if eob_payment_amount > 0:\\n invoicelineitemeob = pd.DataFrame(\\n {\\n \\\"invoice_id\\\": [invoice_id],\\n \\\"cpt_code\\\": [cpt_code],\\n \\\"created_on\\\": [date_of_eob],\\n \\\"copay_amount\\\": [0],\\n \\\"adjustment_amount\\\": [0],\\n \\\"paid_amount\\\": [eob_payment_amount],\\n }\\n )\\n self.InvoiceLineItemsEob = self.InvoiceLineItemsEob.append(\\n invoicelineitemeob\\n )\\n remaining_charge = remaining_charge - eob_payment_amount\\n else:\\n remaining_charge = charge_amount\\n return remaining_charge\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6526457","0.60499185","0.6039584","0.5971947","0.5949904","0.5877273","0.58699375","0.5868027","0.5864572","0.57496387","0.56165034","0.5592037","0.55525774","0.5516271","0.5495002","0.5483541","0.5412485","0.5412102","0.53373694","0.53041404","0.5290604","0.52692235","0.5256279","0.5249647","0.5236856","0.5236116","0.52341986","0.52206016","0.5200139","0.51388955","0.51388496","0.5122479","0.51047635","0.5051272","0.50419605","0.502181","0.50170165","0.5007705","0.4998799","0.49985367","0.49881557","0.49792898","0.4976857","0.49700484","0.49641338","0.49258026","0.4922015","0.49101573","0.4909953","0.4897923","0.48913023","0.48867247","0.48777372","0.4866811","0.48238346","0.481972","0.48188823","0.48106176","0.48021778","0.4791925","0.47826585","0.4778795","0.4778554","0.47749498","0.4773191","0.4770609","0.47567505","0.47523278","0.4747633","0.47409788","0.4739125","0.46946192","0.46899083","0.46645722","0.46645567","0.46550095","0.46446663","0.46387267","0.46279615","0.46250018","0.46225634","0.4588386","0.45874342","0.45742422","0.4564728","0.45570424","0.45518747","0.4543182","0.45393336","0.45365804","0.45352572","0.45351407","0.45314208","0.45305064","0.45167252","0.4512364","0.45113882","0.45081094","0.45001996","0.44958174"],"string":"[\n \"0.6526457\",\n \"0.60499185\",\n \"0.6039584\",\n \"0.5971947\",\n \"0.5949904\",\n \"0.5877273\",\n \"0.58699375\",\n \"0.5868027\",\n \"0.5864572\",\n \"0.57496387\",\n \"0.56165034\",\n \"0.5592037\",\n \"0.55525774\",\n \"0.5516271\",\n \"0.5495002\",\n \"0.5483541\",\n \"0.5412485\",\n \"0.5412102\",\n \"0.53373694\",\n \"0.53041404\",\n \"0.5290604\",\n \"0.52692235\",\n \"0.5256279\",\n \"0.5249647\",\n \"0.5236856\",\n \"0.5236116\",\n \"0.52341986\",\n \"0.52206016\",\n \"0.5200139\",\n \"0.51388955\",\n \"0.51388496\",\n \"0.5122479\",\n \"0.51047635\",\n \"0.5051272\",\n \"0.50419605\",\n \"0.502181\",\n \"0.50170165\",\n \"0.5007705\",\n \"0.4998799\",\n \"0.49985367\",\n \"0.49881557\",\n \"0.49792898\",\n \"0.4976857\",\n \"0.49700484\",\n \"0.49641338\",\n \"0.49258026\",\n \"0.4922015\",\n \"0.49101573\",\n \"0.4909953\",\n \"0.4897923\",\n \"0.48913023\",\n \"0.48867247\",\n \"0.48777372\",\n \"0.4866811\",\n \"0.48238346\",\n \"0.481972\",\n \"0.48188823\",\n \"0.48106176\",\n \"0.48021778\",\n \"0.4791925\",\n \"0.47826585\",\n \"0.4778795\",\n \"0.4778554\",\n \"0.47749498\",\n \"0.4773191\",\n \"0.4770609\",\n \"0.47567505\",\n \"0.47523278\",\n \"0.4747633\",\n \"0.47409788\",\n \"0.4739125\",\n \"0.46946192\",\n \"0.46899083\",\n \"0.46645722\",\n \"0.46645567\",\n \"0.46550095\",\n \"0.46446663\",\n \"0.46387267\",\n \"0.46279615\",\n \"0.46250018\",\n \"0.46225634\",\n \"0.4588386\",\n \"0.45874342\",\n \"0.45742422\",\n \"0.4564728\",\n \"0.45570424\",\n \"0.45518747\",\n \"0.4543182\",\n \"0.45393336\",\n \"0.45365804\",\n \"0.45352572\",\n \"0.45351407\",\n \"0.45314208\",\n \"0.45305064\",\n \"0.45167252\",\n \"0.4512364\",\n \"0.45113882\",\n \"0.45081094\",\n \"0.45001996\",\n \"0.44958174\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7914905"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4989,"cells":{"query":{"kind":"string","value":"r\"\"\"Return the standard path to the shared area on the current platform."},"document":{"kind":"string","value":"def shared_area_path() -> str:\n\n try:\n return os.environ[\"OITG_SHARED_AREA\"]\n except KeyError:\n pass\n\n if os.name == \"nt\": # Windows\n return \"Z:\\\\\"\n if os.name == \"unix\" or os.name == \"posix\": # Linux / OSX / ...\n return os.path.expanduser(\"~/steaneShared/\")\n raise Exception(\"Unknown OS\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_share_path():\n cwd = os.path.dirname(__file__)\n share = os.path.join(cwd, '../share')\n return os.path.abspath(share)","def path_share(self) -> Path:\n return self.path_supervisor / SHARE_DATA","def get_path(self):\n\t\treturn call_sdk_function('PrlShare_GetPath', self.handle)","def path_extern_supervisor(self) -> PurePath:\n return PurePath(os.environ[ENV_SUPERVISOR_SHARE])","def path_extern_mounts(self) -> PurePath:\n return self.path_extern_supervisor / MOUNTS_FOLDER","def localPath(self):\n return self.home","def _get_mount_path(self, connection_info):\n share = self._normalize_export(connection_info['data']['export'])\n return os.path.join(self._get_mount_point_base(),\n utils.get_hash_str(share))","def path_extern_share(self) -> PurePath:\n return PurePath(self.path_extern_supervisor, SHARE_DATA)","def location(self):\n\n p = os.path.abspath(__file__)\n pathSP = os.path.split(p)\n return pathSP","def path_config(self):\n return HOMEASSISTANT_CONFIG.format(HASSIO_SHARE_INT)","def _getSocketPath():\n return f'{CmdSsh._getSshDir()}/soos-%r@%h-%p'","def _GetSystemPath():\n return encoding_util.GetEncodedValue(os.environ, \"PATH\")","def path(cls):\n from os.path import sep, join, exists\n from os import environ\n return join(environ.get(\"SystemRoot\", join(\"C:\", sep, \"Windows\")), \"System32\", \"mpclaim.exe\")","def get_box_pathway():\n import os\n import sys\n sys.dont_write_bytecode = True\n user_env = os.environ['USERPROFILE']\n os.chdir(user_env)\n directory_list = os.listdir(user_env)\n Box_boolean = 'Box' in directory_list\n Box_Sync_boolean = 'Box Sync' in directory_list\n if Box_boolean is False and Box_Sync_boolean is False:\n raise ValueError('Box or Box Sync is not in your pathway')\n elif Box_boolean is True and Box_Sync_boolean is True:\n raise ValueError('Program does not know whether to distinguish Box or Box Sync')\n else:\n if Box_boolean is True:\n return user_env + '\\Box\\\\'\n elif Box_Sync_boolean is True:\n return user_env + '\\Box Sync\\\\'","def get_home_path(self):\n\t\treturn call_sdk_function('PrlVmCfg_GetHomePath', self.handle)","def getPath(self):\n path = os.path.dirname(os.path.realpath(__file__)) #Finds the path of the application\n path =(os.path.dirname(os.path.realpath(__file__))+ '\\\\Enigma Settings') #Adds to the directory to create a folder\n \n return path #Returns the folders directory","def get_kernel_path():\n path = \"/\".join(os.path.dirname(os.path.realpath(__file__)).split('/')[:-1])\n return path+'/src/'","def os_path(self, **kw):\n with_drive = kw.get(\"with_drive\", True)\n if os.name == \"nt\":\n return self.windows_path(with_drive=with_drive)\n return self.posix_path(with_drive=with_drive)","def _get_os_path(self, name=None, path=''):\n\t\t\n\t\tif self.notebook_dir:\n\t\t\tout_path =os.path.join( self.notebook_dir, path.lstrip('/'))\n\t\telse:\n\t\t\tout_path = path\n\t\t\n\t\tif name:\n\t\t\tout_path = os.path.join(out_path, name.lstrip('/'))\n\t\t\n\t\treturn out_path","def _get_local_share_path(self, share):\n local_vol_path = self._get_mount_point_for_gluster_vol()\n if not os.access(local_vol_path, os.R_OK):\n raise exception.GlusterfsException('share path %s does not exist' %\n local_vol_path)\n return os.path.join(local_vol_path, share['name'])","def system_path(self, path):\n return os.path.join(self.prefix, path.lstrip('/'))","def getPath(self):\n path = '/'.join(self.getPhysicalPath())\n return path","def get_home():\n try:\n return str(Path.home())\n except Exception:\n return None","def get_absolute_pathname(self):\n return os.path.join(settings.PRIVATE_STORAGE_ROOT, self.get_relative_pathname())","def path(self):\r\n return self.chroot","def path(self):\r\n return self.chroot","def get_standard_directory(self):\n dirpath = (c.c_char * 256)()\n self._lib.StGetDirectory(c.c_int(1), c.byref(dirpath), 256)\n return dirpath.value.decode('ascii')","def _get_mount_point_for_share(self, nfs_share):\n nfs_share = nfs_share.encode('utf-8')\n return os.path.join(self.configuration.nexenta_mount_point_base,\n md5(nfs_share, usedforsecurity=False).hexdigest())","def GetPath(self):\n sdk_root = config.Paths().sdk_root\n if not sdk_root:\n raise NoSdkRootError()\n return os.path.join(sdk_root, self.name)","def realPath(self):\n \n return (self.useLink and [self.linkPath] or [self.installPath])[0]","def get_plato_path():\n\treturn \"/tsi/\"","def get_path() -> str:\n return os.path.dirname(os.path.realpath(__file__))","def getRootPath()->str:\n if '--develop' in sys.argv:\n return eel._get_real_path('public') + '/'\n\n return eel._get_real_path('build') + '/'","def full_path(self) -> str:\n return self.workspace.get_full_path(self)","def _GetLibraryPath(self, platform, backupPlatform=''):\n if platform == Environment.GetPlatform() or \\\n (backupPlatform and backupPlatform == Environment.GetPlatform()):\n return os.path.split(self._libraryPath)[1]\n return ''","def home_directory(self):\n out = self._call(\"GETHOMEDIRECTORY\")\n return out.json()[\"Path\"]","def shared_binary_location(cmd=\"shared\"):\n return os.path.join(BIN_PREFIX, cmd)\n return binary_location(cmd, SHARED_USE_PATH)","def path(self):\n return self.chroot","def getConfigPath():\n if sys.platform == 'linux':\n configpath = os.path.normpath(os.path.expanduser('~/.config/phobos'))\n elif sys.platform == 'darwin':\n configpath = os.path.normpath(os.path.expanduser('~/Library/Application Support/phobos'))\n elif sys.platform == 'win32':\n configpath = os.path.normpath(os.path.expanduser('~/AppData/Roaming/phobos'))\n else:\n configpath = 'ERROR: {0} not supported,'.format(sys.platform)\n return configpath","def get_path(self):\n return self.sync_path","def absolute_physical_path(self) -> str:\n return self._path","def work_root(session):\n return session[\"AVALON_WORKDIR\"]","def CoreDirectory():\n thisDir=WindowsPath(__file__).parent.resolve()\n # print(f\"this dir {thisDir}\")\n coreDir=thisDir.parent/\"MacroSystem/core\"\n return coreDir","def get_current_path(self):\r\n path_2 = self.path.replace('\\\\', '/')\r\n return self.copy_to_clipboard(path_2)","def standard_path_from_server_root(self, arg: str) -> str:\n # Remove beginning and ending quotes\n arg = arg.strip(\"'\\\"\")\n\n # Standardize the include argument based on server root\n if not arg.startswith(\"/\"):\n # Normpath will condense ../\n arg = os.path.normpath(os.path.join(self.root, arg))\n else:\n arg = os.path.normpath(arg)\n return arg","def get_default_mc_loc():\n if platform.system() == 'Windows': # Windows\n return join_path(os.getenv('APPDATA'), '.minecraft') # C:\\Users\\<user name>\\AppData\\Roaming\n elif platform.system() == 'Darwin': # MacOS\n return join_path(os.getenv('HOME'), 'Library', 'Application Support', 'minecraft') # /home/<user name>/Library/Application Support/minecraft\n else: # Linux\n return join_path(os.getenv('HOME'), '.minecraft') # /home/<user name>/.minecraft","def _get_reporoot():\n from os import path\n import acorn\n medpath = path.abspath(acorn.__file__)\n return path.dirname(path.dirname(medpath))","def _getSshDir():\n return f'{Path.home()}/.ssh'","def get_full_path(self):\n return self.path_display","def masterPath(self):\n\t\treturn fl.File( self._path + '/master.data' )","def get_output_path():\n\n path = rs.DocumentPath()\n name = rs.DocumentName()\n \n if gc.operating_system == \"mac\":\n\n path = path[:-len(name)] + \"_system.dat\"\n\n elif gc.operating_system == \"win\":\n\n i = path.rfind(\"\\\\\")\n\n path = path[:i] + \"/_system.dat\" \n\n return path","def this_folder():\n if getattr(sys, 'frozen', False):\n # The application is frozen\n return os.path.dirname(sys.executable)\n else:\n # The application is not frozen\n return os.path.dirname(__file__)","def platform_data_dir():\n if POSIX: # nocover\n dpath_ = os.environ.get('XDG_DATA_HOME', '~/.local/share')\n elif DARWIN: # nocover\n dpath_ = '~/Library/Application Support'\n elif WIN32: # nocover\n dpath_ = os.environ.get('APPDATA', '~/AppData/Roaming')\n else: # nocover\n raise NotImplementedError('Unknown Platform %r' % (sys.platform,))\n dpath = normpath(expanduser(dpath_))\n return dpath","def _get_mount(self):\n if not self._mount.endswith(os.path.sep):\n return \"%s%s\" % (self._mount, os.path.sep)\n else:\n return self._mount","def kard_folder_path(self):\n if self._base_path is None:\n if is_running_in_docker():\n container_id = os.popen(\n 'cat /proc/self/cgroup | grep docker | '\n 'grep -o -E \"[0-9a-f]{64}\" | head -n 1').read().rstrip()\n cli = docker.DockerClient(version='auto')\n cont = cli.containers.get(container_id)\n mount = next((\n c for c in cont.attrs['Mounts']\n if c['Destination'] == str(get_kard_root_path())))\n self._base_path = Path(mount['Source'])\n else:\n self._base_path = Path(self.kard.path).parent\n return self._base_path","def get_path(self, path):\n if path.startswith('/') and not path.startswith('~/'):\n return os.getcwd() + '/' + path\n else:\n return path","def AppPath(self):\n\t\treturn self.acad.Path","def path_mounts(self) -> Path:\n return self.path_supervisor / MOUNTS_FOLDER","def abspath(self, ref):\n \n directory, path = get_location(self.directory, ref.strip(),\n current=dirname(self.relative))\n path = join_fb_root(join(directory, path))\n return path","def path(self):\n path = os.path.join(self.base_dir, self.store().replace(' ', '_'), self.package_name())\n return os.path.abspath(path)","def workspace_path(self):\n return self._path_temp","def serverRootLocation():\n plist = \"/Library/Server/Preferences/Calendar.plist\"\n serverRoot = u\"/Library/Server/Calendar and Contacts\"\n if os.path.exists(plist):\n serverRoot = plistlib.readPlist(plist).get(\"ServerRoot\", serverRoot)\n return serverRoot","def path(self):\n if self._path:\n return self._path\n path = os.environ[\"PATH\"].split(os.pathsep)\n path = [os.path.expanduser(x) for x in path]\n path = [os.path.abspath(x) for x in path]\n path = [x for x in path if os.path.exists(x)]\n self._path = path\n return self._path","def get_root_abs_path() -> pathlib.Path:\n return PathManager._ROOT","def key_path(self):\n keypath = self._get_field('System', 'keypath')\n localpath = \"/\".join(__file__.split('/')[:-1])\n return join(localpath, keypath)","def path(self):\n return self.lib.path","def _spdr_engine_location():\n return os.path.realpath(__file__).rpartition('/')[0]","def abspath(self, *args):\n return os.path.join(self._spool, *args)","def get_path():\n return path.abspath(path.dirname(path.dirname(__file__)))","def root_path(self) -> Path:\n return ARCHIVES_ROOT / self.source_name / self.key","def path(self):\n return os.path.join(self.config.get('path', os.getcwd()))","def path_extern_homeassistant(self) -> PurePath:\n return PurePath(self.path_extern_supervisor, HOMEASSISTANT_CONFIG)","def server_relative_path(self):\n return self.properties.get(\"ServerRelativePath\", SPResPath(None))","def fs_sis_shared_space(self):\n return self._fs_sis_shared_space","def cwd_for_path(self, path):\n os_path = to_os_path(path, self.root_dir)\n # in the case of notebooks and kernels not being on the same filesystem,\n # walk up to root_dir if the paths don't exist\n while not os.path.isdir(os_path) and os_path != self.root_dir:\n os_path = os.path.dirname(os_path)\n return os_path","def platform_cache_dir():\n if POSIX: # nocover\n dpath_ = os.environ.get('XDG_CACHE_HOME', '~/.cache')\n elif DARWIN: # nocover\n dpath_ = '~/Library/Caches'\n elif WIN32: # nocover\n dpath_ = os.environ.get('LOCALAPPDATA', '~/AppData/Local')\n else: # nocover\n raise NotImplementedError('Unknown Platform %r' % (sys.platform,))\n dpath = normpath(expanduser(dpath_))\n return dpath","def platform_config_dir():\n if POSIX: # nocover\n dpath_ = os.environ.get('XDG_CONFIG_HOME', '~/.config')\n elif DARWIN: # nocover\n dpath_ = '~/Library/Application Support'\n elif WIN32: # nocover\n dpath_ = os.environ.get('APPDATA', '~/AppData/Roaming')\n else: # nocover\n raise NotImplementedError('Unknown Platform %r' % (sys.platform,))\n dpath = normpath(expanduser(dpath_))\n return dpath","def _get_filesystem_path(self, request):\n return self._get_path(filesystem_path(self.base_path, request, self.url_base), False)","def _windows_seps(path: str) -> str:\n\n if not path:\n return None\n elif os.sep != ntpath.sep:\n return path.replace(os.sep, ntpath.sep)\n else:\n return path","def path_homeassistant(self) -> Path:\n return self.path_supervisor / HOMEASSISTANT_CONFIG","def path():\n # Exclude path to this script from path.\n this_file = os.path.realpath(__file__)\n this_path = os.path.dirname(this_file)\n return os.pathsep.join(p for p in sys.path if p != this_path)","def localdir():\n root = __file__\n if os.path.islink(root):\n root = os.path.realpath(root)\n directory = os.path.dirname(os.path.abspath(root))\n return os.path.normpath(os.path.join(directory, \"../settings/\"))","def local_system_path(self, resource=None, path=None):\n p = os.path.join(config['resources']['data-dir'])\n if resource:\n if resource not in self._resources:\n raise InvalidPath(\"Invalid resource {}\".format(resource))\n p = os.path.join(config['resources']['data-dir'],\n self._resources[resource].local_dir)\n if path is not None:\n p = os.path.join(p, path)\n\n return os.path.expanduser(p)","def local_path(self):\n if self.repo_path:\n return self.repo_path\n tmpdir = PurePath(tempfile.gettempdir())\n return str(tmpdir.joinpath('harvest', self.org, self.repo))","def remote_path(self, volume):\n nfs_share = volume['provider_location']\n share = nfs_share.split(':')[1].rstrip('/')\n return '%s/%s/volume' % (share, volume['name'])","def get_mount_point(path):\n\n path = os.path.abspath(path)\n while path != os.path.sep:\n if os.path.ismount(path):\n return path\n path = os.path.abspath(os.path.join(path, os.pardir))\n return path","def getRootPath():\n return '/'.join(__file__.split('/')[:-4]) # Path of this file with pagebot/__init__.py(c) removed.","def get_home_directory(self, user: str) -> str:\n process = self.run(\n \"/\",\n \"root\",\n [\"sh\", \"-c\", f\"realpath ~{user}\"],\n encoding=\"utf-8\",\n stdout=subprocess.PIPE,\n )\n return process.stdout.strip()","def _win_documents_path():\n # Accesses the Windows API via ctypes\n import ctypes\n import ctypes.wintypes\n\n CSIDL_PERSONAL = 0x0005\n dll = ctypes.windll.shell32\n buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH + 1)\n if dll.SHGetSpecialFolderPathW(None, buf, CSIDL_PERSONAL, False):\n return buf.value.encode()\n else:\n raise ValueError","def home():\n if sys.prefix == sys.exec_prefix:\n return sys.prefix\n else:\n return ':'.join((sys.prefix, sys.exec_prefix))","def _get_home():\n from os.path import expanduser\n home = expanduser('~')\n return home","def systemdir():\n if platform == 'windows':\n return os.path.join(os.environ['ProgramFiles'], 'automaton')\n else:\n return \"/etc/automaton/\"","def _get_rc_local_path( self ):\n # might be a symlink but prepend_remote_shell_script doesn't work with symlinks\n return sudo( 'readlink -f /etc/rc.local' )","def get_singularity_path():\n return os.path.join(get_appdata(), 'CCP\\\\EVE\\\\d_eve_sharedcache_sisi_singularity')","def get_directory(self):\n mypath = mlblocks.get_primitives_paths()[-1]\n return mypath","def _get_path(): # THIS IS JUST FOR GETTING THE FILE\n return os.path.dirname(os.path.abspath(__file__)) + '/'","def _extract_system_path(self, script):\r\n\r\n DEFAULT_PATH = ['code']\r\n\r\n # Separate paths by :, like the system path.\r\n raw_path = script.get('system_path', '').split(\":\") + DEFAULT_PATH\r\n\r\n # find additional comma-separated modules search path\r\n path = []\r\n\r\n for dir in raw_path:\r\n if not dir:\r\n continue\r\n\r\n # path is an absolute path or a path relative to the data dir\r\n dir = os.path.join(self.capa_system.filestore.root_path, dir)\r\n # Check that we are within the filestore tree.\r\n reldir = os.path.relpath(dir, self.capa_system.filestore.root_path)\r\n if \"..\" in reldir:\r\n log.warning(\"Ignoring Python directory outside of course: %r\", dir)\r\n continue\r\n\r\n abs_dir = os.path.normpath(dir)\r\n path.append(abs_dir)\r\n\r\n return path","def get_root_folder() -> Path:\n return Path(__file__).parent.parent","def pathtofolder():\n return os.getcwd()","def site_section(self) -> str:\n match = PATH_FORMAT.match(self.path)\n if match:\n return match.group(\"base_path\")\n return \"\""],"string":"[\n \"def get_share_path():\\n cwd = os.path.dirname(__file__)\\n share = os.path.join(cwd, '../share')\\n return os.path.abspath(share)\",\n \"def path_share(self) -> Path:\\n return self.path_supervisor / SHARE_DATA\",\n \"def get_path(self):\\n\\t\\treturn call_sdk_function('PrlShare_GetPath', self.handle)\",\n \"def path_extern_supervisor(self) -> PurePath:\\n return PurePath(os.environ[ENV_SUPERVISOR_SHARE])\",\n \"def path_extern_mounts(self) -> PurePath:\\n return self.path_extern_supervisor / MOUNTS_FOLDER\",\n \"def localPath(self):\\n return self.home\",\n \"def _get_mount_path(self, connection_info):\\n share = self._normalize_export(connection_info['data']['export'])\\n return os.path.join(self._get_mount_point_base(),\\n utils.get_hash_str(share))\",\n \"def path_extern_share(self) -> PurePath:\\n return PurePath(self.path_extern_supervisor, SHARE_DATA)\",\n \"def location(self):\\n\\n p = os.path.abspath(__file__)\\n pathSP = os.path.split(p)\\n return pathSP\",\n \"def path_config(self):\\n return HOMEASSISTANT_CONFIG.format(HASSIO_SHARE_INT)\",\n \"def _getSocketPath():\\n return f'{CmdSsh._getSshDir()}/soos-%r@%h-%p'\",\n \"def _GetSystemPath():\\n return encoding_util.GetEncodedValue(os.environ, \\\"PATH\\\")\",\n \"def path(cls):\\n from os.path import sep, join, exists\\n from os import environ\\n return join(environ.get(\\\"SystemRoot\\\", join(\\\"C:\\\", sep, \\\"Windows\\\")), \\\"System32\\\", \\\"mpclaim.exe\\\")\",\n \"def get_box_pathway():\\n import os\\n import sys\\n sys.dont_write_bytecode = True\\n user_env = os.environ['USERPROFILE']\\n os.chdir(user_env)\\n directory_list = os.listdir(user_env)\\n Box_boolean = 'Box' in directory_list\\n Box_Sync_boolean = 'Box Sync' in directory_list\\n if Box_boolean is False and Box_Sync_boolean is False:\\n raise ValueError('Box or Box Sync is not in your pathway')\\n elif Box_boolean is True and Box_Sync_boolean is True:\\n raise ValueError('Program does not know whether to distinguish Box or Box Sync')\\n else:\\n if Box_boolean is True:\\n return user_env + '\\\\Box\\\\\\\\'\\n elif Box_Sync_boolean is True:\\n return user_env + '\\\\Box Sync\\\\\\\\'\",\n \"def get_home_path(self):\\n\\t\\treturn call_sdk_function('PrlVmCfg_GetHomePath', self.handle)\",\n \"def getPath(self):\\n path = os.path.dirname(os.path.realpath(__file__)) #Finds the path of the application\\n path =(os.path.dirname(os.path.realpath(__file__))+ '\\\\\\\\Enigma Settings') #Adds to the directory to create a folder\\n \\n return path #Returns the folders directory\",\n \"def get_kernel_path():\\n path = \\\"/\\\".join(os.path.dirname(os.path.realpath(__file__)).split('/')[:-1])\\n return path+'/src/'\",\n \"def os_path(self, **kw):\\n with_drive = kw.get(\\\"with_drive\\\", True)\\n if os.name == \\\"nt\\\":\\n return self.windows_path(with_drive=with_drive)\\n return self.posix_path(with_drive=with_drive)\",\n \"def _get_os_path(self, name=None, path=''):\\n\\t\\t\\n\\t\\tif self.notebook_dir:\\n\\t\\t\\tout_path =os.path.join( self.notebook_dir, path.lstrip('/'))\\n\\t\\telse:\\n\\t\\t\\tout_path = path\\n\\t\\t\\n\\t\\tif name:\\n\\t\\t\\tout_path = os.path.join(out_path, name.lstrip('/'))\\n\\t\\t\\n\\t\\treturn out_path\",\n \"def _get_local_share_path(self, share):\\n local_vol_path = self._get_mount_point_for_gluster_vol()\\n if not os.access(local_vol_path, os.R_OK):\\n raise exception.GlusterfsException('share path %s does not exist' %\\n local_vol_path)\\n return os.path.join(local_vol_path, share['name'])\",\n \"def system_path(self, path):\\n return os.path.join(self.prefix, path.lstrip('/'))\",\n \"def getPath(self):\\n path = '/'.join(self.getPhysicalPath())\\n return path\",\n \"def get_home():\\n try:\\n return str(Path.home())\\n except Exception:\\n return None\",\n \"def get_absolute_pathname(self):\\n return os.path.join(settings.PRIVATE_STORAGE_ROOT, self.get_relative_pathname())\",\n \"def path(self):\\r\\n return self.chroot\",\n \"def path(self):\\r\\n return self.chroot\",\n \"def get_standard_directory(self):\\n dirpath = (c.c_char * 256)()\\n self._lib.StGetDirectory(c.c_int(1), c.byref(dirpath), 256)\\n return dirpath.value.decode('ascii')\",\n \"def _get_mount_point_for_share(self, nfs_share):\\n nfs_share = nfs_share.encode('utf-8')\\n return os.path.join(self.configuration.nexenta_mount_point_base,\\n md5(nfs_share, usedforsecurity=False).hexdigest())\",\n \"def GetPath(self):\\n sdk_root = config.Paths().sdk_root\\n if not sdk_root:\\n raise NoSdkRootError()\\n return os.path.join(sdk_root, self.name)\",\n \"def realPath(self):\\n \\n return (self.useLink and [self.linkPath] or [self.installPath])[0]\",\n \"def get_plato_path():\\n\\treturn \\\"/tsi/\\\"\",\n \"def get_path() -> str:\\n return os.path.dirname(os.path.realpath(__file__))\",\n \"def getRootPath()->str:\\n if '--develop' in sys.argv:\\n return eel._get_real_path('public') + '/'\\n\\n return eel._get_real_path('build') + '/'\",\n \"def full_path(self) -> str:\\n return self.workspace.get_full_path(self)\",\n \"def _GetLibraryPath(self, platform, backupPlatform=''):\\n if platform == Environment.GetPlatform() or \\\\\\n (backupPlatform and backupPlatform == Environment.GetPlatform()):\\n return os.path.split(self._libraryPath)[1]\\n return ''\",\n \"def home_directory(self):\\n out = self._call(\\\"GETHOMEDIRECTORY\\\")\\n return out.json()[\\\"Path\\\"]\",\n \"def shared_binary_location(cmd=\\\"shared\\\"):\\n return os.path.join(BIN_PREFIX, cmd)\\n return binary_location(cmd, SHARED_USE_PATH)\",\n \"def path(self):\\n return self.chroot\",\n \"def getConfigPath():\\n if sys.platform == 'linux':\\n configpath = os.path.normpath(os.path.expanduser('~/.config/phobos'))\\n elif sys.platform == 'darwin':\\n configpath = os.path.normpath(os.path.expanduser('~/Library/Application Support/phobos'))\\n elif sys.platform == 'win32':\\n configpath = os.path.normpath(os.path.expanduser('~/AppData/Roaming/phobos'))\\n else:\\n configpath = 'ERROR: {0} not supported,'.format(sys.platform)\\n return configpath\",\n \"def get_path(self):\\n return self.sync_path\",\n \"def absolute_physical_path(self) -> str:\\n return self._path\",\n \"def work_root(session):\\n return session[\\\"AVALON_WORKDIR\\\"]\",\n \"def CoreDirectory():\\n thisDir=WindowsPath(__file__).parent.resolve()\\n # print(f\\\"this dir {thisDir}\\\")\\n coreDir=thisDir.parent/\\\"MacroSystem/core\\\"\\n return coreDir\",\n \"def get_current_path(self):\\r\\n path_2 = self.path.replace('\\\\\\\\', '/')\\r\\n return self.copy_to_clipboard(path_2)\",\n \"def standard_path_from_server_root(self, arg: str) -> str:\\n # Remove beginning and ending quotes\\n arg = arg.strip(\\\"'\\\\\\\"\\\")\\n\\n # Standardize the include argument based on server root\\n if not arg.startswith(\\\"/\\\"):\\n # Normpath will condense ../\\n arg = os.path.normpath(os.path.join(self.root, arg))\\n else:\\n arg = os.path.normpath(arg)\\n return arg\",\n \"def get_default_mc_loc():\\n if platform.system() == 'Windows': # Windows\\n return join_path(os.getenv('APPDATA'), '.minecraft') # C:\\\\Users\\\\<user name>\\\\AppData\\\\Roaming\\n elif platform.system() == 'Darwin': # MacOS\\n return join_path(os.getenv('HOME'), 'Library', 'Application Support', 'minecraft') # /home/<user name>/Library/Application Support/minecraft\\n else: # Linux\\n return join_path(os.getenv('HOME'), '.minecraft') # /home/<user name>/.minecraft\",\n \"def _get_reporoot():\\n from os import path\\n import acorn\\n medpath = path.abspath(acorn.__file__)\\n return path.dirname(path.dirname(medpath))\",\n \"def _getSshDir():\\n return f'{Path.home()}/.ssh'\",\n \"def get_full_path(self):\\n return self.path_display\",\n \"def masterPath(self):\\n\\t\\treturn fl.File( self._path + '/master.data' )\",\n \"def get_output_path():\\n\\n path = rs.DocumentPath()\\n name = rs.DocumentName()\\n \\n if gc.operating_system == \\\"mac\\\":\\n\\n path = path[:-len(name)] + \\\"_system.dat\\\"\\n\\n elif gc.operating_system == \\\"win\\\":\\n\\n i = path.rfind(\\\"\\\\\\\\\\\")\\n\\n path = path[:i] + \\\"/_system.dat\\\" \\n\\n return path\",\n \"def this_folder():\\n if getattr(sys, 'frozen', False):\\n # The application is frozen\\n return os.path.dirname(sys.executable)\\n else:\\n # The application is not frozen\\n return os.path.dirname(__file__)\",\n \"def platform_data_dir():\\n if POSIX: # nocover\\n dpath_ = os.environ.get('XDG_DATA_HOME', '~/.local/share')\\n elif DARWIN: # nocover\\n dpath_ = '~/Library/Application Support'\\n elif WIN32: # nocover\\n dpath_ = os.environ.get('APPDATA', '~/AppData/Roaming')\\n else: # nocover\\n raise NotImplementedError('Unknown Platform %r' % (sys.platform,))\\n dpath = normpath(expanduser(dpath_))\\n return dpath\",\n \"def _get_mount(self):\\n if not self._mount.endswith(os.path.sep):\\n return \\\"%s%s\\\" % (self._mount, os.path.sep)\\n else:\\n return self._mount\",\n \"def kard_folder_path(self):\\n if self._base_path is None:\\n if is_running_in_docker():\\n container_id = os.popen(\\n 'cat /proc/self/cgroup | grep docker | '\\n 'grep -o -E \\\"[0-9a-f]{64}\\\" | head -n 1').read().rstrip()\\n cli = docker.DockerClient(version='auto')\\n cont = cli.containers.get(container_id)\\n mount = next((\\n c for c in cont.attrs['Mounts']\\n if c['Destination'] == str(get_kard_root_path())))\\n self._base_path = Path(mount['Source'])\\n else:\\n self._base_path = Path(self.kard.path).parent\\n return self._base_path\",\n \"def get_path(self, path):\\n if path.startswith('/') and not path.startswith('~/'):\\n return os.getcwd() + '/' + path\\n else:\\n return path\",\n \"def AppPath(self):\\n\\t\\treturn self.acad.Path\",\n \"def path_mounts(self) -> Path:\\n return self.path_supervisor / MOUNTS_FOLDER\",\n \"def abspath(self, ref):\\n \\n directory, path = get_location(self.directory, ref.strip(),\\n current=dirname(self.relative))\\n path = join_fb_root(join(directory, path))\\n return path\",\n \"def path(self):\\n path = os.path.join(self.base_dir, self.store().replace(' ', '_'), self.package_name())\\n return os.path.abspath(path)\",\n \"def workspace_path(self):\\n return self._path_temp\",\n \"def serverRootLocation():\\n plist = \\\"/Library/Server/Preferences/Calendar.plist\\\"\\n serverRoot = u\\\"/Library/Server/Calendar and Contacts\\\"\\n if os.path.exists(plist):\\n serverRoot = plistlib.readPlist(plist).get(\\\"ServerRoot\\\", serverRoot)\\n return serverRoot\",\n \"def path(self):\\n if self._path:\\n return self._path\\n path = os.environ[\\\"PATH\\\"].split(os.pathsep)\\n path = [os.path.expanduser(x) for x in path]\\n path = [os.path.abspath(x) for x in path]\\n path = [x for x in path if os.path.exists(x)]\\n self._path = path\\n return self._path\",\n \"def get_root_abs_path() -> pathlib.Path:\\n return PathManager._ROOT\",\n \"def key_path(self):\\n keypath = self._get_field('System', 'keypath')\\n localpath = \\\"/\\\".join(__file__.split('/')[:-1])\\n return join(localpath, keypath)\",\n \"def path(self):\\n return self.lib.path\",\n \"def _spdr_engine_location():\\n return os.path.realpath(__file__).rpartition('/')[0]\",\n \"def abspath(self, *args):\\n return os.path.join(self._spool, *args)\",\n \"def get_path():\\n return path.abspath(path.dirname(path.dirname(__file__)))\",\n \"def root_path(self) -> Path:\\n return ARCHIVES_ROOT / self.source_name / self.key\",\n \"def path(self):\\n return os.path.join(self.config.get('path', os.getcwd()))\",\n \"def path_extern_homeassistant(self) -> PurePath:\\n return PurePath(self.path_extern_supervisor, HOMEASSISTANT_CONFIG)\",\n \"def server_relative_path(self):\\n return self.properties.get(\\\"ServerRelativePath\\\", SPResPath(None))\",\n \"def fs_sis_shared_space(self):\\n return self._fs_sis_shared_space\",\n \"def cwd_for_path(self, path):\\n os_path = to_os_path(path, self.root_dir)\\n # in the case of notebooks and kernels not being on the same filesystem,\\n # walk up to root_dir if the paths don't exist\\n while not os.path.isdir(os_path) and os_path != self.root_dir:\\n os_path = os.path.dirname(os_path)\\n return os_path\",\n \"def platform_cache_dir():\\n if POSIX: # nocover\\n dpath_ = os.environ.get('XDG_CACHE_HOME', '~/.cache')\\n elif DARWIN: # nocover\\n dpath_ = '~/Library/Caches'\\n elif WIN32: # nocover\\n dpath_ = os.environ.get('LOCALAPPDATA', '~/AppData/Local')\\n else: # nocover\\n raise NotImplementedError('Unknown Platform %r' % (sys.platform,))\\n dpath = normpath(expanduser(dpath_))\\n return dpath\",\n \"def platform_config_dir():\\n if POSIX: # nocover\\n dpath_ = os.environ.get('XDG_CONFIG_HOME', '~/.config')\\n elif DARWIN: # nocover\\n dpath_ = '~/Library/Application Support'\\n elif WIN32: # nocover\\n dpath_ = os.environ.get('APPDATA', '~/AppData/Roaming')\\n else: # nocover\\n raise NotImplementedError('Unknown Platform %r' % (sys.platform,))\\n dpath = normpath(expanduser(dpath_))\\n return dpath\",\n \"def _get_filesystem_path(self, request):\\n return self._get_path(filesystem_path(self.base_path, request, self.url_base), False)\",\n \"def _windows_seps(path: str) -> str:\\n\\n if not path:\\n return None\\n elif os.sep != ntpath.sep:\\n return path.replace(os.sep, ntpath.sep)\\n else:\\n return path\",\n \"def path_homeassistant(self) -> Path:\\n return self.path_supervisor / HOMEASSISTANT_CONFIG\",\n \"def path():\\n # Exclude path to this script from path.\\n this_file = os.path.realpath(__file__)\\n this_path = os.path.dirname(this_file)\\n return os.pathsep.join(p for p in sys.path if p != this_path)\",\n \"def localdir():\\n root = __file__\\n if os.path.islink(root):\\n root = os.path.realpath(root)\\n directory = os.path.dirname(os.path.abspath(root))\\n return os.path.normpath(os.path.join(directory, \\\"../settings/\\\"))\",\n \"def local_system_path(self, resource=None, path=None):\\n p = os.path.join(config['resources']['data-dir'])\\n if resource:\\n if resource not in self._resources:\\n raise InvalidPath(\\\"Invalid resource {}\\\".format(resource))\\n p = os.path.join(config['resources']['data-dir'],\\n self._resources[resource].local_dir)\\n if path is not None:\\n p = os.path.join(p, path)\\n\\n return os.path.expanduser(p)\",\n \"def local_path(self):\\n if self.repo_path:\\n return self.repo_path\\n tmpdir = PurePath(tempfile.gettempdir())\\n return str(tmpdir.joinpath('harvest', self.org, self.repo))\",\n \"def remote_path(self, volume):\\n nfs_share = volume['provider_location']\\n share = nfs_share.split(':')[1].rstrip('/')\\n return '%s/%s/volume' % (share, volume['name'])\",\n \"def get_mount_point(path):\\n\\n path = os.path.abspath(path)\\n while path != os.path.sep:\\n if os.path.ismount(path):\\n return path\\n path = os.path.abspath(os.path.join(path, os.pardir))\\n return path\",\n \"def getRootPath():\\n return '/'.join(__file__.split('/')[:-4]) # Path of this file with pagebot/__init__.py(c) removed.\",\n \"def get_home_directory(self, user: str) -> str:\\n process = self.run(\\n \\\"/\\\",\\n \\\"root\\\",\\n [\\\"sh\\\", \\\"-c\\\", f\\\"realpath ~{user}\\\"],\\n encoding=\\\"utf-8\\\",\\n stdout=subprocess.PIPE,\\n )\\n return process.stdout.strip()\",\n \"def _win_documents_path():\\n # Accesses the Windows API via ctypes\\n import ctypes\\n import ctypes.wintypes\\n\\n CSIDL_PERSONAL = 0x0005\\n dll = ctypes.windll.shell32\\n buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH + 1)\\n if dll.SHGetSpecialFolderPathW(None, buf, CSIDL_PERSONAL, False):\\n return buf.value.encode()\\n else:\\n raise ValueError\",\n \"def home():\\n if sys.prefix == sys.exec_prefix:\\n return sys.prefix\\n else:\\n return ':'.join((sys.prefix, sys.exec_prefix))\",\n \"def _get_home():\\n from os.path import expanduser\\n home = expanduser('~')\\n return home\",\n \"def systemdir():\\n if platform == 'windows':\\n return os.path.join(os.environ['ProgramFiles'], 'automaton')\\n else:\\n return \\\"/etc/automaton/\\\"\",\n \"def _get_rc_local_path( self ):\\n # might be a symlink but prepend_remote_shell_script doesn't work with symlinks\\n return sudo( 'readlink -f /etc/rc.local' )\",\n \"def get_singularity_path():\\n return os.path.join(get_appdata(), 'CCP\\\\\\\\EVE\\\\\\\\d_eve_sharedcache_sisi_singularity')\",\n \"def get_directory(self):\\n mypath = mlblocks.get_primitives_paths()[-1]\\n return mypath\",\n \"def _get_path(): # THIS IS JUST FOR GETTING THE FILE\\n return os.path.dirname(os.path.abspath(__file__)) + '/'\",\n \"def _extract_system_path(self, script):\\r\\n\\r\\n DEFAULT_PATH = ['code']\\r\\n\\r\\n # Separate paths by :, like the system path.\\r\\n raw_path = script.get('system_path', '').split(\\\":\\\") + DEFAULT_PATH\\r\\n\\r\\n # find additional comma-separated modules search path\\r\\n path = []\\r\\n\\r\\n for dir in raw_path:\\r\\n if not dir:\\r\\n continue\\r\\n\\r\\n # path is an absolute path or a path relative to the data dir\\r\\n dir = os.path.join(self.capa_system.filestore.root_path, dir)\\r\\n # Check that we are within the filestore tree.\\r\\n reldir = os.path.relpath(dir, self.capa_system.filestore.root_path)\\r\\n if \\\"..\\\" in reldir:\\r\\n log.warning(\\\"Ignoring Python directory outside of course: %r\\\", dir)\\r\\n continue\\r\\n\\r\\n abs_dir = os.path.normpath(dir)\\r\\n path.append(abs_dir)\\r\\n\\r\\n return path\",\n \"def get_root_folder() -> Path:\\n return Path(__file__).parent.parent\",\n \"def pathtofolder():\\n return os.getcwd()\",\n \"def site_section(self) -> str:\\n match = PATH_FORMAT.match(self.path)\\n if match:\\n return match.group(\\\"base_path\\\")\\n return \\\"\\\"\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75354296","0.6952207","0.67871875","0.67391086","0.67256176","0.6657467","0.6635167","0.661767","0.66105354","0.6436675","0.6340287","0.6331047","0.63205075","0.6297639","0.62504154","0.6217222","0.6186836","0.6157988","0.61453235","0.6119978","0.61148596","0.61036146","0.60967356","0.6091961","0.60649556","0.60649556","0.60303104","0.6011863","0.6002475","0.60024244","0.5988673","0.598336","0.59639025","0.5961879","0.5954032","0.5944549","0.5920802","0.5920613","0.5919807","0.5910782","0.59034544","0.5899904","0.58890384","0.5888895","0.5888649","0.58835614","0.58757544","0.58746046","0.58584017","0.5857375","0.58552134","0.58534133","0.58511883","0.5850528","0.5836711","0.58365226","0.58319575","0.58283645","0.5811796","0.58033127","0.58021015","0.5796344","0.57751685","0.5769574","0.5767842","0.5766182","0.57602924","0.5759437","0.5755839","0.5754592","0.5742297","0.5740234","0.5738132","0.5736668","0.5732669","0.5725006","0.57211155","0.5719392","0.57179236","0.57061726","0.56993985","0.5693953","0.56905967","0.5686172","0.56812525","0.5676247","0.5670134","0.5662917","0.56614316","0.56512785","0.5649088","0.56465447","0.56461966","0.56454945","0.5642816","0.56415224","0.56411886","0.5638341","0.56371224","0.56368035"],"string":"[\n \"0.75354296\",\n \"0.6952207\",\n \"0.67871875\",\n \"0.67391086\",\n \"0.67256176\",\n \"0.6657467\",\n \"0.6635167\",\n \"0.661767\",\n \"0.66105354\",\n \"0.6436675\",\n \"0.6340287\",\n \"0.6331047\",\n \"0.63205075\",\n \"0.6297639\",\n \"0.62504154\",\n \"0.6217222\",\n \"0.6186836\",\n \"0.6157988\",\n \"0.61453235\",\n \"0.6119978\",\n \"0.61148596\",\n \"0.61036146\",\n \"0.60967356\",\n \"0.6091961\",\n \"0.60649556\",\n \"0.60649556\",\n \"0.60303104\",\n \"0.6011863\",\n \"0.6002475\",\n \"0.60024244\",\n \"0.5988673\",\n \"0.598336\",\n \"0.59639025\",\n \"0.5961879\",\n \"0.5954032\",\n \"0.5944549\",\n \"0.5920802\",\n \"0.5920613\",\n \"0.5919807\",\n \"0.5910782\",\n \"0.59034544\",\n \"0.5899904\",\n \"0.58890384\",\n \"0.5888895\",\n \"0.5888649\",\n \"0.58835614\",\n \"0.58757544\",\n \"0.58746046\",\n \"0.58584017\",\n \"0.5857375\",\n \"0.58552134\",\n \"0.58534133\",\n \"0.58511883\",\n \"0.5850528\",\n \"0.5836711\",\n \"0.58365226\",\n \"0.58319575\",\n \"0.58283645\",\n \"0.5811796\",\n \"0.58033127\",\n \"0.58021015\",\n \"0.5796344\",\n \"0.57751685\",\n \"0.5769574\",\n \"0.5767842\",\n \"0.5766182\",\n \"0.57602924\",\n \"0.5759437\",\n \"0.5755839\",\n \"0.5754592\",\n \"0.5742297\",\n \"0.5740234\",\n \"0.5738132\",\n \"0.5736668\",\n \"0.5732669\",\n \"0.5725006\",\n \"0.57211155\",\n \"0.5719392\",\n \"0.57179236\",\n \"0.57061726\",\n \"0.56993985\",\n \"0.5693953\",\n \"0.56905967\",\n \"0.5686172\",\n \"0.56812525\",\n \"0.5676247\",\n \"0.5670134\",\n \"0.5662917\",\n \"0.56614316\",\n \"0.56512785\",\n \"0.5649088\",\n \"0.56465447\",\n \"0.56461966\",\n \"0.56454945\",\n \"0.5642816\",\n \"0.56415224\",\n \"0.56411886\",\n \"0.5638341\",\n \"0.56371224\",\n \"0.56368035\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.85109854"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4990,"cells":{"query":{"kind":"string","value":"Return the path to the given users analysis directory on the shared area (``/Users//analysis``)."},"document":{"kind":"string","value":"def analysis_root_path(user: Optional[str] = None) -> str:\n if user is None:\n user = _get_user()\n return os.path.join(shared_area_path(), \"Users\", user, \"analysis\")"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def todays_analysis_path(day: Optional[str] = None, user: Optional[str] = None) -> str:\n if day is None:\n day = date.today().isoformat()\n if user is None:\n user = _get_user()\n path = os.path.join(analysis_root_path(user=user), day)\n\n if not os.access(path, os.R_OK):\n # If the dir does not exist, create it\n os.mkdir(path)\n\n return path","def dir_user(assignment, user):\n return os.path.join(repository, assignment, user)","def dir_results(assignment, user):\n return os.path.join(repository, assignment, user, 'results')","def get_home_directory(self, user: str) -> str:\n process = self.run(\n \"/\",\n \"root\",\n [\"sh\", \"-c\", f\"realpath ~{user}\"],\n encoding=\"utf-8\",\n stdout=subprocess.PIPE,\n )\n return process.stdout.strip()","def analysis_path(\n project: str, location: str, conversation: str, analysis: str,\n ) -> str:\n return \"projects/{project}/locations/{location}/conversations/{conversation}/analyses/{analysis}\".format(\n project=project,\n location=location,\n conversation=conversation,\n analysis=analysis,\n )","def getFSUserDir(self):\n if not self.authorised:\n raise AuthError(401,\"I am sorry, but you are not authorised\")\n\n if self.authJson[\"userInfo\"] and self.authJson[\"userInfo\"][\"screenName\"]:\n fsDir = self.config.get(\"FileMan\",\"homedir\") + self.authJson[\"userInfo\"][\"screenName\"]\n return fsDir\n else: \n raise AuthError(500, \"Cannot determine the working directory - Liferay did not provide user's screenName\")","def getUserDir() -> str:\n\n if os.name == \"nt\": # Windows system, try to return documents directory\n try:\n import ctypes.wintypes\n CSIDL_PERSONAL = 5 # Documents\n SHGFP_TYPE_CURRENT = 0 # Current value\n\n buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH)\n ctypes.windll.shell32.SHGetFolderPathW(0, CSIDL_PERSONAL, 0, SHGFP_TYPE_CURRENT, buf)\n\n return buf.value\n except ImportError:\n pass\n\n return os.path.expanduser(\"~\") # Non-Windows system, return home directory","def getRelativeRootExperimentPath(self):\n return userId + \"/\" + \\\n self._rootExportPath[self._rootExportPath.rfind(self._properties['export_dir']):]","def get_share_path():\n cwd = os.path.dirname(__file__)\n share = os.path.join(cwd, '../share')\n return os.path.abspath(share)","def path_to_data():\n jab = os.expanduser('~/jab')\n return os.path.join(jab, 'local/login_sums.csv')","def user(path = None):\n if path:\n return \"%s/%s\" % (expanduser(\"~\"), path)\n else:\n return expanduser(\"~\")","def shared_area_path() -> str:\n\n try:\n return os.environ[\"OITG_SHARED_AREA\"]\n except KeyError:\n pass\n\n if os.name == \"nt\": # Windows\n return \"Z:\\\\\"\n if os.name == \"unix\" or os.name == \"posix\": # Linux / OSX / ...\n return os.path.expanduser(\"~/steaneShared/\")\n raise Exception(\"Unknown OS\")","def get_user_data_path():\n current_directory = os.path.dirname(os.path.realpath(__file__))\n return os.path.join(current_directory, 'emergency_fund_info.json')","def get_downloadpath(user_id):\r\n path = settings.DOCUMENT_PATH + str(user_id) + '/'\r\n if not os.path.isdir(path):\r\n os.mkdir(path)\r\n return path","def getFSUserDir(self):\n\n return self.config.get(\"FileMan\",\"homedir\") + self.getRole()[\"roleName\"]","def default_output_path():\n\n documents = os.path.join(os.path.expanduser('~'))\n try:\n documents = _xdg_documents_path()\n except: pass\n if platform.system() == 'Windows':\n try:\n documents = _win_documents_path()\n except: pass\n\n return os.path.join(documents, 'Topographica')","def get_folder(self):\n return os.path.join(\n settings.PRIVATE_STORAGE_ROOT, Exam.EXAM_FILES_LOCATION,\n str(self.unique_id)[0:2])","def get_teamocil_dir() -> pathlib.Path:\n return pathlib.Path(\"~/.teamocil/\").expanduser()","def get_game_dir(self, username=False):\n if not self.common and not username:\n raise RuntimeError(\"Can't determine this game's directory without username\")\n if self.common:\n subdir = \"common\"\n else:\n subdir = \"username\"\n subsubdir = self.dir\n if WIN32 or CYGWIN:\n subsubdir = subsubdir.lower()\n return os.path.join(subdir, subsubdir)","def share_directory(self):\n # Get the user to share file/folder with.\n share_user = User.query.filter_by(email = self.email.data).first()\n if not share_user:\n return\n\n # The source to copy to another user.\n filename = os.listdir(self.path.data)[int(self.index.data)]\n src = os.path.join(self.path.data, filename)\n # Get home path for the user to share folder with.\n dst = os.path.join(share_user.get_files_path(), filename)\n # Copy source to destination.\n copytree(src, dst)","def get_base_data_directory(self):\n user_category = ''\n directory = ''\n\n if self.session_start_date:\n start_time = self.session_start_date.split(' ')[0] #.replace('-', '')\n else:\n # PL. To avoid mixing users directory if they restart the application\n # after midnight but before 8 AM, the directory date doesn't change:\n _local_time = time.localtime()\n if _local_time[3] > 7:\n start_time = time.strftime(\"%Y-%m-%d\")\n else:\n # substract 8 hourse to current date to get yesterday's date. \n _local_time = time.gmtime((time.time() - 8*60*60))\n start_time = time.strftime(\"%Y-%m-%d\", _local_time)\n\n if self.is_inhouse():\n #directory = os.path.join(self.base_directory, self.endstation_name,\n # self.get_user_category(), self.get_proposal(),\n # start_time)\n directory = os.path.join(self.base_directory, start_time, self.proposal_number, self.get_proposal_number())\t \n else:\n #directory = os.path.join(self.base_directory, self.get_user_category(),\n # self.get_proposal(), self.endstation_name,\n # start_time)\n logging.debug(\"SoleilSession self.base_directory %s\" % self.base_directory)\n logging.debug(\"SoleilSession start_time %s\" % start_time)\n logging.debug(\"SoleilSession self.proposal_number %s\" % self.proposal_number)\n logging.debug(\"SoleilSession self.get_proposal_number() %s\" % self.get_proposal_number())\n directory = os.path.join(self.base_directory, start_time, self.get_proposal_number())\n\n return directory","def user_home_path(self):\n return path.join(env.user_home, self._user_home_path)","def _get_storage_path(self, stream_name:str=None, version:int=None, user_id:str=None):\n\n dirpath = self.data_path+\"study=\"+self.study_name+\"/\"\n\n if stream_name:\n dirpath += \"stream={0}/\".format(stream_name)\n\n if version:\n if \"stream=\" not in dirpath:\n raise ValueError(\"stream_name argument is missing.\")\n else:\n dirpath += \"version={0}/\".format(str(version))\n\n if user_id:\n if \"stream=\" not in dirpath or \"version=\" not in dirpath:\n raise ValueError(\"stream_name and/or version arguments are missing.\")\n else:\n dirpath += \"user={0}/\".format(user_id)\n\n return dirpath","def get_storage_directory(username=None):\n\n return os.path.join(get_home_dir(username), '.cfy-agent')","def get_disassembler_user_directory(self):\n pass","def get_home_dir(self, username):\n user = connection.User.find_one({'email': str(username) })\n return str(user['_id'])","def get_path(self, path):\n if path.startswith('/') and not path.startswith('~/'):\n return os.getcwd() + '/' + path\n else:\n return path","def home_directory(self):\n out = self._call(\"GETHOMEDIRECTORY\")\n return out.json()[\"Path\"]","def getRootDirectory(self):\n if Globals.WORKFLOWS_BASEDIR[0] == '~':\n return os.path.expanduser(Globals.WORKFLOWS_BASEDIR)\n else:\n return os.path.join('', Globals.WORKFLOWS_BASEDIR)","def get_data_dir():\n return Path(current_app.config[\"USER_DIR\"]) / \"data\"","def subOfUserFilesDir(subdir: str) -> str:\n return os.path.join(os.getcwd(), _baseUserFilesDir, subdir)","def getPath(self):\n path = os.path.dirname(os.path.realpath(__file__)) #Finds the path of the application\n path =(os.path.dirname(os.path.realpath(__file__))+ '\\\\Enigma Settings') #Adds to the directory to create a folder\n \n return path #Returns the folders directory","def pathtofolder():\n return os.getcwd()","def user_conf_dir(self):\n return os.path.join(BaseDirectory.xdg_config_home, \"speech-dispatcher\")","def localpath(self, *args):\n return os.path.join(os.path.expanduser(self.serverfiles_dir), *args)","def personaldir():\n if platform == 'windows':\n return os.path.join(os.environ['APPDATA'], 'automaton')\n else:\n return os.path.expanduser('~/.automaton/')","def _GetOwnersFilePath(path):\n if _IsWellFormattedFilePath(path):\n # _SRC is removed because the file system on the machine running the code\n # may not have a(n) src directory.\n path_without_src = path[len(SRC):]\n\n return os.path.abspath(\n os.path.join(*(DIR_ABOVE_TOOLS + path_without_src.split(os.sep))))\n\n raise Error(\n 'The given path {} is not well-formatted. Well-formatted paths begin '\n 'with \"src/\" and end with \"OWNERS\"'.format(path))","def load_analysis_path():\n import json\n import os\n with open(os.path.join(os.path.dirname(__file__), \"analysis_config.json\")) as my_file:\n analysis_paths = json.load(my_file)\n return analysis_paths","def artiq_results_path(experiment: Optional[str] = None) -> str:\n\n path = os.path.join(shared_area_path(), \"artiqResults\")\n\n if experiment is None:\n try:\n experiment = os.environ[\"OITG_EXPERIMENT\"]\n except KeyError:\n raise Exception(\n \"No experiment supplied, and no OITG_EXPERIMENT environment key\")\n\n return os.path.join(path, experiment)","def get_home_dir(self, username):\n return self.user_table[username]['home']","def get_user_homedir():\n return os.path.expanduser(\"~\")","def working_directory(self):\n project_full_path = \"/\".join(self.file_name.split(\"/\")[:-1])\n file_name = self.file_name.split(\"/\")[-1]\n if \".h5\" in file_name:\n file_name = file_name.split(\".h5\")[0]\n file_name += \"_hdf5\"\n if self.h5_path[0] == \"/\":\n h5_path = self.h5_path[1:]\n else:\n h5_path = self.h5_path\n return posixpath.join(project_full_path, file_name, h5_path)","def get_absolute_pathname(self):\n return os.path.join(settings.PRIVATE_STORAGE_ROOT, self.get_relative_pathname())","def _get_project_dir(self):\n return os.path.expanduser(\n self.sqlfluff_config.get_section(\n (self.templater_selector, self.name, \"project_dir\")\n )\n or os.getcwd()\n )","def get_user_data_dir_name(self):\n return self._user_data_dir.name","def output_path():\n folder = path.join(path.curdir, \"stages\")\n folder = path.abspath(folder)\n return ensure_path(folder)","def get_data_folder_path(challenge_short_name):\n return safe_join(settings.MEDIA_ROOT, challenge_short_name)","def work_root(session):\n return session[\"AVALON_WORKDIR\"]","def profile_directory_path(request, file):\n return directory_path('profile', file)","def outputFilepath(self, filename):\n return os.path.expanduser('~') + '/' + filename","def user_directory_path(instance, filename: str) -> str:\n\n # File will be uploaded to MEDIA_ROOT/user_<id>/<filename>\n return 'user_{0}/{1}'.format(instance.profile.user.pk, filename)","def _get_default_path(self):\n return os.path.join(cfg.DATA_DIR, 'visual_genome')","def path_share(self) -> Path:\n return self.path_supervisor / SHARE_DATA","def format_path (in_path):\n return os.path.realpath(os.path.expanduser(in_path))","def get_data_path():\n\n # Get pathname absolute or relative.\n path = os.path.join(\n os.path.dirname(__file__), __malstor_data_directory__)\n\n abs_data_path = os.path.abspath(path)\n if not os.path.exists(abs_data_path):\n raise project_path_not_found\n\n return abs_data_path","def _normalized_path(path):\n return os.path.abspath(os.path.expanduser(path))","def _get_config_path():\n return os.path.join(os.path.expanduser('~'))","def user_data_path(repo_base, repo='', file_name='', file_format=None):\n if len(repo_base) == 0:\n raise ValueError('Invalid repo_base.')\n if len(file_name) > 0 and len(repo) == 0:\n raise ValueError('Must pass in repo when providing file_name.')\n parts = [repo_base, repo, file_name]\n for p in parts:\n if (not isinstance(p, six.string_types) or p.startswith('.')):\n raise ValueError('Invalid path component.')\n path = os.path.abspath(os.path.join(os.sep, 'user_data', *parts))\n\n if file_format:\n if re.match('[^0-9a-zA-Z_-]', file_format):\n raise ValueError('Invalid file format specified.')\n path = '%s.%s' % (path, file_format)\n\n return path","def get_upload_path(instance, filename):\n \n userpath = \"{name}/{file}\".format(name=instance.user.username, file=filename)\n mainpath = os.path.join(\"infocomp\",userpath)\n return mainpath","def get_abs_path(self, value):\n return os.path.abspath(os.path.expanduser(os.path.expandvars(value)))","def user_data_dir(data_dir, username):\n user_data_dir = os.path.join(data_dir, username)\n if not os.path.exists(user_data_dir):\n os.mkdir(user_data_dir)\n return user_data_dir","def presentation(self, value):\r\n realpath = os.path.expanduser(value)\r\n if self.auto_create:\r\n if not os.path.exists(realpath):\r\n os.makedirs(realpath)\r\n return realpath","def Directory(self) -> str:","def data_abex_results_dir(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / \"Results\"","def sas_file(self):\n\n return os.path.normpath(self.path +'\\\\'+ cfg_dict['format_pgm'])","def get_user_directory(username=None):\n home = expanduser(\"~\")\n\n yew_dir = os.path.join(home, STORAGE_DIR, username or get_username())\n if not os.path.exists(yew_dir):\n os.makedirs(yew_dir)\n return yew_dir","def read_analysis(self,id):\n raw=requests.get(cfg_dict['analysis'] + id, auth=HttpNtlmAuth(cfg_dict['user'], cfg_dict['pass']))\n self.analysis=json.loads(raw.text)\n\n raw = self.analysis['directory'] + cfg_dict['format_loc']\n norm = os.path.normpath(raw)\n if os.path.exists(norm):\n self.path=norm","def dataset_path(cls):\n basepath = os.path.dirname(__file__)\n filepath = os.path.abspath(\n os.path.join(basepath, \"..\", \"datasets\", get_env('DATA_FILENAME')))\n return filepath","def get_report_path(self):\n report_path = os.path.join(logPath, \"report.html\")\n return report_path","def full_path(path):\n return os.path.realpath(os.path.expandvars(os.path.expanduser(path)))","def GetDataDir(self):\r\n \r\n sp = wx.StandardPaths.Get()\r\n return sp.GetUserDataDir()","def _glob_precip_stats_dirpath(reanalysis):\n fmt = os.path.join( os.path.split( os.path.split( filepath[reanalysis]['path'] )[0] )[0], '????', '??')\n return fmt.format('PRECTOT')","def get_output_path(self):\n output_path = '%s/%s' % (\n os.path.expanduser(JOB_OUTPUT_PATH), self.get_unique_name())\n return output_path","def get_user_config_path():\n\n return \"{}/.dapsenv/dapsenv.conf\".format(expanduser(\"~\"))","def user_directory(sub_directory):\n result = None\n directory = os.path.join(HOME, sub_directory)\n if os.path.exists(directory):\n result = directory\n return result","def get_user_folder_link_xpath():\n return links['users_folder'].get('folder_xpath')","def experiment_dir(experiment_name: str) -> Path: # pragma: no cover\n return EXPERIMENTS_DIR / experiment_name","def localPath(self):\n return self.home","def get_path():\n\n output_path = None\n while output_path is None:\n print question + \"Please enter the directory where you would like the file saved?\"\n output_path = raw_input()\n if os.path.isdir(os.path.expanduser(output_path)):\n pass\n else:\n os.system('clear')\n print warn + \"%s is not valid, please try again: \" % str(output_path)\n output_path = None\n return os.path.expanduser(output_path)","def homedir():\n return os.path.expanduser('~')","def _get_vispy_app_dir():\n # Define default user directory\n user_dir = os.path.expanduser('~')\n\n # Get system app data dir\n path = None\n if sys.platform.startswith('win'):\n path1, path2 = os.getenv('LOCALAPPDATA'), os.getenv('APPDATA')\n path = path1 or path2\n elif sys.platform.startswith('darwin'):\n path = os.path.join(user_dir, 'Library', 'Application Support')\n # On Linux and as fallback\n if not (path and os.path.isdir(path)):\n path = user_dir\n\n # Maybe we should store things local to the executable (in case of a\n # portable distro or a frozen application that wants to be portable)\n prefix = sys.prefix\n if getattr(sys, 'frozen', None): # See application_dir() function\n prefix = os.path.abspath(os.path.dirname(sys.path[0]))\n for reldir in ('settings', '../settings'):\n localpath = os.path.abspath(os.path.join(prefix, reldir))\n if os.path.isdir(localpath):\n try:\n open(os.path.join(localpath, 'test.write'), 'wb').close()\n os.remove(os.path.join(localpath, 'test.write'))\n except IOError:\n pass # We cannot write in this directory\n else:\n path = localpath\n break\n\n # Get path specific for this app\n appname = '.vispy' if path == user_dir else 'vispy'\n path = os.path.join(path, appname)\n return path","def path(self):\n path = os.path.join(self.base_dir, self.store().replace(' ', '_'), self.package_name())\n return os.path.abspath(path)","def workspace_path(self):\n return self._path_temp","def path_extern_supervisor(self) -> PurePath:\n return PurePath(os.environ[ENV_SUPERVISOR_SHARE])","def get_path(user_file:str):\n\n path: List[UserMeasure] = []\n with open(user_file) as f:\n for line in f.readlines():\n data = line.split(\",\")\n path.append(UserMeasure(\n data[0], # Timestamp\n data[1], # LAC\n data[2], # ID\n data[3], # Zone\n ))\n return path","def get_working_dir(self):\n return self.role.directory","def location(self):\n\n p = os.path.abspath(__file__)\n pathSP = os.path.split(p)\n return pathSP","def localdir():\n root = __file__\n if os.path.islink(root):\n root = os.path.realpath(root)\n directory = os.path.dirname(os.path.abspath(root))\n return os.path.normpath(os.path.join(directory, \"../settings/\"))","def output_path(self) -> str:\n if self._output_path is None:\n if not self._root_folder:\n self._root_folder = self._env.experiments_folder\n folder = os.path.join(self._root_folder, self.key)\n\n if not os.path.exists(folder):\n os.makedirs(folder)\n\n self._output_path = folder\n\n return self._output_path","def get_default_data_dir(self):\n data_dir_path = os.path.join(self.comicsite.short_name,self.folder_prefix,self.cleantitle)\n return data_dir_path","def _get_default_path(self):\n # return os.path.join(datasets.ROOT_DIR, 'data', 'MSRC21')\n # set local path\n return u'/Users/danilonunes/workspace/datasets/msrc21/'","def _fixpath(p):\n return os.path.abspath(os.path.expanduser(p))","def pwd_expanduser ( fspath, uid ):\n if not fspath or fspath[0] != '~':\n return fspath\n elif len ( fspath ) < 2:\n return get_home_dir ( uid )\n elif fspath[1] == os.sep:\n return get_home_dir ( uid ) + fspath[1:]\n else:\n return fspath","def user_plugin_dir() -> str:\n return os.path.join(user_data_dir(), 'plugins')","def get_softfax_output_file_path(request):\n if request.config.getoption(\"--output\"):\n path = os.path.join(ma_misc.get_abs_path(\"/results\", False), request.config.getoption(\"--output\"))\n if not os.path.isdir(path[:path.rfind(\"/\")]):\n os.makedirs(path[:path.rfind(\"/\")])\n return path\n else:\n return os.path.join(pytest.session_result_folder, \"performance/sending_fax_result.xls\")","def assignments_root_path(self):\n return os.path.join(self.root_path,\n self.assignments.model.__name__.lower())","def fix_path(path):\n return os.path.abspath(os.path.expanduser(path))","def _get_organisms_file_path(self, gene_name, gene_id):\n return os.path.join(os.getcwd(), \"src\", \"data\", \"organisms\", \"{}_{}.txt\".format(gene_name, gene_id))","def get_score_path(cfg):\n return os.path.join(\n get_score_dir(cfg),\n \"ener.csv\")","def subOfUserConfigFilesDir(subdir: str) -> str:\n return os.path.join(os.getcwd(), _baseUserConfigFilesDir, subdir)"],"string":"[\n \"def todays_analysis_path(day: Optional[str] = None, user: Optional[str] = None) -> str:\\n if day is None:\\n day = date.today().isoformat()\\n if user is None:\\n user = _get_user()\\n path = os.path.join(analysis_root_path(user=user), day)\\n\\n if not os.access(path, os.R_OK):\\n # If the dir does not exist, create it\\n os.mkdir(path)\\n\\n return path\",\n \"def dir_user(assignment, user):\\n return os.path.join(repository, assignment, user)\",\n \"def dir_results(assignment, user):\\n return os.path.join(repository, assignment, user, 'results')\",\n \"def get_home_directory(self, user: str) -> str:\\n process = self.run(\\n \\\"/\\\",\\n \\\"root\\\",\\n [\\\"sh\\\", \\\"-c\\\", f\\\"realpath ~{user}\\\"],\\n encoding=\\\"utf-8\\\",\\n stdout=subprocess.PIPE,\\n )\\n return process.stdout.strip()\",\n \"def analysis_path(\\n project: str, location: str, conversation: str, analysis: str,\\n ) -> str:\\n return \\\"projects/{project}/locations/{location}/conversations/{conversation}/analyses/{analysis}\\\".format(\\n project=project,\\n location=location,\\n conversation=conversation,\\n analysis=analysis,\\n )\",\n \"def getFSUserDir(self):\\n if not self.authorised:\\n raise AuthError(401,\\\"I am sorry, but you are not authorised\\\")\\n\\n if self.authJson[\\\"userInfo\\\"] and self.authJson[\\\"userInfo\\\"][\\\"screenName\\\"]:\\n fsDir = self.config.get(\\\"FileMan\\\",\\\"homedir\\\") + self.authJson[\\\"userInfo\\\"][\\\"screenName\\\"]\\n return fsDir\\n else: \\n raise AuthError(500, \\\"Cannot determine the working directory - Liferay did not provide user's screenName\\\")\",\n \"def getUserDir() -> str:\\n\\n if os.name == \\\"nt\\\": # Windows system, try to return documents directory\\n try:\\n import ctypes.wintypes\\n CSIDL_PERSONAL = 5 # Documents\\n SHGFP_TYPE_CURRENT = 0 # Current value\\n\\n buf = ctypes.create_unicode_buffer(ctypes.wintypes.MAX_PATH)\\n ctypes.windll.shell32.SHGetFolderPathW(0, CSIDL_PERSONAL, 0, SHGFP_TYPE_CURRENT, buf)\\n\\n return buf.value\\n except ImportError:\\n pass\\n\\n return os.path.expanduser(\\\"~\\\") # Non-Windows system, return home directory\",\n \"def getRelativeRootExperimentPath(self):\\n return userId + \\\"/\\\" + \\\\\\n self._rootExportPath[self._rootExportPath.rfind(self._properties['export_dir']):]\",\n \"def get_share_path():\\n cwd = os.path.dirname(__file__)\\n share = os.path.join(cwd, '../share')\\n return os.path.abspath(share)\",\n \"def path_to_data():\\n jab = os.expanduser('~/jab')\\n return os.path.join(jab, 'local/login_sums.csv')\",\n \"def user(path = None):\\n if path:\\n return \\\"%s/%s\\\" % (expanduser(\\\"~\\\"), path)\\n else:\\n return expanduser(\\\"~\\\")\",\n \"def shared_area_path() -> str:\\n\\n try:\\n return os.environ[\\\"OITG_SHARED_AREA\\\"]\\n except KeyError:\\n pass\\n\\n if os.name == \\\"nt\\\": # Windows\\n return \\\"Z:\\\\\\\\\\\"\\n if os.name == \\\"unix\\\" or os.name == \\\"posix\\\": # Linux / OSX / ...\\n return os.path.expanduser(\\\"~/steaneShared/\\\")\\n raise Exception(\\\"Unknown OS\\\")\",\n \"def get_user_data_path():\\n current_directory = os.path.dirname(os.path.realpath(__file__))\\n return os.path.join(current_directory, 'emergency_fund_info.json')\",\n \"def get_downloadpath(user_id):\\r\\n path = settings.DOCUMENT_PATH + str(user_id) + '/'\\r\\n if not os.path.isdir(path):\\r\\n os.mkdir(path)\\r\\n return path\",\n \"def getFSUserDir(self):\\n\\n return self.config.get(\\\"FileMan\\\",\\\"homedir\\\") + self.getRole()[\\\"roleName\\\"]\",\n \"def default_output_path():\\n\\n documents = os.path.join(os.path.expanduser('~'))\\n try:\\n documents = _xdg_documents_path()\\n except: pass\\n if platform.system() == 'Windows':\\n try:\\n documents = _win_documents_path()\\n except: pass\\n\\n return os.path.join(documents, 'Topographica')\",\n \"def get_folder(self):\\n return os.path.join(\\n settings.PRIVATE_STORAGE_ROOT, Exam.EXAM_FILES_LOCATION,\\n str(self.unique_id)[0:2])\",\n \"def get_teamocil_dir() -> pathlib.Path:\\n return pathlib.Path(\\\"~/.teamocil/\\\").expanduser()\",\n \"def get_game_dir(self, username=False):\\n if not self.common and not username:\\n raise RuntimeError(\\\"Can't determine this game's directory without username\\\")\\n if self.common:\\n subdir = \\\"common\\\"\\n else:\\n subdir = \\\"username\\\"\\n subsubdir = self.dir\\n if WIN32 or CYGWIN:\\n subsubdir = subsubdir.lower()\\n return os.path.join(subdir, subsubdir)\",\n \"def share_directory(self):\\n # Get the user to share file/folder with.\\n share_user = User.query.filter_by(email = self.email.data).first()\\n if not share_user:\\n return\\n\\n # The source to copy to another user.\\n filename = os.listdir(self.path.data)[int(self.index.data)]\\n src = os.path.join(self.path.data, filename)\\n # Get home path for the user to share folder with.\\n dst = os.path.join(share_user.get_files_path(), filename)\\n # Copy source to destination.\\n copytree(src, dst)\",\n \"def get_base_data_directory(self):\\n user_category = ''\\n directory = ''\\n\\n if self.session_start_date:\\n start_time = self.session_start_date.split(' ')[0] #.replace('-', '')\\n else:\\n # PL. To avoid mixing users directory if they restart the application\\n # after midnight but before 8 AM, the directory date doesn't change:\\n _local_time = time.localtime()\\n if _local_time[3] > 7:\\n start_time = time.strftime(\\\"%Y-%m-%d\\\")\\n else:\\n # substract 8 hourse to current date to get yesterday's date. \\n _local_time = time.gmtime((time.time() - 8*60*60))\\n start_time = time.strftime(\\\"%Y-%m-%d\\\", _local_time)\\n\\n if self.is_inhouse():\\n #directory = os.path.join(self.base_directory, self.endstation_name,\\n # self.get_user_category(), self.get_proposal(),\\n # start_time)\\n directory = os.path.join(self.base_directory, start_time, self.proposal_number, self.get_proposal_number())\\t \\n else:\\n #directory = os.path.join(self.base_directory, self.get_user_category(),\\n # self.get_proposal(), self.endstation_name,\\n # start_time)\\n logging.debug(\\\"SoleilSession self.base_directory %s\\\" % self.base_directory)\\n logging.debug(\\\"SoleilSession start_time %s\\\" % start_time)\\n logging.debug(\\\"SoleilSession self.proposal_number %s\\\" % self.proposal_number)\\n logging.debug(\\\"SoleilSession self.get_proposal_number() %s\\\" % self.get_proposal_number())\\n directory = os.path.join(self.base_directory, start_time, self.get_proposal_number())\\n\\n return directory\",\n \"def user_home_path(self):\\n return path.join(env.user_home, self._user_home_path)\",\n \"def _get_storage_path(self, stream_name:str=None, version:int=None, user_id:str=None):\\n\\n dirpath = self.data_path+\\\"study=\\\"+self.study_name+\\\"/\\\"\\n\\n if stream_name:\\n dirpath += \\\"stream={0}/\\\".format(stream_name)\\n\\n if version:\\n if \\\"stream=\\\" not in dirpath:\\n raise ValueError(\\\"stream_name argument is missing.\\\")\\n else:\\n dirpath += \\\"version={0}/\\\".format(str(version))\\n\\n if user_id:\\n if \\\"stream=\\\" not in dirpath or \\\"version=\\\" not in dirpath:\\n raise ValueError(\\\"stream_name and/or version arguments are missing.\\\")\\n else:\\n dirpath += \\\"user={0}/\\\".format(user_id)\\n\\n return dirpath\",\n \"def get_storage_directory(username=None):\\n\\n return os.path.join(get_home_dir(username), '.cfy-agent')\",\n \"def get_disassembler_user_directory(self):\\n pass\",\n \"def get_home_dir(self, username):\\n user = connection.User.find_one({'email': str(username) })\\n return str(user['_id'])\",\n \"def get_path(self, path):\\n if path.startswith('/') and not path.startswith('~/'):\\n return os.getcwd() + '/' + path\\n else:\\n return path\",\n \"def home_directory(self):\\n out = self._call(\\\"GETHOMEDIRECTORY\\\")\\n return out.json()[\\\"Path\\\"]\",\n \"def getRootDirectory(self):\\n if Globals.WORKFLOWS_BASEDIR[0] == '~':\\n return os.path.expanduser(Globals.WORKFLOWS_BASEDIR)\\n else:\\n return os.path.join('', Globals.WORKFLOWS_BASEDIR)\",\n \"def get_data_dir():\\n return Path(current_app.config[\\\"USER_DIR\\\"]) / \\\"data\\\"\",\n \"def subOfUserFilesDir(subdir: str) -> str:\\n return os.path.join(os.getcwd(), _baseUserFilesDir, subdir)\",\n \"def getPath(self):\\n path = os.path.dirname(os.path.realpath(__file__)) #Finds the path of the application\\n path =(os.path.dirname(os.path.realpath(__file__))+ '\\\\\\\\Enigma Settings') #Adds to the directory to create a folder\\n \\n return path #Returns the folders directory\",\n \"def pathtofolder():\\n return os.getcwd()\",\n \"def user_conf_dir(self):\\n return os.path.join(BaseDirectory.xdg_config_home, \\\"speech-dispatcher\\\")\",\n \"def localpath(self, *args):\\n return os.path.join(os.path.expanduser(self.serverfiles_dir), *args)\",\n \"def personaldir():\\n if platform == 'windows':\\n return os.path.join(os.environ['APPDATA'], 'automaton')\\n else:\\n return os.path.expanduser('~/.automaton/')\",\n \"def _GetOwnersFilePath(path):\\n if _IsWellFormattedFilePath(path):\\n # _SRC is removed because the file system on the machine running the code\\n # may not have a(n) src directory.\\n path_without_src = path[len(SRC):]\\n\\n return os.path.abspath(\\n os.path.join(*(DIR_ABOVE_TOOLS + path_without_src.split(os.sep))))\\n\\n raise Error(\\n 'The given path {} is not well-formatted. Well-formatted paths begin '\\n 'with \\\"src/\\\" and end with \\\"OWNERS\\\"'.format(path))\",\n \"def load_analysis_path():\\n import json\\n import os\\n with open(os.path.join(os.path.dirname(__file__), \\\"analysis_config.json\\\")) as my_file:\\n analysis_paths = json.load(my_file)\\n return analysis_paths\",\n \"def artiq_results_path(experiment: Optional[str] = None) -> str:\\n\\n path = os.path.join(shared_area_path(), \\\"artiqResults\\\")\\n\\n if experiment is None:\\n try:\\n experiment = os.environ[\\\"OITG_EXPERIMENT\\\"]\\n except KeyError:\\n raise Exception(\\n \\\"No experiment supplied, and no OITG_EXPERIMENT environment key\\\")\\n\\n return os.path.join(path, experiment)\",\n \"def get_home_dir(self, username):\\n return self.user_table[username]['home']\",\n \"def get_user_homedir():\\n return os.path.expanduser(\\\"~\\\")\",\n \"def working_directory(self):\\n project_full_path = \\\"/\\\".join(self.file_name.split(\\\"/\\\")[:-1])\\n file_name = self.file_name.split(\\\"/\\\")[-1]\\n if \\\".h5\\\" in file_name:\\n file_name = file_name.split(\\\".h5\\\")[0]\\n file_name += \\\"_hdf5\\\"\\n if self.h5_path[0] == \\\"/\\\":\\n h5_path = self.h5_path[1:]\\n else:\\n h5_path = self.h5_path\\n return posixpath.join(project_full_path, file_name, h5_path)\",\n \"def get_absolute_pathname(self):\\n return os.path.join(settings.PRIVATE_STORAGE_ROOT, self.get_relative_pathname())\",\n \"def _get_project_dir(self):\\n return os.path.expanduser(\\n self.sqlfluff_config.get_section(\\n (self.templater_selector, self.name, \\\"project_dir\\\")\\n )\\n or os.getcwd()\\n )\",\n \"def get_user_data_dir_name(self):\\n return self._user_data_dir.name\",\n \"def output_path():\\n folder = path.join(path.curdir, \\\"stages\\\")\\n folder = path.abspath(folder)\\n return ensure_path(folder)\",\n \"def get_data_folder_path(challenge_short_name):\\n return safe_join(settings.MEDIA_ROOT, challenge_short_name)\",\n \"def work_root(session):\\n return session[\\\"AVALON_WORKDIR\\\"]\",\n \"def profile_directory_path(request, file):\\n return directory_path('profile', file)\",\n \"def outputFilepath(self, filename):\\n return os.path.expanduser('~') + '/' + filename\",\n \"def user_directory_path(instance, filename: str) -> str:\\n\\n # File will be uploaded to MEDIA_ROOT/user_<id>/<filename>\\n return 'user_{0}/{1}'.format(instance.profile.user.pk, filename)\",\n \"def _get_default_path(self):\\n return os.path.join(cfg.DATA_DIR, 'visual_genome')\",\n \"def path_share(self) -> Path:\\n return self.path_supervisor / SHARE_DATA\",\n \"def format_path (in_path):\\n return os.path.realpath(os.path.expanduser(in_path))\",\n \"def get_data_path():\\n\\n # Get pathname absolute or relative.\\n path = os.path.join(\\n os.path.dirname(__file__), __malstor_data_directory__)\\n\\n abs_data_path = os.path.abspath(path)\\n if not os.path.exists(abs_data_path):\\n raise project_path_not_found\\n\\n return abs_data_path\",\n \"def _normalized_path(path):\\n return os.path.abspath(os.path.expanduser(path))\",\n \"def _get_config_path():\\n return os.path.join(os.path.expanduser('~'))\",\n \"def user_data_path(repo_base, repo='', file_name='', file_format=None):\\n if len(repo_base) == 0:\\n raise ValueError('Invalid repo_base.')\\n if len(file_name) > 0 and len(repo) == 0:\\n raise ValueError('Must pass in repo when providing file_name.')\\n parts = [repo_base, repo, file_name]\\n for p in parts:\\n if (not isinstance(p, six.string_types) or p.startswith('.')):\\n raise ValueError('Invalid path component.')\\n path = os.path.abspath(os.path.join(os.sep, 'user_data', *parts))\\n\\n if file_format:\\n if re.match('[^0-9a-zA-Z_-]', file_format):\\n raise ValueError('Invalid file format specified.')\\n path = '%s.%s' % (path, file_format)\\n\\n return path\",\n \"def get_upload_path(instance, filename):\\n \\n userpath = \\\"{name}/{file}\\\".format(name=instance.user.username, file=filename)\\n mainpath = os.path.join(\\\"infocomp\\\",userpath)\\n return mainpath\",\n \"def get_abs_path(self, value):\\n return os.path.abspath(os.path.expanduser(os.path.expandvars(value)))\",\n \"def user_data_dir(data_dir, username):\\n user_data_dir = os.path.join(data_dir, username)\\n if not os.path.exists(user_data_dir):\\n os.mkdir(user_data_dir)\\n return user_data_dir\",\n \"def presentation(self, value):\\r\\n realpath = os.path.expanduser(value)\\r\\n if self.auto_create:\\r\\n if not os.path.exists(realpath):\\r\\n os.makedirs(realpath)\\r\\n return realpath\",\n \"def Directory(self) -> str:\",\n \"def data_abex_results_dir(experiment_name: str) -> Path: # pragma: no cover\\n return experiment_dir(experiment_name) / \\\"Results\\\"\",\n \"def sas_file(self):\\n\\n return os.path.normpath(self.path +'\\\\\\\\'+ cfg_dict['format_pgm'])\",\n \"def get_user_directory(username=None):\\n home = expanduser(\\\"~\\\")\\n\\n yew_dir = os.path.join(home, STORAGE_DIR, username or get_username())\\n if not os.path.exists(yew_dir):\\n os.makedirs(yew_dir)\\n return yew_dir\",\n \"def read_analysis(self,id):\\n raw=requests.get(cfg_dict['analysis'] + id, auth=HttpNtlmAuth(cfg_dict['user'], cfg_dict['pass']))\\n self.analysis=json.loads(raw.text)\\n\\n raw = self.analysis['directory'] + cfg_dict['format_loc']\\n norm = os.path.normpath(raw)\\n if os.path.exists(norm):\\n self.path=norm\",\n \"def dataset_path(cls):\\n basepath = os.path.dirname(__file__)\\n filepath = os.path.abspath(\\n os.path.join(basepath, \\\"..\\\", \\\"datasets\\\", get_env('DATA_FILENAME')))\\n return filepath\",\n \"def get_report_path(self):\\n report_path = os.path.join(logPath, \\\"report.html\\\")\\n return report_path\",\n \"def full_path(path):\\n return os.path.realpath(os.path.expandvars(os.path.expanduser(path)))\",\n \"def GetDataDir(self):\\r\\n \\r\\n sp = wx.StandardPaths.Get()\\r\\n return sp.GetUserDataDir()\",\n \"def _glob_precip_stats_dirpath(reanalysis):\\n fmt = os.path.join( os.path.split( os.path.split( filepath[reanalysis]['path'] )[0] )[0], '????', '??')\\n return fmt.format('PRECTOT')\",\n \"def get_output_path(self):\\n output_path = '%s/%s' % (\\n os.path.expanduser(JOB_OUTPUT_PATH), self.get_unique_name())\\n return output_path\",\n \"def get_user_config_path():\\n\\n return \\\"{}/.dapsenv/dapsenv.conf\\\".format(expanduser(\\\"~\\\"))\",\n \"def user_directory(sub_directory):\\n result = None\\n directory = os.path.join(HOME, sub_directory)\\n if os.path.exists(directory):\\n result = directory\\n return result\",\n \"def get_user_folder_link_xpath():\\n return links['users_folder'].get('folder_xpath')\",\n \"def experiment_dir(experiment_name: str) -> Path: # pragma: no cover\\n return EXPERIMENTS_DIR / experiment_name\",\n \"def localPath(self):\\n return self.home\",\n \"def get_path():\\n\\n output_path = None\\n while output_path is None:\\n print question + \\\"Please enter the directory where you would like the file saved?\\\"\\n output_path = raw_input()\\n if os.path.isdir(os.path.expanduser(output_path)):\\n pass\\n else:\\n os.system('clear')\\n print warn + \\\"%s is not valid, please try again: \\\" % str(output_path)\\n output_path = None\\n return os.path.expanduser(output_path)\",\n \"def homedir():\\n return os.path.expanduser('~')\",\n \"def _get_vispy_app_dir():\\n # Define default user directory\\n user_dir = os.path.expanduser('~')\\n\\n # Get system app data dir\\n path = None\\n if sys.platform.startswith('win'):\\n path1, path2 = os.getenv('LOCALAPPDATA'), os.getenv('APPDATA')\\n path = path1 or path2\\n elif sys.platform.startswith('darwin'):\\n path = os.path.join(user_dir, 'Library', 'Application Support')\\n # On Linux and as fallback\\n if not (path and os.path.isdir(path)):\\n path = user_dir\\n\\n # Maybe we should store things local to the executable (in case of a\\n # portable distro or a frozen application that wants to be portable)\\n prefix = sys.prefix\\n if getattr(sys, 'frozen', None): # See application_dir() function\\n prefix = os.path.abspath(os.path.dirname(sys.path[0]))\\n for reldir in ('settings', '../settings'):\\n localpath = os.path.abspath(os.path.join(prefix, reldir))\\n if os.path.isdir(localpath):\\n try:\\n open(os.path.join(localpath, 'test.write'), 'wb').close()\\n os.remove(os.path.join(localpath, 'test.write'))\\n except IOError:\\n pass # We cannot write in this directory\\n else:\\n path = localpath\\n break\\n\\n # Get path specific for this app\\n appname = '.vispy' if path == user_dir else 'vispy'\\n path = os.path.join(path, appname)\\n return path\",\n \"def path(self):\\n path = os.path.join(self.base_dir, self.store().replace(' ', '_'), self.package_name())\\n return os.path.abspath(path)\",\n \"def workspace_path(self):\\n return self._path_temp\",\n \"def path_extern_supervisor(self) -> PurePath:\\n return PurePath(os.environ[ENV_SUPERVISOR_SHARE])\",\n \"def get_path(user_file:str):\\n\\n path: List[UserMeasure] = []\\n with open(user_file) as f:\\n for line in f.readlines():\\n data = line.split(\\\",\\\")\\n path.append(UserMeasure(\\n data[0], # Timestamp\\n data[1], # LAC\\n data[2], # ID\\n data[3], # Zone\\n ))\\n return path\",\n \"def get_working_dir(self):\\n return self.role.directory\",\n \"def location(self):\\n\\n p = os.path.abspath(__file__)\\n pathSP = os.path.split(p)\\n return pathSP\",\n \"def localdir():\\n root = __file__\\n if os.path.islink(root):\\n root = os.path.realpath(root)\\n directory = os.path.dirname(os.path.abspath(root))\\n return os.path.normpath(os.path.join(directory, \\\"../settings/\\\"))\",\n \"def output_path(self) -> str:\\n if self._output_path is None:\\n if not self._root_folder:\\n self._root_folder = self._env.experiments_folder\\n folder = os.path.join(self._root_folder, self.key)\\n\\n if not os.path.exists(folder):\\n os.makedirs(folder)\\n\\n self._output_path = folder\\n\\n return self._output_path\",\n \"def get_default_data_dir(self):\\n data_dir_path = os.path.join(self.comicsite.short_name,self.folder_prefix,self.cleantitle)\\n return data_dir_path\",\n \"def _get_default_path(self):\\n # return os.path.join(datasets.ROOT_DIR, 'data', 'MSRC21')\\n # set local path\\n return u'/Users/danilonunes/workspace/datasets/msrc21/'\",\n \"def _fixpath(p):\\n return os.path.abspath(os.path.expanduser(p))\",\n \"def pwd_expanduser ( fspath, uid ):\\n if not fspath or fspath[0] != '~':\\n return fspath\\n elif len ( fspath ) < 2:\\n return get_home_dir ( uid )\\n elif fspath[1] == os.sep:\\n return get_home_dir ( uid ) + fspath[1:]\\n else:\\n return fspath\",\n \"def user_plugin_dir() -> str:\\n return os.path.join(user_data_dir(), 'plugins')\",\n \"def get_softfax_output_file_path(request):\\n if request.config.getoption(\\\"--output\\\"):\\n path = os.path.join(ma_misc.get_abs_path(\\\"/results\\\", False), request.config.getoption(\\\"--output\\\"))\\n if not os.path.isdir(path[:path.rfind(\\\"/\\\")]):\\n os.makedirs(path[:path.rfind(\\\"/\\\")])\\n return path\\n else:\\n return os.path.join(pytest.session_result_folder, \\\"performance/sending_fax_result.xls\\\")\",\n \"def assignments_root_path(self):\\n return os.path.join(self.root_path,\\n self.assignments.model.__name__.lower())\",\n \"def fix_path(path):\\n return os.path.abspath(os.path.expanduser(path))\",\n \"def _get_organisms_file_path(self, gene_name, gene_id):\\n return os.path.join(os.getcwd(), \\\"src\\\", \\\"data\\\", \\\"organisms\\\", \\\"{}_{}.txt\\\".format(gene_name, gene_id))\",\n \"def get_score_path(cfg):\\n return os.path.join(\\n get_score_dir(cfg),\\n \\\"ener.csv\\\")\",\n \"def subOfUserConfigFilesDir(subdir: str) -> str:\\n return os.path.join(os.getcwd(), _baseUserConfigFilesDir, subdir)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6710544","0.66245717","0.64282644","0.61189187","0.5994886","0.5977346","0.5951611","0.59258217","0.5919063","0.5871089","0.5855553","0.5822797","0.5740604","0.5706992","0.56850857","0.5682241","0.5660873","0.5612151","0.5608156","0.5605027","0.560351","0.5599671","0.55976796","0.5572536","0.5572053","0.55658996","0.5558749","0.5538831","0.5538418","0.55361325","0.55134887","0.5495109","0.5492528","0.546889","0.5468836","0.54613924","0.5454739","0.5449682","0.54358715","0.54317933","0.5404243","0.54029673","0.5377288","0.5374815","0.5372315","0.5371117","0.53704035","0.5367823","0.5351231","0.534481","0.5337228","0.5332551","0.53239787","0.5308816","0.5286404","0.52862597","0.5269704","0.52566403","0.52532613","0.52476776","0.52416587","0.52261436","0.52209073","0.52190155","0.5210911","0.5209251","0.52067137","0.52065885","0.52064747","0.5205118","0.5195897","0.5191503","0.5183327","0.5179935","0.5175128","0.51716053","0.5171361","0.5171136","0.51568735","0.51509935","0.51495004","0.51481616","0.51448977","0.514441","0.5138244","0.5130007","0.51293945","0.5129009","0.5124722","0.51218593","0.5120487","0.5118856","0.5118308","0.5110514","0.5109511","0.51076853","0.51072913","0.5103638","0.5102426","0.51005954"],"string":"[\n \"0.6710544\",\n \"0.66245717\",\n \"0.64282644\",\n \"0.61189187\",\n \"0.5994886\",\n \"0.5977346\",\n \"0.5951611\",\n \"0.59258217\",\n \"0.5919063\",\n \"0.5871089\",\n \"0.5855553\",\n \"0.5822797\",\n \"0.5740604\",\n \"0.5706992\",\n \"0.56850857\",\n \"0.5682241\",\n \"0.5660873\",\n \"0.5612151\",\n \"0.5608156\",\n \"0.5605027\",\n \"0.560351\",\n \"0.5599671\",\n \"0.55976796\",\n \"0.5572536\",\n \"0.5572053\",\n \"0.55658996\",\n \"0.5558749\",\n \"0.5538831\",\n \"0.5538418\",\n \"0.55361325\",\n \"0.55134887\",\n \"0.5495109\",\n \"0.5492528\",\n \"0.546889\",\n \"0.5468836\",\n \"0.54613924\",\n \"0.5454739\",\n \"0.5449682\",\n \"0.54358715\",\n \"0.54317933\",\n \"0.5404243\",\n \"0.54029673\",\n \"0.5377288\",\n \"0.5374815\",\n \"0.5372315\",\n \"0.5371117\",\n \"0.53704035\",\n \"0.5367823\",\n \"0.5351231\",\n \"0.534481\",\n \"0.5337228\",\n \"0.5332551\",\n \"0.53239787\",\n \"0.5308816\",\n \"0.5286404\",\n \"0.52862597\",\n \"0.5269704\",\n \"0.52566403\",\n \"0.52532613\",\n \"0.52476776\",\n \"0.52416587\",\n \"0.52261436\",\n \"0.52209073\",\n \"0.52190155\",\n \"0.5210911\",\n \"0.5209251\",\n \"0.52067137\",\n \"0.52065885\",\n \"0.52064747\",\n \"0.5205118\",\n \"0.5195897\",\n \"0.5191503\",\n \"0.5183327\",\n \"0.5179935\",\n \"0.5175128\",\n \"0.51716053\",\n \"0.5171361\",\n \"0.5171136\",\n \"0.51568735\",\n \"0.51509935\",\n \"0.51495004\",\n \"0.51481616\",\n \"0.51448977\",\n \"0.514441\",\n \"0.5138244\",\n \"0.5130007\",\n \"0.51293945\",\n \"0.5129009\",\n \"0.5124722\",\n \"0.51218593\",\n \"0.5120487\",\n \"0.5118856\",\n \"0.5118308\",\n \"0.5110514\",\n \"0.5109511\",\n \"0.51076853\",\n \"0.51072913\",\n \"0.5103638\",\n \"0.5102426\",\n \"0.51005954\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.84479433"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4991,"cells":{"query":{"kind":"string","value":"Return the path to the analysis directory for the given day, defaulting to today. The analysis directory is intended to be used as working space for analysing data while it is taken, so that the code can easily be found again later if the data or conclusions reached are reexamined. If the directory does not exist, it is created."},"document":{"kind":"string","value":"def todays_analysis_path(day: Optional[str] = None, user: Optional[str] = None) -> str:\n if day is None:\n day = date.today().isoformat()\n if user is None:\n user = _get_user()\n path = os.path.join(analysis_root_path(user=user), day)\n\n if not os.access(path, os.R_OK):\n # If the dir does not exist, create it\n os.mkdir(path)\n\n return path"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_day_data_path(self, days_ago=0):\n home = os.environ.get('USERPROFILE').replace('\\\\', '/')\n self.data_dir= os.path.join(home, 'TimeData')\n if not os.path.isdir(self.data_dir):\n mkdir(self.data_dir)\n today_filename = os.path.join(\n self.data_dir,\n (datetime.now()-timedelta(days=days_ago)).strftime('%Y-%m-%d.json'))\n return today_filename","def filepath(day, ind):\n if ind!=\"TradeReport\" and ind!=\"OrderDetail\" and ind!=\"OrderHistory\":\n raise NameError(' ind must be either TradeReport or OrderDetail')\n \n elif day<1 or day>31 or type(day)!=int:\n raise TypeError('day must be an integer between 1 and 31')\n \n if day<10:\n day=\"0\"+str(day)\n else:\n day=str(day)\n \n path=\"/data/LSE_DATA/raw/T_\" + ind + \"_\"+ day +\"012008.csv/\" + \"t_\" + ind +\".csv\"\n\n return path","def _get_new_measurement_path() -> pathlib.Path:\n today = strftime(\"%Y%m%d\")\n today_path = DATA_DIR / today\n new_path = get_unique_path(today_path, 'measurement_{:03d}')\n return new_path","def journal_today():\n today = pendulum.today()\n LOG.debug('Today: %s', today)\n\n path = PATH_FORMAT.format(year=today.year, month=today.month, date=today.to_date_string())\n path = pathlib.Path(path).expanduser()\n LOG.debug('Path of today: %s', path)\n\n parent = path.parent\n if not parent.exists():\n parent.mkdir(parents=True, exist_ok=True)\n LOG.debug('Created new path: %s', parent)\n\n if not path.exists():\n shutil.copyfile(TEMPLATE_PATH, path)\n\n return path","def prepare_folder(self) -> str:\n base_folder = self.config['info']['folder']\n today_folder = f'{datetime.today():%Y-%m-%d}'\n folder = os.path.join(base_folder, today_folder)\n if not os.path.isdir(folder):\n os.makedirs(folder)\n return folder","def _set_output_dir(self):\n return os.path.join(self.outputDir,\n datetime.datetime.utcnow().strftime(\"%Y%m%d\"))","def _get_directory(self):\n directory = os.environ.get(\"EEMETER_WEATHER_CACHE_DIRECTORY\",\n os.path.expanduser('~/.eemeter/cache'))\n if not os.path.exists(directory):\n os.makedirs(directory)\n return directory","def day_name():\n file_path = os.path.dirname(__file__)\n day_path = os.path.normpath(os.path.join(file_path, '..'))\n return os.path.basename(day_path)","def create_output_folder(self):\n if not os.path.exists(self.current_path):\n os.mkdir(self.current_path)\n data_dir_by_date = datetime.datetime.now().strftime(\n \"data-%d-%b_%H-%M-%S\")\n self.date_path = os.path.join(self.current_path, data_dir_by_date)\n if not os.path.exists(self.date_path):\n os.mkdir(self.date_path)","def calc_directory(init_dir, dbg=False):\n dt_str, _ = calc_date_time()\n dt_final = os.sep.join([init_dir, dt_str])\n\n dbc.print_helper((\"Dir: \" + dt_final), dbg=dbg)\n return dt_final, dt_str","def get_dag_directory(self) -> str:\n if isinstance(self._dag_directory, Path):\n return str(self._dag_directory.resolve())\n else:\n return str(self._dag_directory)","def _get_default_path(self):\n return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year)","def _get_default_path(self):\n return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year)","def tmpdir(self):\n dir_ = os.path.dirname(self.filename)\n try:\n path = At_code_checker.Dir_Map[dir_.lower()]\n if not os.path.isdir(path):\n create_dir(path)\n except KeyError:\n path = self.get_temp_dir()\n At_code_checker.Dir_Map[dir_.lower()] = path\n finally:\n return path","def _get_new_log_file(self, date, hour):\n\n # Get folder name for this particular date\n dayfolder = str(date)\n\n # Generate new log directory if necessary\n if not os.path.exists('/'.join([self._logpath, dayfolder])):\n self._make_log_dir(dayfolder)\n\n # Return the path to the current log file\n filename = str(hour) + '.txt'\n return '/'.join([self._logpath, dayfolder, filename])","def get_default_data_dir(self):\n data_dir_path = os.path.join(self.comicsite.short_name,self.folder_prefix,self.cleantitle)\n return data_dir_path","def _join_path(\n year: int, day: int, session: str, file_type: Optional[str] = None\n) -> str:\n cache_location = user_cache_dir(appname=\"advent-of-code\")\n cache_file = os.path.join(cache_location, str(session), str(year), str(day))\n if file_type == \"input_file\":\n cache_file = os.path.join(cache_file, \"input.txt\")\n if file_type == \"submission_file\":\n cache_file = os.path.join(cache_file, \"submission.txt\")\n if file_type == \"last_time_file\":\n cache_file = os.path.join(cache_file, \"time.txt\")\n return cache_file","def _get_session_dir(self):\n\n fnd = os.path.join(self.config.capture_dir, self.timestamp.date_string(), self.timestamp.time_string())\n if not os.path.isdir(fnd):\n os.makedirs(fnd)\n\n return fnd","def submission_dir(self):\n submissions_dir = osp.join(self.root, \"submissions\")\n date = '-'.join([\n f'{getattr(datetime.now(), x)}'\n for x in ['year', 'month', 'day']])\n time = '-'.join([\n f'{getattr(datetime.now(), x)}'\n for x in ['hour', 'minute', 'second']])\n submission_name = f'{date}_{time}'\n path = osp.join(submissions_dir, submission_name)\n return path","def experiment_dir(experiment_name: str) -> Path: # pragma: no cover\n return EXPERIMENTS_DIR / experiment_name","def working_directory(self):\n project_full_path = \"/\".join(self.file_name.split(\"/\")[:-1])\n file_name = self.file_name.split(\"/\")[-1]\n if \".h5\" in file_name:\n file_name = file_name.split(\".h5\")[0]\n file_name += \"_hdf5\"\n if self.h5_path[0] == \"/\":\n h5_path = self.h5_path[1:]\n else:\n h5_path = self.h5_path\n return posixpath.join(project_full_path, file_name, h5_path)","def get_run_directory(output_root: Union[str, Path]) -> Path:\n output_root = Path(output_root).resolve()\n launch_time = datetime.datetime.now().strftime(\"%Y_%m_%d\")\n today_runs = [\n int(run_dir.name.split(\".\")[1])\n for run_dir in output_root.iterdir()\n if run_dir.name.startswith(launch_time)\n ]\n run_version = max(today_runs) + 1 if today_runs else 1\n datetime_dir = output_root / f\"{launch_time}.{run_version:0>2}\"\n return datetime_dir","def init_logs_directory(self):\n \n return self.join_and_init_path(self.get_data_general_directory, PATH_FOR_LOGS)","def _default_log_dir():\n config_dir = os.path.abspath(os.path.dirname(self.config_filepath))\n log_dir = os.path.join(config_dir, \"logs\")\n if not os.path.isdir(log_dir):\n os.mkdir(log_dir)\n return log_dir","def get_current_day() -> int:\n return datetime.now().day","def get_first_of_day(self, folder_before=None, day=datetime.today(), filename='Epikurve.csv'):\n folders = os.listdir(self.data_root_path)\n folders.sort(reverse=True)\n reached = folder_before is not None\n __folder_before = str(folder_before).split('/')[-1]\n for folder in folders:\n if reached:\n path_csv = self.data_root_path / folder / filename\n with open(path_csv) as f:\n first = True\n for x in csv.reader(f, delimiter=';'):\n if first:\n first = False\n continue\n ts = datetime.strptime(x[2], '%Y-%m-%dT%H:%M:%S')\n break\n if ts.date() <= day.date():\n return folder\n else:\n if folder == __folder_before:\n reached = True","def make_experiment_directory(path='',config=None,default_dir='_runs'):\n directory = path\n if not path:\n timestamp = datetime.now().strftime('%Y-%m-%dT%H-%M-%S-%f')\n directory = os.path.join(default_dir,timestamp)\n directory = os.path.abspath(directory) \n if os.path.isdir(directory) and not config.override and not config.cloud:\n raise ValueError(\n 'directory already exists, use --override option: %s'\n % directory)\n elif os.path.isdir(directory) and not config.cloud: \n rmtree(directory)\n if not config.cloud: \n os.makedirs(directory)\n if config:\n config.wdir = directory \n return directory","def get_denoiser_data_dir():\r\n dir = get_qiime_project_dir() + \"/qiime/support_files/denoiser/Data/\"\r\n return dir","def simulation_dir(self):\n try:\n return (self.output_directory / self.sim_id).expand()\n except AttributeError:\n return Path()","def get_counts_dir(cls, event_type):\n if 'rna_events_dir' in cls.global_settings:\n return os.path.join(cls.global_settings['rna_events_dir'],\n event_type)\n return None","def create_output_dir(self):\n if self.output_dir is None:\n new_path = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\n self.output_dir = os.path.expanduser(os.path.join(self.input_dir, new_path))\n try:\n os.makedirs(self.output_dir)\n except OSError:\n pass","def generate_subdir(channel, energy=13):\n return os.path.join('%dTeV' % energy, channel, strftime(\"%d_%b_%y\"))","def current_day():\n now = pytz.timezone('America/Los_Angeles').localize(datetime.now())\n return now.strftime('%m/%d')","def _get_station_filename():\n output_dir = os.path.join(output, state, station)\n if not os.path.isdir(output_dir):\n logger.debug(\"Creating directory %s\", output_dir)\n os.makedirs(output_dir)\n return os.path.join(output_dir, \"%s.%s\" % (c_time, format))","def _directory_subdir(hemi, month_num):\n month_dir = '{:02}_{}'.format(month_num, cal.month_abbr[month_num])\n return os.path.join(nt.by_name(hemi)['long_name'],\n 'monthly', month_dir)","def make_save_dir(self, dir_string='', date='auto', date_first=True):\n # Make a new unique identifier when making a new directory for data to be stored\n if self.update_ID:\n self.set_exp_id()\n\n # add the ID to the subdirectory, if prepend_ID is true\n if dir_string is not '' and self.prepend_ID:\n dir_string = rf'{self.exp_ID}_{dir_string}'\n\n # add the date automatically\n if date is 'auto':\n date = datetime.datetime.now().strftime('%Y_%m_%d')\n\n # decide ordering which to put the date\n if date_first:\n save_dir = rf'{self.base_directory}/{date}/{dir_string}'\n else:\n save_dir = rf'{self.base_directory}/{dir_string}/{date}'\n\n # or don't add the date\n if date is None: # if you want to make a directory that doesn't specify date, for saving more general stuff\n save_dir = rf'{self.base_directory}/{dir_string}'\n\n if not os.path.exists(save_dir):\n print(\"Data storage dir does not exist,\"\n \" creating it at {}\".format(save_dir))\n os.makedirs(save_dir)\n\n return save_dir","def get_day_today() -> str:\n day = datetime.now().strftime(\"%w\")\n if day == '0': # Sunday\n return '6'\n elif day == '6': # Saturday\n return '5'\n elif day == '1': # Monday\n return '0'\n elif day == '2': # Tuesday\n return '1'\n elif day == '3': # Wednesday\n return '2'\n elif day == '4': # Thursday\n return '3'\n elif day == '5': # Friday\n return '4'","def currentDay(self):\n day = datetime.datetime.today().day\n return day","def get_directory(self):\n path = os.path.join(settings.SUBMISSION_DIR, \n str(self.course.semester), \n str(self.course.code), \n \"Sec.%d\" % self.course.section,\n self.code)\n return path.replace(\" \", \"_\")","def outdir_str(d):\n f = folder_str(d)\n logs_dir = os.path.join(f, 'logs')\n try:\n if not os.path.exists(logs_dir):\n os.makedirs(logs_dir)\n except OSError:\n raise argparse.ArgumentTypeError('could not create \"%s\" directory' % logs_dir)\n return f","def get_full_dir(self, path):\r\n full_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),\r\n path)\r\n if not os.path.exists(full_dir):\r\n os.makedirs(full_dir)\r\n return full_dir","def create_summary_folder_name():\n dir_str = '' # ADD PATH\n time_stamp_str = time.strftime(\"%a, %d %b %Y %H:%M:%S/\", time.gmtime())\n param_str = ''\n return dir_str + time_stamp_str + param_str","def _create_dir_name(date, dir_structure='ymd', is_exif=True):\n if is_exif:\n date_split = date.split(' ')[0].split(':')\n else:\n date_split = date.split(' ')[0].split('-')\n dir_name = '\\\\'\n if 'y' in dir_structure:\n dir_name += date_split[0] + '\\\\'\n if 'm' in dir_structure:\n dir_name += '_'.join(d for d in date_split[:2]) + '\\\\'\n if 'd' in dir_structure:\n dir_name += '_'.join(d for d in date_split[:3]) + '\\\\'\n return dir_name","def get_log_dir():\n base_dir = os.path.realpath(cfg.CONF.ruiner.log_dir.rstrip('/'))\n return os.path.join(base_dir, test_start_time_tag())","def get_data_dir() -> str:\n os.makedirs(DEFAULT_OUTPUT_DIR, exist_ok=True)\n return DEFAULT_OUTPUT_DIR","def data_loader_new_directory_name(self, working_dir: Path):\n\n wd = SnowfakeryWorkingDirectory(working_dir)\n key = wd.index\n if key not in self.cached_counts:\n self.cached_counts[key] = wd.get_record_counts()\n\n if not self.run_until.sobject_name:\n return working_dir\n\n count = self.cached_counts[key][self.run_until.sobject_name]\n\n path, _ = str(working_dir).rsplit(\"_\", 1)\n new_working_dir = Path(path + \"_\" + str(count))\n return new_working_dir","def get_base_data_directory(self):\n user_category = ''\n directory = ''\n\n if self.session_start_date:\n start_time = self.session_start_date.split(' ')[0] #.replace('-', '')\n else:\n # PL. To avoid mixing users directory if they restart the application\n # after midnight but before 8 AM, the directory date doesn't change:\n _local_time = time.localtime()\n if _local_time[3] > 7:\n start_time = time.strftime(\"%Y-%m-%d\")\n else:\n # substract 8 hourse to current date to get yesterday's date. \n _local_time = time.gmtime((time.time() - 8*60*60))\n start_time = time.strftime(\"%Y-%m-%d\", _local_time)\n\n if self.is_inhouse():\n #directory = os.path.join(self.base_directory, self.endstation_name,\n # self.get_user_category(), self.get_proposal(),\n # start_time)\n directory = os.path.join(self.base_directory, start_time, self.proposal_number, self.get_proposal_number())\t \n else:\n #directory = os.path.join(self.base_directory, self.get_user_category(),\n # self.get_proposal(), self.endstation_name,\n # start_time)\n logging.debug(\"SoleilSession self.base_directory %s\" % self.base_directory)\n logging.debug(\"SoleilSession start_time %s\" % start_time)\n logging.debug(\"SoleilSession self.proposal_number %s\" % self.proposal_number)\n logging.debug(\"SoleilSession self.get_proposal_number() %s\" % self.get_proposal_number())\n directory = os.path.join(self.base_directory, start_time, self.get_proposal_number())\n\n return directory","def get_data_dir(dataset_name: str):\n # Get home directory\n home_dir = os.getenv(\"HOME\")\n\n # Merge home directory with results, project, dataset and directories\n data_dir = os.path.join(\n home_dir, \"data\", \"simple-einet-diff-sampling\", dataset_name\n )\n\n # Create directory if it does not exist\n os.makedirs(data_dir, exist_ok=True)\n return data_dir","def get_dynamic_data(self, today, settings): # DOY=None, year_doy=None\n\n name_key = 'name_fmt'\n loc_key = 'dir_loc'\n dt_key = 'dt_fmt'\n clim_key = 'climatology'\n doy = today.timetuple().tm_yday\n\n print('settings', settings)\n\n if settings[clim_key]:\n # for climatology then we expect a DOY format\n if settings[dt_key] == 'doy':\n dynamic_key = '{:03d}'.format(doy)\n else:\n print('{} is set to climatology but date format from config_dict is {}'.format(settings[name_key],\n settings[dt_key]))\n sys.exit(0)\n elif settings[dt_key] == 'YYYYdoy':\n dynamic_key = '{}{:03d}'.format(today.year, doy)\n else:\n print('Hey user, the format of the dt_fmt configuration you gave: {} is not supported at '\n 'this time'.format(settings[dt_key]))\n sys.exit(0)\n\n fpath = os.path.join(settings[loc_key], settings[name_key].format(dynamic_key))\n return fpath","def get_archive_filename():\r\n today = datetime.date.today()\r\n return str(today)","def file_dir_dir_dir() -> str:\n stack_t = inspect.stack()\n ins = inspect.getframeinfo(stack_t[1][0])\n return os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(ins.filename))))","def _logFile_default(self):\n print \"choosing default log file\"\n return os.path.join(self.rpiADCLogFolder,time.strftime(\"rpiADC-%Y-%m-%d.csv\", self.currentLocalTime))","def get_day():\n return handle_invalid_inputs(question_4, days)","def create_estimation_dir(parent_dir, suffix):\n if parent_dir is None:\n return None\n\n estimation_dir = os.path.join(parent_dir, \"estimations\")\n\n # Make a directory of the estimation with current time\n estimation_dir = os.path.join(estimation_dir, \"\".join([datetime.datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S_%f\"),\n suffix]))\n mkdir_p(estimation_dir)\n\n return estimation_dir","def file_dir_dir() -> str:\n stack_t = inspect.stack()\n ins = inspect.getframeinfo(stack_t[1][0])\n return os.path.dirname(os.path.dirname(os.path.abspath(ins.filename)))","def get_pycqed_appdata_dir():\n if os.name == 'nt':\n path = os.path.expandvars(r'%LOCALAPPDATA%\\pycqed')\n else:\n path = os.path.expanduser('~/.pycqed')\n os.makedirs(path, exist_ok=True)\n return path","def path_helper(location, date, time, slc_dir='slc', data_dir='/media/bup/Data'):\n\n base_folder = data_dir + '/' + location + '/' + date + '/'\n name = date + '_' + time\n def_path = base_folder + slc_dir + '/' + name\n return def_path","def pathtofolder():\n return os.getcwd()","def get_directory(self) -> Path:\n path = Path(str(self.max_nesting_lvl))\n path /= str(self.num_snps)\n path /= self.read_quality\n path /= str(self.coverage)\n path /= str(self.denovo_kmer_size)\n return path","def datafolder_from_timestamp(ts=make_timestamp(),make=False):\n\tfolder_day = ts.split(\"_\")[0]\n\tfolder_month=folder_day[:-2]\n\tfolder_year=folder_month[:-2]\n\t#Yearly folders\n\tyear_folder = data_root_folder+folder_separator+folder_year\n\tif make & (os.listdir(data_root_folder).count(folder_year)==0):\n\t\tos.mkdir(year_folder)\n\t#\n\t#Monthly folders\n\tmonth_folder = year_folder+folder_separator+folder_month\n\tif (os.listdir(year_folder).count(folder_month)==0) & make:\n\t\tos.mkdir(month_folder)\n\t#\n\t#Daily folders\n\tday_folder = month_folder+folder_separator+folder_day\n\tif (os.listdir(month_folder).count(folder_day)==0) & make:\n\t\tos.mkdir(day_folder)\n\n\treturn day_folder+folder_separator","def _create_new_experiment_dir(self):\n ls = os.listdir(self.experiment_dir)\n existing_exp_dirs = [d for d in ls if d.startswith('experiment')]\n if len(existing_exp_dirs) == 0:\n out = 'experiment1'\n else:\n inds = [int(d.lstrip('experiment')) for d in existing_exp_dirs]\n out = 'experiment'+str(max(inds)+1)\n\n self.new_experiment_dir = os.path.join(self.experiment_dir, out)\n os.mkdir(self.new_experiment_dir)\n return None","def create_plot_dir(base_dir: str) -> str:\n time_str = datetime.now().strftime('%Y%b%d-%H%M%S') \n plot_dir = os.path.join(res_dir, 'fig_'+time_str)\n# plot_dir = os.path.join(res_dir, 'plot')\n if not os.path.exists(plot_dir):\n os.makedirs(plot_dir)\n\n return plot_dir","def logdir(self) -> Path:\n assert (\n self._logdir\n ), \"Log provider has not been tied to a SummaryWriter yet\"\n return self._logdir","def prerun(timestamp):\r\n if not os.path.isdir('log'):\r\n os.makedirs('log')\r\n if not os.path.isdir('collected'):\r\n os.makedirs('collected')\r\n if not os.path.isdir('done'):\r\n os.makedirs('done')\r\n time_stamped_folder = os.path.join('collected', timestamp)\r\n if not os.path.isdir(time_stamped_folder):\r\n os.makedirs(time_stamped_folder)\r\n return time_stamped_folder","def path_to_program_dir(self):\n\tpath = sys.argv[0]\n\n\tif not os.path.isdir(path):\n\t path = os.path.dirname(path)\n\n\tif not path: return '.'\n\n\treturn path","def setup_logdir(self, default_logdir: Union[str, Path]) -> Path:\n self._default_logdir = Path(default_logdir)\n\n if self._create_logdir:\n self.logdir_path.mkdir(parents=True, exist_ok=True)\n\n if not self.logdir_path.is_dir():\n raise ValueError(f\"logdir '{self.logdir_path}' must be a directory.\")\n\n return self.logdir_path","def daily_talk(corpus_dir: Pathlike, output_dir: Pathlike, num_jobs: int):\n prepare_daily_talk(corpus_dir, output_dir, num_jobs=num_jobs)","def _get_project_dir(self):\n return os.path.expanduser(\n self.sqlfluff_config.get_section(\n (self.templater_selector, self.name, \"project_dir\")\n )\n or os.getcwd()\n )","def get_data_folder():\n data_folder = './MedData/'\n\n if not os.path.isdir(data_folder):\n os.makedirs(data_folder)\n\n return data_folder","def GetCurrentDir(self) -> str:\n ...","def _infer_output_directory():\n\n # Check if environment variable currently set\n if \"CHIME_DIR\" not in os.environ:\n # Inform user that the environment variable is not currently set\n print(\"CHIME_DIR not set please specify an output directory.\")\n # Check if user wishes to use default path\n use_default = input(\"Use default? [y/n]: \")\n\n if use_default.lower() in [\"y\", \"yes\"]:\n # Use default args to create directory\n _mk_output_dir()\n # Remind user to set environment variable in the future\n print(f\"You should set CHIME_DIR={os.environ['CHIME_DIR']}\")\n\n elif use_default.lower() in [\"n\", \"no\"]:\n # Make output directory using user args\n user_selection = input(\"Specify a path for the output directory: \")\n if user_selection:\n _mk_output_dir(directory_path=user_selection)\n # Remind user to set environment variable\n print(f\"You should set CHIME_DIR={user_selection}.\")\n\n # Recurse if invalid selection\n else:\n _infer_output_directory()\n else:\n # Covers edge-case where user reads documentation\n _mk_output_dir(directory_path=os.environ[\"CHIME_DIR\"])","def test_directory_path_with_calendar():\n downloader = WallpaperDownloader(\"08-2020\")\n directory_path = downloader._get_directory_path(with_calendar=True)\n exist_directory_path = os.path.join(\n downloader.destination_directory_path,\n \"august-2020 (with-calendar)\",\n )\n assert directory_path == exist_directory_path","def _get_default_path(self):\n return os.path.join(action_datasets.ROOT_DIR, 'data', 'Actions')","def _output_log_path(name):\n output = Path(\"../Raw Data/\").joinpath(str(date.today()))\n output.mkdir(parents=True, exist_ok=True)\n return output.joinpath(\"000_logging.hdf5\")","def _find_or_create_dir(dir_name: str) -> str:\r\n # Get the directory of the current file.\r\n parent_dir_path = os.path.dirname(os.path.realpath(__file__))\r\n \r\n # Create a directory if it doesn't exist.\r\n dir_path = os.path.join(parent_dir_path, dir_name)\r\n if not os.path.exists(dir_path):\r\n os.makedirs(dir_path)\r\n\r\n return dir_path","def get_log_directory(self):\n\n return self.__config_parser__.get('SETTINGS', 'LOGFILE_DIRECTORY')","def get_ais_path(self, vessel_type: str, simulation_date: datetime.date) -> Path:\n # adjust date to match AIS file naming convention\n file_date = f\"{self.year}{simulation_date.month:02}01\"\n\n for path in self.paths:\n if vessel_type in path.name and file_date in path.name:\n break\n\n return path","def get_directory() -> str:\n return directory","def _get_filepath(self) -> str:\n return os.path.join(\n os.sep.join(\n [\n self.period.value,\n 'activities',\n f'activities_{self._dt_string}.json'\n ]\n )\n )","def create_path_by_date(dest, dt):\n if not os.path.isdir(dest):\n raise FileNotFoundError(f\"dest {dest} must be valid path\")\n yyyy, mm, dd = dt[0:3]\n yyyy = str(yyyy).zfill(4)\n mm = str(mm).zfill(2)\n dd = str(dd).zfill(2)\n new_dest = os.path.join(dest, yyyy, mm, dd)\n if not os.path.isdir(new_dest):\n os.makedirs(new_dest)\n return new_dest","def get_query_folders(root_dir, today):\n\n pat = r'(\\d*-\\d*-\\d*-\\d\\s\\s)' #regex for the folder of the type that the SERPs are saved in\n query_folder_list = []\n\n for f in os.listdir(root_dir):\n #match = re.search(pat, f) #search for the format in the regex in the folder name\n #if match:\n #dir_name = match.group(1) #extract query term\n # date = match.group(1) #extract date\n\n if os.path.isdir(os.path.join(root_dir, f)) and (f == today):\n query_folder_list.append(os.path.join(root_dir, f))\n else:\n pass\n if not query_folder_list: #if empty, no htmls were collected for that query term for that day\n print(\" does not match a recent dir with same query name in {0}\".format(root_dir))\n\n return query_folder_list","def day(self):\n return 0","def day(self):\n return 0","def default_agasc_dir():\n if 'AGASC_DIR' in os.environ:\n out = Path(os.environ['AGASC_DIR'])\n else:\n out = Path(os.environ['SKA'], 'data', 'agasc')\n return out","def get_today_stat(cls):\n return cls.get_specified_days_stat(0)","def test_directory_path_without_calendar():\n downloader = WallpaperDownloader(\"08-2020\")\n directory_path = downloader._get_directory_path(with_calendar=False)\n exist_directory_path = os.path.join(\n downloader.destination_directory_path,\n \"august-2020 (without-calendar)\",\n )\n assert directory_path == exist_directory_path","def get_fifteen_logfile():\n return \"fifteenStrategy\" + get_day() + \".log\"","def get_dir_path():\n return DIR_PATH","def dailyanalysis(experiment):\n import os\n for fn in os.listdir('/network/aopp/hera/mad/bakerh/fms_tmp/' +\n experiment):\n if fn.find('exe.fms') == -1 and fn.find('mppnccombine.ifc') == -1:\n storedaily('/network/aopp/hera/mad/bakerh/fms_tmp/' + experiment +\n '/' + fn + '/combine/',\n '/network/aopp/hera/mad/bakerh/data/FMS/output/' +\n experiment + '/' + fn + '/history/')\n print('Completed ' + fn)","def output_directory(self):\n if self._output_directory is None:\n cache_filename = self._original_cache\n output_directory = settings.cache_folder / cache_filename\n output_directory.makedirs_p()\n self._output_directory = output_directory.expand()\n return Path(self._output_directory)","def getSteamAppDir(appid: int) -> str:\n\tfor path in libraryFolders():\n\t\ttry:\n\t\t\tlogger.info(f'searching for {appid} in {path}..')\n\t\t\twith open(f'{path}appmanifest_{appid}.acf', 'r') as file:\n\t\t\t\t# found the app!\n\t\t\t\t# get the app's name\n\t\t\t\tinstDir = Property.parse( file, f'appmanifest_{appid}.acf' ).as_dict()[ 'appstate' ][ 'installdir' ]\n\t\t\t\tpath += f'common/{instDir}/'\n\t\t\t\tlogger.info(f'{appid} found! path: {path}')\n\t\t\t\treturn path\n\t\texcept FileNotFoundError:\n\t\t\t# if no, just continue\n\t\t\tcontinue\n\traise RuntimeError(f'No path found for app {appid}!')","def get_log_folder(cls, test_suite_name):\n if not test_suite_name:\n test_suite_name = os.path.splitext(os.path.basename(sys.modules['__main__'].__file__))[0]\n sdk_path = cls.get_sdk_path()\n log_folder = os.path.join(sdk_path, \"TEST_LOGS\",\n test_suite_name +\n time.strftime(\"_%m%d_%H_%M_%S\", time.localtime(LOG_FOLDER_TIMESTAMP)))\n if not os.path.exists(log_folder):\n os.makedirs(log_folder)\n return log_folder","def output_yesterday(max_past_days=10):\n path = None\n\n for yesterday_path in yesterdays(max_past_days=max_past_days):\n if yesterday_path.is_file():\n path = yesterday_path\n LOG.debug('Found last known journal.')\n break\n else:\n raise ValueError('Could not find previous journal in past {0:d} days.'.format(max_past_days))\n\n return path","def default_awg_dir():\n path = os.path.join(get_pycqed_appdata_dir(), 'awg')\n os.makedirs(path, exist_ok=True)\n return path","def create_daily_file(self, output_dir: str,\n day: int, header='Bazin', get_cost=False):\n # Create the output directory if it doesn't exist\n if not os.path.isdir(output_dir):\n os.makedirs(output_dir)\n\n features_file = output_dir + 'day_' + str(day) + '.dat'\n\n if header == 'Bazin':\n # add headers to files\n with open(features_file, 'w') as param_file:\n if get_cost:\n param_file.write(self.bazin_header)\n else:\n self.bazin_header = 'id redshift type code ' + \\\n 'orig_sample queryable ' + \\\n 'last_rmag gA gB gt0 ' + \\\n 'gtfall gtrise rA rB rt0 rtfall rtrise iA ' + \\\n 'iB it0 itfall itrise zA zB zt0 ztfall ztrise\\n'\n param_file.write(self.bazin_header)\n\n else:\n with open(features_file, 'w') as param_file:\n param_file.write(self.header)","def get_current_day():\n current_day = datetime.now().strftime('%A').lower()\n return current_day","def getFSDir(self):\n \n # target dir configuration value\n dirname = os.path.abspath(\n self.config.get(\"FileMan\",\"targetdir\")\n )\n\n # exists or not - create\n if not os.path.isdir(dirname):\n try:\n os.mkdir(dirname)\n except OSError,e:\n raise AuthError(500,\"Could not create target directory [%s]:%s\"%\\\n (dirname, e))\n\n # check directory permission\n if not os.access(dirname, 7):\n raise AuthError(500,\"Write access denied for target directory [%s]\"% (dirname))\n\n return dirname","def _get_default_path(self):\n return os.path.join(cfg.ROOT_DIR, 'data', 'KITTI')","def getDesDir(self):\n if self.desdir == None:\n cwd = os.getcwd()\n self.desdir = os.path.join(cwd, self.args.dest)\n return self.desdir","def daily_avg(dacycle,avg):\n \n if avg not in ['transcom','transcom_extended','olson','olson_extended','country','flux1x1']:\n raise IOError,'Choice of averaging invalid'\n\n analysisdir = dacycle['dir.analysis']\n weekdir = os.path.join(analysisdir , 'data_%s_weekly'%avg)\n daydir = os.path.join(analysisdir , 'data_%s_daily'%avg)\n\n if not os.path.exists(daydir):\n print \"Creating new output directory \" + daydir\n os.makedirs(daydir)\n\n files = os.listdir(weekdir)\n files = [f for f in files if '-' in f and f.endswith('.nc')]\n\n fileinfo = {}\n for filename in files:\n date=datetime.datetime.strptime(filename.split('.')[-2],'%Y-%m-%d')\n fileinfo[filename] = date\n \n dt = dacycle['cyclelength']\n\n for k,v in fileinfo.iteritems():\n cycle_file = os.path.join(weekdir,k)\n for i in range(abs(dt.days)):\n daily_file = os.path.join(daydir,'%s_fluxes.%s.nc'%(avg,(v+datetime.timedelta(days=i)).strftime('%Y-%m-%d')))\n if not os.path.lexists(daily_file):\n os.symlink(cycle_file,daily_file)\n #print daily_file,cycle_file"],"string":"[\n \"def get_day_data_path(self, days_ago=0):\\n home = os.environ.get('USERPROFILE').replace('\\\\\\\\', '/')\\n self.data_dir= os.path.join(home, 'TimeData')\\n if not os.path.isdir(self.data_dir):\\n mkdir(self.data_dir)\\n today_filename = os.path.join(\\n self.data_dir,\\n (datetime.now()-timedelta(days=days_ago)).strftime('%Y-%m-%d.json'))\\n return today_filename\",\n \"def filepath(day, ind):\\n if ind!=\\\"TradeReport\\\" and ind!=\\\"OrderDetail\\\" and ind!=\\\"OrderHistory\\\":\\n raise NameError(' ind must be either TradeReport or OrderDetail')\\n \\n elif day<1 or day>31 or type(day)!=int:\\n raise TypeError('day must be an integer between 1 and 31')\\n \\n if day<10:\\n day=\\\"0\\\"+str(day)\\n else:\\n day=str(day)\\n \\n path=\\\"/data/LSE_DATA/raw/T_\\\" + ind + \\\"_\\\"+ day +\\\"012008.csv/\\\" + \\\"t_\\\" + ind +\\\".csv\\\"\\n\\n return path\",\n \"def _get_new_measurement_path() -> pathlib.Path:\\n today = strftime(\\\"%Y%m%d\\\")\\n today_path = DATA_DIR / today\\n new_path = get_unique_path(today_path, 'measurement_{:03d}')\\n return new_path\",\n \"def journal_today():\\n today = pendulum.today()\\n LOG.debug('Today: %s', today)\\n\\n path = PATH_FORMAT.format(year=today.year, month=today.month, date=today.to_date_string())\\n path = pathlib.Path(path).expanduser()\\n LOG.debug('Path of today: %s', path)\\n\\n parent = path.parent\\n if not parent.exists():\\n parent.mkdir(parents=True, exist_ok=True)\\n LOG.debug('Created new path: %s', parent)\\n\\n if not path.exists():\\n shutil.copyfile(TEMPLATE_PATH, path)\\n\\n return path\",\n \"def prepare_folder(self) -> str:\\n base_folder = self.config['info']['folder']\\n today_folder = f'{datetime.today():%Y-%m-%d}'\\n folder = os.path.join(base_folder, today_folder)\\n if not os.path.isdir(folder):\\n os.makedirs(folder)\\n return folder\",\n \"def _set_output_dir(self):\\n return os.path.join(self.outputDir,\\n datetime.datetime.utcnow().strftime(\\\"%Y%m%d\\\"))\",\n \"def _get_directory(self):\\n directory = os.environ.get(\\\"EEMETER_WEATHER_CACHE_DIRECTORY\\\",\\n os.path.expanduser('~/.eemeter/cache'))\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n return directory\",\n \"def day_name():\\n file_path = os.path.dirname(__file__)\\n day_path = os.path.normpath(os.path.join(file_path, '..'))\\n return os.path.basename(day_path)\",\n \"def create_output_folder(self):\\n if not os.path.exists(self.current_path):\\n os.mkdir(self.current_path)\\n data_dir_by_date = datetime.datetime.now().strftime(\\n \\\"data-%d-%b_%H-%M-%S\\\")\\n self.date_path = os.path.join(self.current_path, data_dir_by_date)\\n if not os.path.exists(self.date_path):\\n os.mkdir(self.date_path)\",\n \"def calc_directory(init_dir, dbg=False):\\n dt_str, _ = calc_date_time()\\n dt_final = os.sep.join([init_dir, dt_str])\\n\\n dbc.print_helper((\\\"Dir: \\\" + dt_final), dbg=dbg)\\n return dt_final, dt_str\",\n \"def get_dag_directory(self) -> str:\\n if isinstance(self._dag_directory, Path):\\n return str(self._dag_directory.resolve())\\n else:\\n return str(self._dag_directory)\",\n \"def _get_default_path(self):\\n return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year)\",\n \"def _get_default_path(self):\\n return os.path.join(cfg.DATA_DIR, 'VOCdevkit' + self._year)\",\n \"def tmpdir(self):\\n dir_ = os.path.dirname(self.filename)\\n try:\\n path = At_code_checker.Dir_Map[dir_.lower()]\\n if not os.path.isdir(path):\\n create_dir(path)\\n except KeyError:\\n path = self.get_temp_dir()\\n At_code_checker.Dir_Map[dir_.lower()] = path\\n finally:\\n return path\",\n \"def _get_new_log_file(self, date, hour):\\n\\n # Get folder name for this particular date\\n dayfolder = str(date)\\n\\n # Generate new log directory if necessary\\n if not os.path.exists('/'.join([self._logpath, dayfolder])):\\n self._make_log_dir(dayfolder)\\n\\n # Return the path to the current log file\\n filename = str(hour) + '.txt'\\n return '/'.join([self._logpath, dayfolder, filename])\",\n \"def get_default_data_dir(self):\\n data_dir_path = os.path.join(self.comicsite.short_name,self.folder_prefix,self.cleantitle)\\n return data_dir_path\",\n \"def _join_path(\\n year: int, day: int, session: str, file_type: Optional[str] = None\\n) -> str:\\n cache_location = user_cache_dir(appname=\\\"advent-of-code\\\")\\n cache_file = os.path.join(cache_location, str(session), str(year), str(day))\\n if file_type == \\\"input_file\\\":\\n cache_file = os.path.join(cache_file, \\\"input.txt\\\")\\n if file_type == \\\"submission_file\\\":\\n cache_file = os.path.join(cache_file, \\\"submission.txt\\\")\\n if file_type == \\\"last_time_file\\\":\\n cache_file = os.path.join(cache_file, \\\"time.txt\\\")\\n return cache_file\",\n \"def _get_session_dir(self):\\n\\n fnd = os.path.join(self.config.capture_dir, self.timestamp.date_string(), self.timestamp.time_string())\\n if not os.path.isdir(fnd):\\n os.makedirs(fnd)\\n\\n return fnd\",\n \"def submission_dir(self):\\n submissions_dir = osp.join(self.root, \\\"submissions\\\")\\n date = '-'.join([\\n f'{getattr(datetime.now(), x)}'\\n for x in ['year', 'month', 'day']])\\n time = '-'.join([\\n f'{getattr(datetime.now(), x)}'\\n for x in ['hour', 'minute', 'second']])\\n submission_name = f'{date}_{time}'\\n path = osp.join(submissions_dir, submission_name)\\n return path\",\n \"def experiment_dir(experiment_name: str) -> Path: # pragma: no cover\\n return EXPERIMENTS_DIR / experiment_name\",\n \"def working_directory(self):\\n project_full_path = \\\"/\\\".join(self.file_name.split(\\\"/\\\")[:-1])\\n file_name = self.file_name.split(\\\"/\\\")[-1]\\n if \\\".h5\\\" in file_name:\\n file_name = file_name.split(\\\".h5\\\")[0]\\n file_name += \\\"_hdf5\\\"\\n if self.h5_path[0] == \\\"/\\\":\\n h5_path = self.h5_path[1:]\\n else:\\n h5_path = self.h5_path\\n return posixpath.join(project_full_path, file_name, h5_path)\",\n \"def get_run_directory(output_root: Union[str, Path]) -> Path:\\n output_root = Path(output_root).resolve()\\n launch_time = datetime.datetime.now().strftime(\\\"%Y_%m_%d\\\")\\n today_runs = [\\n int(run_dir.name.split(\\\".\\\")[1])\\n for run_dir in output_root.iterdir()\\n if run_dir.name.startswith(launch_time)\\n ]\\n run_version = max(today_runs) + 1 if today_runs else 1\\n datetime_dir = output_root / f\\\"{launch_time}.{run_version:0>2}\\\"\\n return datetime_dir\",\n \"def init_logs_directory(self):\\n \\n return self.join_and_init_path(self.get_data_general_directory, PATH_FOR_LOGS)\",\n \"def _default_log_dir():\\n config_dir = os.path.abspath(os.path.dirname(self.config_filepath))\\n log_dir = os.path.join(config_dir, \\\"logs\\\")\\n if not os.path.isdir(log_dir):\\n os.mkdir(log_dir)\\n return log_dir\",\n \"def get_current_day() -> int:\\n return datetime.now().day\",\n \"def get_first_of_day(self, folder_before=None, day=datetime.today(), filename='Epikurve.csv'):\\n folders = os.listdir(self.data_root_path)\\n folders.sort(reverse=True)\\n reached = folder_before is not None\\n __folder_before = str(folder_before).split('/')[-1]\\n for folder in folders:\\n if reached:\\n path_csv = self.data_root_path / folder / filename\\n with open(path_csv) as f:\\n first = True\\n for x in csv.reader(f, delimiter=';'):\\n if first:\\n first = False\\n continue\\n ts = datetime.strptime(x[2], '%Y-%m-%dT%H:%M:%S')\\n break\\n if ts.date() <= day.date():\\n return folder\\n else:\\n if folder == __folder_before:\\n reached = True\",\n \"def make_experiment_directory(path='',config=None,default_dir='_runs'):\\n directory = path\\n if not path:\\n timestamp = datetime.now().strftime('%Y-%m-%dT%H-%M-%S-%f')\\n directory = os.path.join(default_dir,timestamp)\\n directory = os.path.abspath(directory) \\n if os.path.isdir(directory) and not config.override and not config.cloud:\\n raise ValueError(\\n 'directory already exists, use --override option: %s'\\n % directory)\\n elif os.path.isdir(directory) and not config.cloud: \\n rmtree(directory)\\n if not config.cloud: \\n os.makedirs(directory)\\n if config:\\n config.wdir = directory \\n return directory\",\n \"def get_denoiser_data_dir():\\r\\n dir = get_qiime_project_dir() + \\\"/qiime/support_files/denoiser/Data/\\\"\\r\\n return dir\",\n \"def simulation_dir(self):\\n try:\\n return (self.output_directory / self.sim_id).expand()\\n except AttributeError:\\n return Path()\",\n \"def get_counts_dir(cls, event_type):\\n if 'rna_events_dir' in cls.global_settings:\\n return os.path.join(cls.global_settings['rna_events_dir'],\\n event_type)\\n return None\",\n \"def create_output_dir(self):\\n if self.output_dir is None:\\n new_path = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')\\n self.output_dir = os.path.expanduser(os.path.join(self.input_dir, new_path))\\n try:\\n os.makedirs(self.output_dir)\\n except OSError:\\n pass\",\n \"def generate_subdir(channel, energy=13):\\n return os.path.join('%dTeV' % energy, channel, strftime(\\\"%d_%b_%y\\\"))\",\n \"def current_day():\\n now = pytz.timezone('America/Los_Angeles').localize(datetime.now())\\n return now.strftime('%m/%d')\",\n \"def _get_station_filename():\\n output_dir = os.path.join(output, state, station)\\n if not os.path.isdir(output_dir):\\n logger.debug(\\\"Creating directory %s\\\", output_dir)\\n os.makedirs(output_dir)\\n return os.path.join(output_dir, \\\"%s.%s\\\" % (c_time, format))\",\n \"def _directory_subdir(hemi, month_num):\\n month_dir = '{:02}_{}'.format(month_num, cal.month_abbr[month_num])\\n return os.path.join(nt.by_name(hemi)['long_name'],\\n 'monthly', month_dir)\",\n \"def make_save_dir(self, dir_string='', date='auto', date_first=True):\\n # Make a new unique identifier when making a new directory for data to be stored\\n if self.update_ID:\\n self.set_exp_id()\\n\\n # add the ID to the subdirectory, if prepend_ID is true\\n if dir_string is not '' and self.prepend_ID:\\n dir_string = rf'{self.exp_ID}_{dir_string}'\\n\\n # add the date automatically\\n if date is 'auto':\\n date = datetime.datetime.now().strftime('%Y_%m_%d')\\n\\n # decide ordering which to put the date\\n if date_first:\\n save_dir = rf'{self.base_directory}/{date}/{dir_string}'\\n else:\\n save_dir = rf'{self.base_directory}/{dir_string}/{date}'\\n\\n # or don't add the date\\n if date is None: # if you want to make a directory that doesn't specify date, for saving more general stuff\\n save_dir = rf'{self.base_directory}/{dir_string}'\\n\\n if not os.path.exists(save_dir):\\n print(\\\"Data storage dir does not exist,\\\"\\n \\\" creating it at {}\\\".format(save_dir))\\n os.makedirs(save_dir)\\n\\n return save_dir\",\n \"def get_day_today() -> str:\\n day = datetime.now().strftime(\\\"%w\\\")\\n if day == '0': # Sunday\\n return '6'\\n elif day == '6': # Saturday\\n return '5'\\n elif day == '1': # Monday\\n return '0'\\n elif day == '2': # Tuesday\\n return '1'\\n elif day == '3': # Wednesday\\n return '2'\\n elif day == '4': # Thursday\\n return '3'\\n elif day == '5': # Friday\\n return '4'\",\n \"def currentDay(self):\\n day = datetime.datetime.today().day\\n return day\",\n \"def get_directory(self):\\n path = os.path.join(settings.SUBMISSION_DIR, \\n str(self.course.semester), \\n str(self.course.code), \\n \\\"Sec.%d\\\" % self.course.section,\\n self.code)\\n return path.replace(\\\" \\\", \\\"_\\\")\",\n \"def outdir_str(d):\\n f = folder_str(d)\\n logs_dir = os.path.join(f, 'logs')\\n try:\\n if not os.path.exists(logs_dir):\\n os.makedirs(logs_dir)\\n except OSError:\\n raise argparse.ArgumentTypeError('could not create \\\"%s\\\" directory' % logs_dir)\\n return f\",\n \"def get_full_dir(self, path):\\r\\n full_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),\\r\\n path)\\r\\n if not os.path.exists(full_dir):\\r\\n os.makedirs(full_dir)\\r\\n return full_dir\",\n \"def create_summary_folder_name():\\n dir_str = '' # ADD PATH\\n time_stamp_str = time.strftime(\\\"%a, %d %b %Y %H:%M:%S/\\\", time.gmtime())\\n param_str = ''\\n return dir_str + time_stamp_str + param_str\",\n \"def _create_dir_name(date, dir_structure='ymd', is_exif=True):\\n if is_exif:\\n date_split = date.split(' ')[0].split(':')\\n else:\\n date_split = date.split(' ')[0].split('-')\\n dir_name = '\\\\\\\\'\\n if 'y' in dir_structure:\\n dir_name += date_split[0] + '\\\\\\\\'\\n if 'm' in dir_structure:\\n dir_name += '_'.join(d for d in date_split[:2]) + '\\\\\\\\'\\n if 'd' in dir_structure:\\n dir_name += '_'.join(d for d in date_split[:3]) + '\\\\\\\\'\\n return dir_name\",\n \"def get_log_dir():\\n base_dir = os.path.realpath(cfg.CONF.ruiner.log_dir.rstrip('/'))\\n return os.path.join(base_dir, test_start_time_tag())\",\n \"def get_data_dir() -> str:\\n os.makedirs(DEFAULT_OUTPUT_DIR, exist_ok=True)\\n return DEFAULT_OUTPUT_DIR\",\n \"def data_loader_new_directory_name(self, working_dir: Path):\\n\\n wd = SnowfakeryWorkingDirectory(working_dir)\\n key = wd.index\\n if key not in self.cached_counts:\\n self.cached_counts[key] = wd.get_record_counts()\\n\\n if not self.run_until.sobject_name:\\n return working_dir\\n\\n count = self.cached_counts[key][self.run_until.sobject_name]\\n\\n path, _ = str(working_dir).rsplit(\\\"_\\\", 1)\\n new_working_dir = Path(path + \\\"_\\\" + str(count))\\n return new_working_dir\",\n \"def get_base_data_directory(self):\\n user_category = ''\\n directory = ''\\n\\n if self.session_start_date:\\n start_time = self.session_start_date.split(' ')[0] #.replace('-', '')\\n else:\\n # PL. To avoid mixing users directory if they restart the application\\n # after midnight but before 8 AM, the directory date doesn't change:\\n _local_time = time.localtime()\\n if _local_time[3] > 7:\\n start_time = time.strftime(\\\"%Y-%m-%d\\\")\\n else:\\n # substract 8 hourse to current date to get yesterday's date. \\n _local_time = time.gmtime((time.time() - 8*60*60))\\n start_time = time.strftime(\\\"%Y-%m-%d\\\", _local_time)\\n\\n if self.is_inhouse():\\n #directory = os.path.join(self.base_directory, self.endstation_name,\\n # self.get_user_category(), self.get_proposal(),\\n # start_time)\\n directory = os.path.join(self.base_directory, start_time, self.proposal_number, self.get_proposal_number())\\t \\n else:\\n #directory = os.path.join(self.base_directory, self.get_user_category(),\\n # self.get_proposal(), self.endstation_name,\\n # start_time)\\n logging.debug(\\\"SoleilSession self.base_directory %s\\\" % self.base_directory)\\n logging.debug(\\\"SoleilSession start_time %s\\\" % start_time)\\n logging.debug(\\\"SoleilSession self.proposal_number %s\\\" % self.proposal_number)\\n logging.debug(\\\"SoleilSession self.get_proposal_number() %s\\\" % self.get_proposal_number())\\n directory = os.path.join(self.base_directory, start_time, self.get_proposal_number())\\n\\n return directory\",\n \"def get_data_dir(dataset_name: str):\\n # Get home directory\\n home_dir = os.getenv(\\\"HOME\\\")\\n\\n # Merge home directory with results, project, dataset and directories\\n data_dir = os.path.join(\\n home_dir, \\\"data\\\", \\\"simple-einet-diff-sampling\\\", dataset_name\\n )\\n\\n # Create directory if it does not exist\\n os.makedirs(data_dir, exist_ok=True)\\n return data_dir\",\n \"def get_dynamic_data(self, today, settings): # DOY=None, year_doy=None\\n\\n name_key = 'name_fmt'\\n loc_key = 'dir_loc'\\n dt_key = 'dt_fmt'\\n clim_key = 'climatology'\\n doy = today.timetuple().tm_yday\\n\\n print('settings', settings)\\n\\n if settings[clim_key]:\\n # for climatology then we expect a DOY format\\n if settings[dt_key] == 'doy':\\n dynamic_key = '{:03d}'.format(doy)\\n else:\\n print('{} is set to climatology but date format from config_dict is {}'.format(settings[name_key],\\n settings[dt_key]))\\n sys.exit(0)\\n elif settings[dt_key] == 'YYYYdoy':\\n dynamic_key = '{}{:03d}'.format(today.year, doy)\\n else:\\n print('Hey user, the format of the dt_fmt configuration you gave: {} is not supported at '\\n 'this time'.format(settings[dt_key]))\\n sys.exit(0)\\n\\n fpath = os.path.join(settings[loc_key], settings[name_key].format(dynamic_key))\\n return fpath\",\n \"def get_archive_filename():\\r\\n today = datetime.date.today()\\r\\n return str(today)\",\n \"def file_dir_dir_dir() -> str:\\n stack_t = inspect.stack()\\n ins = inspect.getframeinfo(stack_t[1][0])\\n return os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(ins.filename))))\",\n \"def _logFile_default(self):\\n print \\\"choosing default log file\\\"\\n return os.path.join(self.rpiADCLogFolder,time.strftime(\\\"rpiADC-%Y-%m-%d.csv\\\", self.currentLocalTime))\",\n \"def get_day():\\n return handle_invalid_inputs(question_4, days)\",\n \"def create_estimation_dir(parent_dir, suffix):\\n if parent_dir is None:\\n return None\\n\\n estimation_dir = os.path.join(parent_dir, \\\"estimations\\\")\\n\\n # Make a directory of the estimation with current time\\n estimation_dir = os.path.join(estimation_dir, \\\"\\\".join([datetime.datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S_%f\\\"),\\n suffix]))\\n mkdir_p(estimation_dir)\\n\\n return estimation_dir\",\n \"def file_dir_dir() -> str:\\n stack_t = inspect.stack()\\n ins = inspect.getframeinfo(stack_t[1][0])\\n return os.path.dirname(os.path.dirname(os.path.abspath(ins.filename)))\",\n \"def get_pycqed_appdata_dir():\\n if os.name == 'nt':\\n path = os.path.expandvars(r'%LOCALAPPDATA%\\\\pycqed')\\n else:\\n path = os.path.expanduser('~/.pycqed')\\n os.makedirs(path, exist_ok=True)\\n return path\",\n \"def path_helper(location, date, time, slc_dir='slc', data_dir='/media/bup/Data'):\\n\\n base_folder = data_dir + '/' + location + '/' + date + '/'\\n name = date + '_' + time\\n def_path = base_folder + slc_dir + '/' + name\\n return def_path\",\n \"def pathtofolder():\\n return os.getcwd()\",\n \"def get_directory(self) -> Path:\\n path = Path(str(self.max_nesting_lvl))\\n path /= str(self.num_snps)\\n path /= self.read_quality\\n path /= str(self.coverage)\\n path /= str(self.denovo_kmer_size)\\n return path\",\n \"def datafolder_from_timestamp(ts=make_timestamp(),make=False):\\n\\tfolder_day = ts.split(\\\"_\\\")[0]\\n\\tfolder_month=folder_day[:-2]\\n\\tfolder_year=folder_month[:-2]\\n\\t#Yearly folders\\n\\tyear_folder = data_root_folder+folder_separator+folder_year\\n\\tif make & (os.listdir(data_root_folder).count(folder_year)==0):\\n\\t\\tos.mkdir(year_folder)\\n\\t#\\n\\t#Monthly folders\\n\\tmonth_folder = year_folder+folder_separator+folder_month\\n\\tif (os.listdir(year_folder).count(folder_month)==0) & make:\\n\\t\\tos.mkdir(month_folder)\\n\\t#\\n\\t#Daily folders\\n\\tday_folder = month_folder+folder_separator+folder_day\\n\\tif (os.listdir(month_folder).count(folder_day)==0) & make:\\n\\t\\tos.mkdir(day_folder)\\n\\n\\treturn day_folder+folder_separator\",\n \"def _create_new_experiment_dir(self):\\n ls = os.listdir(self.experiment_dir)\\n existing_exp_dirs = [d for d in ls if d.startswith('experiment')]\\n if len(existing_exp_dirs) == 0:\\n out = 'experiment1'\\n else:\\n inds = [int(d.lstrip('experiment')) for d in existing_exp_dirs]\\n out = 'experiment'+str(max(inds)+1)\\n\\n self.new_experiment_dir = os.path.join(self.experiment_dir, out)\\n os.mkdir(self.new_experiment_dir)\\n return None\",\n \"def create_plot_dir(base_dir: str) -> str:\\n time_str = datetime.now().strftime('%Y%b%d-%H%M%S') \\n plot_dir = os.path.join(res_dir, 'fig_'+time_str)\\n# plot_dir = os.path.join(res_dir, 'plot')\\n if not os.path.exists(plot_dir):\\n os.makedirs(plot_dir)\\n\\n return plot_dir\",\n \"def logdir(self) -> Path:\\n assert (\\n self._logdir\\n ), \\\"Log provider has not been tied to a SummaryWriter yet\\\"\\n return self._logdir\",\n \"def prerun(timestamp):\\r\\n if not os.path.isdir('log'):\\r\\n os.makedirs('log')\\r\\n if not os.path.isdir('collected'):\\r\\n os.makedirs('collected')\\r\\n if not os.path.isdir('done'):\\r\\n os.makedirs('done')\\r\\n time_stamped_folder = os.path.join('collected', timestamp)\\r\\n if not os.path.isdir(time_stamped_folder):\\r\\n os.makedirs(time_stamped_folder)\\r\\n return time_stamped_folder\",\n \"def path_to_program_dir(self):\\n\\tpath = sys.argv[0]\\n\\n\\tif not os.path.isdir(path):\\n\\t path = os.path.dirname(path)\\n\\n\\tif not path: return '.'\\n\\n\\treturn path\",\n \"def setup_logdir(self, default_logdir: Union[str, Path]) -> Path:\\n self._default_logdir = Path(default_logdir)\\n\\n if self._create_logdir:\\n self.logdir_path.mkdir(parents=True, exist_ok=True)\\n\\n if not self.logdir_path.is_dir():\\n raise ValueError(f\\\"logdir '{self.logdir_path}' must be a directory.\\\")\\n\\n return self.logdir_path\",\n \"def daily_talk(corpus_dir: Pathlike, output_dir: Pathlike, num_jobs: int):\\n prepare_daily_talk(corpus_dir, output_dir, num_jobs=num_jobs)\",\n \"def _get_project_dir(self):\\n return os.path.expanduser(\\n self.sqlfluff_config.get_section(\\n (self.templater_selector, self.name, \\\"project_dir\\\")\\n )\\n or os.getcwd()\\n )\",\n \"def get_data_folder():\\n data_folder = './MedData/'\\n\\n if not os.path.isdir(data_folder):\\n os.makedirs(data_folder)\\n\\n return data_folder\",\n \"def GetCurrentDir(self) -> str:\\n ...\",\n \"def _infer_output_directory():\\n\\n # Check if environment variable currently set\\n if \\\"CHIME_DIR\\\" not in os.environ:\\n # Inform user that the environment variable is not currently set\\n print(\\\"CHIME_DIR not set please specify an output directory.\\\")\\n # Check if user wishes to use default path\\n use_default = input(\\\"Use default? [y/n]: \\\")\\n\\n if use_default.lower() in [\\\"y\\\", \\\"yes\\\"]:\\n # Use default args to create directory\\n _mk_output_dir()\\n # Remind user to set environment variable in the future\\n print(f\\\"You should set CHIME_DIR={os.environ['CHIME_DIR']}\\\")\\n\\n elif use_default.lower() in [\\\"n\\\", \\\"no\\\"]:\\n # Make output directory using user args\\n user_selection = input(\\\"Specify a path for the output directory: \\\")\\n if user_selection:\\n _mk_output_dir(directory_path=user_selection)\\n # Remind user to set environment variable\\n print(f\\\"You should set CHIME_DIR={user_selection}.\\\")\\n\\n # Recurse if invalid selection\\n else:\\n _infer_output_directory()\\n else:\\n # Covers edge-case where user reads documentation\\n _mk_output_dir(directory_path=os.environ[\\\"CHIME_DIR\\\"])\",\n \"def test_directory_path_with_calendar():\\n downloader = WallpaperDownloader(\\\"08-2020\\\")\\n directory_path = downloader._get_directory_path(with_calendar=True)\\n exist_directory_path = os.path.join(\\n downloader.destination_directory_path,\\n \\\"august-2020 (with-calendar)\\\",\\n )\\n assert directory_path == exist_directory_path\",\n \"def _get_default_path(self):\\n return os.path.join(action_datasets.ROOT_DIR, 'data', 'Actions')\",\n \"def _output_log_path(name):\\n output = Path(\\\"../Raw Data/\\\").joinpath(str(date.today()))\\n output.mkdir(parents=True, exist_ok=True)\\n return output.joinpath(\\\"000_logging.hdf5\\\")\",\n \"def _find_or_create_dir(dir_name: str) -> str:\\r\\n # Get the directory of the current file.\\r\\n parent_dir_path = os.path.dirname(os.path.realpath(__file__))\\r\\n \\r\\n # Create a directory if it doesn't exist.\\r\\n dir_path = os.path.join(parent_dir_path, dir_name)\\r\\n if not os.path.exists(dir_path):\\r\\n os.makedirs(dir_path)\\r\\n\\r\\n return dir_path\",\n \"def get_log_directory(self):\\n\\n return self.__config_parser__.get('SETTINGS', 'LOGFILE_DIRECTORY')\",\n \"def get_ais_path(self, vessel_type: str, simulation_date: datetime.date) -> Path:\\n # adjust date to match AIS file naming convention\\n file_date = f\\\"{self.year}{simulation_date.month:02}01\\\"\\n\\n for path in self.paths:\\n if vessel_type in path.name and file_date in path.name:\\n break\\n\\n return path\",\n \"def get_directory() -> str:\\n return directory\",\n \"def _get_filepath(self) -> str:\\n return os.path.join(\\n os.sep.join(\\n [\\n self.period.value,\\n 'activities',\\n f'activities_{self._dt_string}.json'\\n ]\\n )\\n )\",\n \"def create_path_by_date(dest, dt):\\n if not os.path.isdir(dest):\\n raise FileNotFoundError(f\\\"dest {dest} must be valid path\\\")\\n yyyy, mm, dd = dt[0:3]\\n yyyy = str(yyyy).zfill(4)\\n mm = str(mm).zfill(2)\\n dd = str(dd).zfill(2)\\n new_dest = os.path.join(dest, yyyy, mm, dd)\\n if not os.path.isdir(new_dest):\\n os.makedirs(new_dest)\\n return new_dest\",\n \"def get_query_folders(root_dir, today):\\n\\n pat = r'(\\\\d*-\\\\d*-\\\\d*-\\\\d\\\\s\\\\s)' #regex for the folder of the type that the SERPs are saved in\\n query_folder_list = []\\n\\n for f in os.listdir(root_dir):\\n #match = re.search(pat, f) #search for the format in the regex in the folder name\\n #if match:\\n #dir_name = match.group(1) #extract query term\\n # date = match.group(1) #extract date\\n\\n if os.path.isdir(os.path.join(root_dir, f)) and (f == today):\\n query_folder_list.append(os.path.join(root_dir, f))\\n else:\\n pass\\n if not query_folder_list: #if empty, no htmls were collected for that query term for that day\\n print(\\\" does not match a recent dir with same query name in {0}\\\".format(root_dir))\\n\\n return query_folder_list\",\n \"def day(self):\\n return 0\",\n \"def day(self):\\n return 0\",\n \"def default_agasc_dir():\\n if 'AGASC_DIR' in os.environ:\\n out = Path(os.environ['AGASC_DIR'])\\n else:\\n out = Path(os.environ['SKA'], 'data', 'agasc')\\n return out\",\n \"def get_today_stat(cls):\\n return cls.get_specified_days_stat(0)\",\n \"def test_directory_path_without_calendar():\\n downloader = WallpaperDownloader(\\\"08-2020\\\")\\n directory_path = downloader._get_directory_path(with_calendar=False)\\n exist_directory_path = os.path.join(\\n downloader.destination_directory_path,\\n \\\"august-2020 (without-calendar)\\\",\\n )\\n assert directory_path == exist_directory_path\",\n \"def get_fifteen_logfile():\\n return \\\"fifteenStrategy\\\" + get_day() + \\\".log\\\"\",\n \"def get_dir_path():\\n return DIR_PATH\",\n \"def dailyanalysis(experiment):\\n import os\\n for fn in os.listdir('/network/aopp/hera/mad/bakerh/fms_tmp/' +\\n experiment):\\n if fn.find('exe.fms') == -1 and fn.find('mppnccombine.ifc') == -1:\\n storedaily('/network/aopp/hera/mad/bakerh/fms_tmp/' + experiment +\\n '/' + fn + '/combine/',\\n '/network/aopp/hera/mad/bakerh/data/FMS/output/' +\\n experiment + '/' + fn + '/history/')\\n print('Completed ' + fn)\",\n \"def output_directory(self):\\n if self._output_directory is None:\\n cache_filename = self._original_cache\\n output_directory = settings.cache_folder / cache_filename\\n output_directory.makedirs_p()\\n self._output_directory = output_directory.expand()\\n return Path(self._output_directory)\",\n \"def getSteamAppDir(appid: int) -> str:\\n\\tfor path in libraryFolders():\\n\\t\\ttry:\\n\\t\\t\\tlogger.info(f'searching for {appid} in {path}..')\\n\\t\\t\\twith open(f'{path}appmanifest_{appid}.acf', 'r') as file:\\n\\t\\t\\t\\t# found the app!\\n\\t\\t\\t\\t# get the app's name\\n\\t\\t\\t\\tinstDir = Property.parse( file, f'appmanifest_{appid}.acf' ).as_dict()[ 'appstate' ][ 'installdir' ]\\n\\t\\t\\t\\tpath += f'common/{instDir}/'\\n\\t\\t\\t\\tlogger.info(f'{appid} found! path: {path}')\\n\\t\\t\\t\\treturn path\\n\\t\\texcept FileNotFoundError:\\n\\t\\t\\t# if no, just continue\\n\\t\\t\\tcontinue\\n\\traise RuntimeError(f'No path found for app {appid}!')\",\n \"def get_log_folder(cls, test_suite_name):\\n if not test_suite_name:\\n test_suite_name = os.path.splitext(os.path.basename(sys.modules['__main__'].__file__))[0]\\n sdk_path = cls.get_sdk_path()\\n log_folder = os.path.join(sdk_path, \\\"TEST_LOGS\\\",\\n test_suite_name +\\n time.strftime(\\\"_%m%d_%H_%M_%S\\\", time.localtime(LOG_FOLDER_TIMESTAMP)))\\n if not os.path.exists(log_folder):\\n os.makedirs(log_folder)\\n return log_folder\",\n \"def output_yesterday(max_past_days=10):\\n path = None\\n\\n for yesterday_path in yesterdays(max_past_days=max_past_days):\\n if yesterday_path.is_file():\\n path = yesterday_path\\n LOG.debug('Found last known journal.')\\n break\\n else:\\n raise ValueError('Could not find previous journal in past {0:d} days.'.format(max_past_days))\\n\\n return path\",\n \"def default_awg_dir():\\n path = os.path.join(get_pycqed_appdata_dir(), 'awg')\\n os.makedirs(path, exist_ok=True)\\n return path\",\n \"def create_daily_file(self, output_dir: str,\\n day: int, header='Bazin', get_cost=False):\\n # Create the output directory if it doesn't exist\\n if not os.path.isdir(output_dir):\\n os.makedirs(output_dir)\\n\\n features_file = output_dir + 'day_' + str(day) + '.dat'\\n\\n if header == 'Bazin':\\n # add headers to files\\n with open(features_file, 'w') as param_file:\\n if get_cost:\\n param_file.write(self.bazin_header)\\n else:\\n self.bazin_header = 'id redshift type code ' + \\\\\\n 'orig_sample queryable ' + \\\\\\n 'last_rmag gA gB gt0 ' + \\\\\\n 'gtfall gtrise rA rB rt0 rtfall rtrise iA ' + \\\\\\n 'iB it0 itfall itrise zA zB zt0 ztfall ztrise\\\\n'\\n param_file.write(self.bazin_header)\\n\\n else:\\n with open(features_file, 'w') as param_file:\\n param_file.write(self.header)\",\n \"def get_current_day():\\n current_day = datetime.now().strftime('%A').lower()\\n return current_day\",\n \"def getFSDir(self):\\n \\n # target dir configuration value\\n dirname = os.path.abspath(\\n self.config.get(\\\"FileMan\\\",\\\"targetdir\\\")\\n )\\n\\n # exists or not - create\\n if not os.path.isdir(dirname):\\n try:\\n os.mkdir(dirname)\\n except OSError,e:\\n raise AuthError(500,\\\"Could not create target directory [%s]:%s\\\"%\\\\\\n (dirname, e))\\n\\n # check directory permission\\n if not os.access(dirname, 7):\\n raise AuthError(500,\\\"Write access denied for target directory [%s]\\\"% (dirname))\\n\\n return dirname\",\n \"def _get_default_path(self):\\n return os.path.join(cfg.ROOT_DIR, 'data', 'KITTI')\",\n \"def getDesDir(self):\\n if self.desdir == None:\\n cwd = os.getcwd()\\n self.desdir = os.path.join(cwd, self.args.dest)\\n return self.desdir\",\n \"def daily_avg(dacycle,avg):\\n \\n if avg not in ['transcom','transcom_extended','olson','olson_extended','country','flux1x1']:\\n raise IOError,'Choice of averaging invalid'\\n\\n analysisdir = dacycle['dir.analysis']\\n weekdir = os.path.join(analysisdir , 'data_%s_weekly'%avg)\\n daydir = os.path.join(analysisdir , 'data_%s_daily'%avg)\\n\\n if not os.path.exists(daydir):\\n print \\\"Creating new output directory \\\" + daydir\\n os.makedirs(daydir)\\n\\n files = os.listdir(weekdir)\\n files = [f for f in files if '-' in f and f.endswith('.nc')]\\n\\n fileinfo = {}\\n for filename in files:\\n date=datetime.datetime.strptime(filename.split('.')[-2],'%Y-%m-%d')\\n fileinfo[filename] = date\\n \\n dt = dacycle['cyclelength']\\n\\n for k,v in fileinfo.iteritems():\\n cycle_file = os.path.join(weekdir,k)\\n for i in range(abs(dt.days)):\\n daily_file = os.path.join(daydir,'%s_fluxes.%s.nc'%(avg,(v+datetime.timedelta(days=i)).strftime('%Y-%m-%d')))\\n if not os.path.lexists(daily_file):\\n os.symlink(cycle_file,daily_file)\\n #print daily_file,cycle_file\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62076753","0.5934615","0.59194785","0.58207476","0.57378083","0.5428975","0.54136276","0.53955543","0.5333741","0.5282543","0.5224942","0.519696","0.519696","0.5180282","0.5148305","0.51434815","0.5098279","0.5076191","0.5064754","0.50544584","0.5054282","0.5029764","0.5018956","0.5011002","0.5006264","0.50057095","0.4997772","0.4975446","0.49469227","0.4939346","0.4935224","0.49333403","0.49302968","0.49030307","0.4895709","0.4894794","0.48804787","0.48800293","0.48771587","0.48694927","0.48628643","0.48620668","0.48609427","0.48585984","0.48503974","0.4841737","0.48330587","0.48327696","0.48310566","0.48130727","0.48052126","0.4802002","0.4791357","0.4789006","0.4785057","0.47821715","0.47819987","0.47765183","0.47762534","0.47747698","0.47747266","0.47739616","0.47721207","0.47570148","0.47505736","0.4743814","0.47336915","0.4731094","0.4729925","0.47270882","0.4721733","0.47176045","0.4712256","0.47111875","0.47102994","0.47098446","0.46976063","0.46963957","0.4687641","0.46872878","0.46804866","0.46786895","0.46786895","0.46781185","0.46746048","0.46731442","0.467312","0.4670103","0.46694618","0.4668328","0.46648943","0.4664607","0.46593451","0.4656399","0.4653126","0.4649628","0.46474388","0.46473578","0.46470696","0.46453115"],"string":"[\n \"0.62076753\",\n \"0.5934615\",\n \"0.59194785\",\n \"0.58207476\",\n \"0.57378083\",\n \"0.5428975\",\n \"0.54136276\",\n \"0.53955543\",\n \"0.5333741\",\n \"0.5282543\",\n \"0.5224942\",\n \"0.519696\",\n \"0.519696\",\n \"0.5180282\",\n \"0.5148305\",\n \"0.51434815\",\n \"0.5098279\",\n \"0.5076191\",\n \"0.5064754\",\n \"0.50544584\",\n \"0.5054282\",\n \"0.5029764\",\n \"0.5018956\",\n \"0.5011002\",\n \"0.5006264\",\n \"0.50057095\",\n \"0.4997772\",\n \"0.4975446\",\n \"0.49469227\",\n \"0.4939346\",\n \"0.4935224\",\n \"0.49333403\",\n \"0.49302968\",\n \"0.49030307\",\n \"0.4895709\",\n \"0.4894794\",\n \"0.48804787\",\n \"0.48800293\",\n \"0.48771587\",\n \"0.48694927\",\n \"0.48628643\",\n \"0.48620668\",\n \"0.48609427\",\n \"0.48585984\",\n \"0.48503974\",\n \"0.4841737\",\n \"0.48330587\",\n \"0.48327696\",\n \"0.48310566\",\n \"0.48130727\",\n \"0.48052126\",\n \"0.4802002\",\n \"0.4791357\",\n \"0.4789006\",\n \"0.4785057\",\n \"0.47821715\",\n \"0.47819987\",\n \"0.47765183\",\n \"0.47762534\",\n \"0.47747698\",\n \"0.47747266\",\n \"0.47739616\",\n \"0.47721207\",\n \"0.47570148\",\n \"0.47505736\",\n \"0.4743814\",\n \"0.47336915\",\n \"0.4731094\",\n \"0.4729925\",\n \"0.47270882\",\n \"0.4721733\",\n \"0.47176045\",\n \"0.4712256\",\n \"0.47111875\",\n \"0.47102994\",\n \"0.47098446\",\n \"0.46976063\",\n \"0.46963957\",\n \"0.4687641\",\n \"0.46872878\",\n \"0.46804866\",\n \"0.46786895\",\n \"0.46786895\",\n \"0.46781185\",\n \"0.46746048\",\n \"0.46731442\",\n \"0.467312\",\n \"0.4670103\",\n \"0.46694618\",\n \"0.4668328\",\n \"0.46648943\",\n \"0.4664607\",\n \"0.46593451\",\n \"0.4656399\",\n \"0.4653126\",\n \"0.4649628\",\n \"0.46474388\",\n \"0.46473578\",\n \"0.46470696\",\n \"0.46453115\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7822021"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4992,"cells":{"query":{"kind":"string","value":"Return the path to an experiment's ARTIQ results directory. The standard results path is ``/artiqResults/``."},"document":{"kind":"string","value":"def artiq_results_path(experiment: Optional[str] = None) -> str:\n\n path = os.path.join(shared_area_path(), \"artiqResults\")\n\n if experiment is None:\n try:\n experiment = os.environ[\"OITG_EXPERIMENT\"]\n except KeyError:\n raise Exception(\n \"No experiment supplied, and no OITG_EXPERIMENT environment key\")\n\n return os.path.join(path, experiment)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def data_abex_results_dir(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / \"Results\"","def data_abex_results_iteration_dir(experiment_name: str, iteration: int) -> Path: # pragma: no cover\n return data_abex_results_dir(experiment_name) / iteration_name(iteration)","def _get_results_path(self):\n # if we already have the results path set, please return it\n if self._results_path is not None:\n return self._results_path\n\n self._validate_results_path()\n\n path = self.results_path\n\n if path is None:\n for i in range(1, 10001):\n name = f\"AutoML_{i}\"\n if not os.path.exists(name):\n self.create_dir(name)\n self._results_path = name\n return name\n # If it got here, could not create, raise expection\n raise AutoMLException(\"Cannot create directory for AutoML results\")\n elif os.path.exists(self.results_path) and os.path.exists(\n os.path.join(self.results_path, \"params.json\")\n ): # AutoML already loaded, return path\n self._results_path = path\n return path\n # Dir does not exist, create it\n elif not os.path.exists(path):\n self.create_dir(path)\n self._results_path = path\n return path\n # Dir exists and is empty, use it\n elif os.path.exists(path) and not len(os.listdir(path)):\n self._results_path = path\n return path\n elif os.path.exists(path) and len(os.listdir(path)):\n raise AutoMLException(\n f\"Cannot set directory for AutoML. Directory '{path}' is not empty.\"\n )\n\n raise AutoMLException(\"Cannot set directory for AutoML results\")","def dir_results(assignment, user):\n return os.path.join(repository, assignment, user, 'results')","def experiment_dir(experiment_name: str) -> Path: # pragma: no cover\n return EXPERIMENTS_DIR / experiment_name","def ml_predict_results_path(self) -> str:\n return join(self.machine_learning_path, 'results')","def _get_R_script_dir(self):\r\n qiime_dir = get_qiime_project_dir()\r\n script_dir = join(qiime_dir, 'qiime', 'support_files', 'R')\r\n return script_dir","def _get_R_script_dir(self):\r\n qiime_dir = get_qiime_project_dir()\r\n script_dir = join(qiime_dir, 'qiime', 'support_files', 'R')\r\n return script_dir","def _get_R_script_dir(self):\r\n qiime_dir = get_qiime_project_dir()\r\n script_dir = join(qiime_dir, 'qiime', 'support_files', 'R')\r\n return script_dir","def results_dir(filename = None):\n path = 'results'\n if os.path.isdir(path):\n if not os.access(path, os.R_OK | os.W_OK):\n raise EnvironmentError(\"{0} is not readable or writable\".format(os.path.abspath(path)))\n return os.path.join(path, filename) if filename else path\n os.mkdir(path) # raises if it fails\n return os.path.join(path, filename) if filename else path","def local_results(self):\n\n return self._local_results_path","def get_result_path(self):\n return logPath","def results_directory(self, run_config):\n suite_dir_name = '{}_{}'.format(run_config['test_suite_start_time'],\n run_config['test_id'])\n datetime_str = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')\n test_result_dir = '{}'.format(datetime_str)\n result_dir = os.path.join(self.workspace, 'results', suite_dir_name,\n test_result_dir)\n\n # Creates workspace and default log folder\n if not os.path.exists(result_dir):\n print('Making results directory:{}'.format(result_dir))\n os.makedirs(result_dir)\n\n return result_dir","def get_qiime_temp_dir():\r\n qiime_config = load_qiime_config()\r\n qiime_config_value = qiime_config['temp_dir']\r\n if qiime_config_value is not None:\r\n result = qiime_config_value\r\n else:\r\n result = '/tmp/'\r\n return result","def getRelativeRootExperimentPath(self):\n return userId + \"/\" + \\\n self._rootExportPath[self._rootExportPath.rfind(self._properties['export_dir']):]","def output_path(self) -> str:\n if self._output_path is None:\n if not self._root_folder:\n self._root_folder = self._env.experiments_folder\n folder = os.path.join(self._root_folder, self.key)\n\n if not os.path.exists(folder):\n os.makedirs(folder)\n\n self._output_path = folder\n\n return self._output_path","def results(results_dir):\n\n if not isinstance(results_dir, str):\n raise TypeError(\"results_dir must be a string!\")\n\n if not os.path.exists(results_dir):\n os.makedirs(results_dir)\n\n return results_dir","def get_trial_dir() -> str:\n return logging.root._log_dir # type: ignore","def index_path(self):\n\t\treturn os.path.normpath(self.output + \"/\" + self.resultset_index)","def remote_results(self):\n\n return self._remote_results_path","def config_data_path(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / DATA_CONFIG","def get_archive_file_path(self,results):\n path = os.path.join(self.archive_path,results.version)\n if not os.path.exists(path):\n os.makedirs(path)\n return os.path.join(path,self.get_archive_filename(results))","def get_log_dir():\n base_dir = os.path.realpath(cfg.CONF.ruiner.log_dir.rstrip('/'))\n return os.path.join(base_dir, test_start_time_tag())","def get_qiime_scripts_dir():\r\n script_fp = which('print_qiime_config.py')\r\n\r\n if script_fp is None:\r\n raise ScriptsDirError(\"Could not find the directory containing QIIME \"\r\n \"scripts. QIIME scripts must be accessible via \"\r\n \"the PATH environment variable, and they must \"\r\n \"be executable. Please ensure that you have a \"\r\n \"valid QIIME installation (see the QIIME \"\r\n \"Installation Guide: \"\r\n \"http://qiime.org/install/install.html).\")\r\n\r\n return dirname(script_fp)","def config_abex_path(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / ABEX_CONFIG","def test_get_result_directory(self):\n pass","def get_output_path(self):\n output_path = '%s/%s' % (\n os.path.expanduser(JOB_OUTPUT_PATH), self.get_unique_name())\n return output_path","def _fetch_results_dir(self, backend=None, results_dir=None):\n if backend is None and results_dir is not None:\n return results_dir\n elif backend is not None and results_dir is None:\n return Config().get_results_dir(backend)\n elif backend is None and results_dir is None:\n return self.nominal_results_dir\n else:\n raise ResultsAttributeError('Invalid combination of attributes!')","def _getResultsFileName(self, toilPath):\n return os.path.join(toilPath, \"results.txt\")","def output_path(self):\r\n return '%s/%s' % (os.path.abspath(os.path.dirname(__file__) + 'outputs'),\r\n self.identifier)","def output_dir(self):\n return os.path.join(self._sandbox, 'output' + os.path.sep)","def queries_path(tmpdir):\n return Path(tmpdir) / \"queries\"","def get_output_path():\n return os.getcwd() + \"/output/\"","def sirv_truth_dir(self):\n return op.join(self.root_dir, \"SIRV\")","def data_abex_input_dir(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / DATA_DIR / \"ABEX-Inputs\"","def test_get_qiime_scripts_dir(self):\r\n obs = get_qiime_scripts_dir()\r\n\r\n # We can't do much testing of the observed value, but let's at least\r\n # check that the directory exists.\r\n self.assertTrue(isdir(obs))","def simulation_dir(self):\n try:\n return (self.output_directory / self.sim_id).expand()\n except AttributeError:\n return Path()","def _get_R_script_path(self):\r\n return join(self._get_R_script_dir(), self._r_script)","def _get_R_script_path(self):\r\n return join(self._get_R_script_dir(), self._r_script)","def _get_R_script_path(self):\r\n return join(self._get_R_script_dir(), self._R_script)","def get_benchmark_file_path(cls, results_dir):\n return os.path.join(results_dir, \"benchmarks.json\")","def getTradeOutputDir():\n\tglobal config\n\treturn config['directory']['output']","def data_abex_input_path(experiment_name: str, iteration: int) -> Path: # pragma: no cover\n iteration_csv: str = f\"{iteration_name(iteration)}.csv\"\n return data_abex_input_dir(experiment_name) / iteration_csv","def get_qiime_project_dir():\r\n # Get the full path of util.py\r\n current_file_path = abspath(__file__)\r\n # Get the directory containing util.py\r\n current_dir_path = dirname(current_file_path)\r\n # Return the directory containing the directory containing util.py\r\n return dirname(current_dir_path)","def tempdir(self):\n path = tempfile.gettempdir()\n return os.path.join(path, 'parquet-index-test-' + str(uuid.uuid4()))","def format_result_paths(self):\n if self.file_blacklist == \"ALL\" or self.results_path is None:\n return\n\n # Blacklist the prediction files for any datasets that were not given\n if self.holdout_dataset is None:\n self.file_blacklist.append(\"predictions_holdout\")\n if self.test_dataset is None:\n self.file_blacklist.append(\"predictions_test\")\n\n # Add given `experiment_recorders` to `result_paths`\n for recorder in self.experiment_recorders:\n try:\n recorder, result_path = recorder\n except IndexError:\n raise IndexError(f\"Expected `recorder` to be tuple of (class, str), not {recorder}\")\n\n self.result_paths[recorder.result_path_key] = result_path\n\n # Set full filepath for result files relative to `results_path`, or to None (blacklist)\n for k in self.result_paths.keys():\n if k == \"root\":\n continue\n elif k not in self.file_blacklist:\n # If `k` not in `RESULT_FILE_SUB_DIR_PATHS`, then added via `experiment_recorders`\n self.result_paths[k] = os.path.join(\n self.results_path, RESULT_FILE_SUB_DIR_PATHS.get(k, self.result_paths[k])\n )\n else:\n self.result_paths[k] = None\n # G.debug('Result file \"{}\" has been blacklisted'.format(k))","def get_resultdir(project_obj, result_folder):\n description = project_obj.description.replace(' ', '') # remove any spaces in the project name\n return 'documents/%s/%s/reports/%s' % (str(project_obj.date.date()), description, result_folder)","def get_tranquility_path():\n return os.path.join(get_appdata(), 'CCP\\\\EVE\\\\d_eve_sharedcache_tq_tranquility')","def build_result_folder(timestamp=str(int(time.time()))):\n out_path = os.path.abspath(os.path.join(os.path.curdir, \"runs\", timestamp))\n print(\"Writing to {}\\n\".format(out_path))\n\n data_path = os.path.abspath(os.path.join(out_path, \"data\"))\n evaluation_path = os.path.abspath(os.path.join(out_path, \"evaluation\"))\n\n if not os.path.exists(out_path):\n os.makedirs(data_path)\n os.makedirs(evaluation_path)\n return out_path","def out_path(dataset, work_dir=consts.WORK_DIR):\r\n return join_path(dataset_path(dataset, work_dir), consts.OUTPUT_DIR)","def output_abspath(self):\n return os.path.join(self.queue.data_abspath, self.id)","def get_fuzzer_filestore_path(benchmark_df, fuzzer):\n fuzzer_df = benchmark_df[benchmark_df.fuzzer == fuzzer]\n filestore_path = fuzzer_df.experiment_filestore.unique()[0]\n exp_name = fuzzer_df.experiment.unique()[0]\n return posixpath.join(filestore_path, exp_name)","def get_score_path(cfg):\n return os.path.join(\n get_score_dir(cfg),\n \"ener.csv\")","def questionDirectoryPath(instance, filename):\n return \"phanluot/{}/{}\".format(instance.questionID, filename)","def fasta_dir(self):\n return op.join(self.root_dir, 'fasta')","def ml_evaluate_samples_path(self) -> str:\n return join(self.machine_learning_path, 'evaluate')","def set_results_path(self):\n\n self.results_input.delete(0, END)\n path = set_path()\n self.results_input.insert(0, path)","def assure_experiment_dir(self):\n if not os.path.exists(self.experiment_dir):\n os.makedirs(self.experiment_dir)\n experiment_conf_dir = os.path.join(self.experiment_dir, 'conf')\n if not os.path.exists(experiment_conf_dir):\n os.makedirs(experiment_conf_dir)","def _fetch_run_dir(self, run_id, backend=None, results_dir=None):\n results_dir = self._fetch_results_dir(backend=backend, results_dir=results_dir)\n return os.path.join(results_dir, run_id)","def get_test_data_path():\n return os.path.abspath(os.path.join(os.path.dirname(__file__), \"data\") + os.path.sep)","def create_experiment_path(self, experiment):\n # get communications object as link to microscope hardware\n communicatons_object = self._get_control_software().connection\n experiment_path = communicatons_object.create_experiment_path(\n experiment, self.experiment_folder\n )\n return experiment_path","def default_agasc_dir():\n if 'AGASC_DIR' in os.environ:\n out = Path(os.environ['AGASC_DIR'])\n else:\n out = Path(os.environ['SKA'], 'data', 'agasc')\n return out","def get_results_directory(self, high_level_directory):\n batch_num_dir_name = \"BN{}\".format(self.config_manager.get(ConfigManager.CONFIG_BATCH_MO_NUMBER))\n serial_num_dir_name = \"SN{}-{}\".format(self.config_manager.get(ConfigManager.CONFIG_BATCH_MO_NUMBER),\n self.config_manager.get(ConfigManager.CONFIG_SERIAL_NUMBER))\n results_path = os.path.join(high_level_directory, batch_num_dir_name, serial_num_dir_name)\n os.makedirs(results_path, exist_ok=True, mode=0o660)\n \n return results_path","def tests_path(self, version):\n base = self.version_path(version)\n return osp.normpath(osp.join(base, os.pardir, os.pardir,\n \"share\", \"aster\", \"tests\"))","def resultFilepath(result):\n basePath = RESULTS_PATH+'/'+result['type']+'/'\n if result['type'] == 'artist':\n return basePath + result['name']['ids']['nameId']+'.json'\n else:\n print '__ERR : type de reponse non pris en charge'","def dataset_path(cls):\n basepath = os.path.dirname(__file__)\n filepath = os.path.abspath(\n os.path.join(basepath, \"..\", \"datasets\", get_env('DATA_FILENAME')))\n return filepath","def return_output_path(self):\n # Return the path of the output file\n return os.path.join(self._output_file_location, self._output_filename)","def test_get_qiime_scripts_dir(self):\r\n # get_qiime_scripts_dir will raise an error if it can't find a scripts\r\n # directory.\r\n scripts_dir = get_qiime_scripts_dir()\r\n self.assertTrue(isdir(scripts_dir), \"The QIIME scripts directory does \"\r\n \"not exist: %s\" % scripts_dir)","def output_path():\n folder = path.join(path.curdir, \"stages\")\n folder = path.abspath(folder)\n return ensure_path(folder)","def data_characterization_dir(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / DATA_DIR / \"Characterization\"","def tmp_dir_path(self) -> str:\n return self._tmp_dir_path","def test_data_dir(self):\n return os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')","def _output_path(name):\n output = Path(\"../Analysis Results/\").joinpath(str(date.today()))\n output.mkdir(parents=True, exist_ok=True)\n return output.joinpath(f\"{name}.png\")","def data_characterization_path(experiment_name: str, iteration: int) -> Path: # pragma: no cover\n iteration_csv: str = f\"{iteration_name(iteration)}.csv\"\n return data_characterization_dir(experiment_name) / iteration_csv","def get_axebindir():\n import sys\n\n if 'axesrc' in sys.modules:\n modfile = sys.modules['axesrc'].__file__\n axebindir = os.path.abspath(os.path.join(os.path.dirname(modfile),'../bin/'))\n\n else:\n from pyraf import iraf\n\n # just read all variables\n all_variables = iraf.getVarDict()\n\n arch = all_variables['arch']\n stsdas = all_variables['stsdas']\n # compose the bin directory\n axebindir = os.path.join(stsdas, 'bin'+arch)\n #axe = all_variables['axe']\n #axebindir = all_variables['axebin']\n\n # compose the bin directory\n #axebindir = os.path.join(axe, 'bin')\n\n # return the path\n return axebindir","def get_score_dir(cfg):\n return os.path.join(\n BASE_DATA_DIR,\n \"capt\",\n \"pH\" + str(cfg.pH),\n str(cfg.mut))","def return_testvideo_path():\r\n\tpath = '{}/Downloads/Test_videos/BigBuckBunny.mp4'.format(os.environ['USERPROFILE'] if os.name == 'nt' else os.environ['HOME'])\r\n\treturn os.path.abspath(path)","def test_dir():\n return os.path.abspath(os.path.dirname(__file__))","def get_test_file_path(self):\n xml_file_path_prefix = \"./tests/\"\n return xml_file_path_prefix + self.test_name + \"_data/\"","def form_results():\n folder_name = \"/{0}_{1}_{2}_{3}_{4}_{5}_autoencoder\". \\\n format(datetime.datetime.now(), z_dim, learning_rate, batch_size, n_epochs, beta1)\n tensorboard_path = results_path + folder_name + '/Tensorboard'\n saved_model_path = results_path + folder_name + '/Saved_models/'\n log_path = results_path + folder_name + '/log'\n if not os.path.exists(results_path + folder_name):\n os.mkdir(results_path + folder_name)\n os.mkdir(tensorboard_path)\n os.mkdir(saved_model_path)\n os.mkdir(log_path)\n return tensorboard_path, saved_model_path, log_path","def getJobDir(jobName=None):\n if jobName is None:\n jobName = getJobName()\n return os.path.join(os.environ['LCATR_INSTALL_AREA'], jobName,\n os.environ['LCATR_VERSION'])","def get_report_path(self):\n report_path = os.path.join(logPath, \"report.html\")\n return report_path","def get_lr_root():\n data_acis_lr = Path(\"data\", \"acis\", \"LoadReviews\")\n path = \"/\" / data_acis_lr\n if not path.exists():\n path = os.environ[\"SKA\"] / data_acis_lr\n if not path.exists():\n raise FileNotFoundError(\"no available ACIS load review directory\")\n return path","def rdap_info_cache_directory() -> str:\n current_path = Path(__file__).resolve().parent\n return os.path.join(current_path, 'cache', 'rdap')","def GetResultFile(self):\n\n file_path = self.configfile.map['ResultFilePath']\n\n # Check if several entrie\n if file_path is not None:\n if len(file_path) > 1:\n warning(\n 'Many path for the result file are setted ({}), I will take the first one'\n .format(file_path))\n file_path = file_path[0]\n\n # If the storing file is elsewhere\n if file_path != \"#\":\n sys.path.insert(0, file_path)\n base = DBASE.open('Anna')\n\n if base is not None:\n return base\n else:\n error(\n 'Cannot find Anna file in {}'\n .format(file_path))\n return None\n\n else:\n base = DBASE.open('Anna')\n if base is not None:\n return base\n else:\n error(\n 'Cannot find Anna file in {}'\n .format(file_path))\n return None","def __get_output_dir(self, conf):\n return conf[self.conf_item.get_output_dir()]","def form_results():\n folder_name = \"/{0}_{1}_{2}_{3}_{4}_{5}_Adversarial_Autoencoder\". \\\n format(time.strftime(\"%Y-%m-%d %Hh%Mm%Ss\", time.localtime()), z_dim,\n learning_rate, batch_size, n_epochs, beta1)\n tensorboard_path = results_path + folder_name + '/Tensorboard'\n saved_model_path = results_path + folder_name + '/Saved_models/'\n log_path = results_path + folder_name + '/log'\n if not os.path.exists(results_path + folder_name):\n os.mkdir(results_path + folder_name)\n os.mkdir(tensorboard_path)\n os.mkdir(saved_model_path)\n os.mkdir(log_path)\n return tensorboard_path, saved_model_path, log_path","def res_file_directory(username,code,run_number,results_dir=\"results\",res_file_subdir=os.path.join(\"results\",\"res\")):\n\n group_home = os.environ.get(\"GROUP_HOME\")\n if (type(group_home) is not str):\n raise(ValueError(\"Need to set environment variable GROUP_HOME\"))\n\n res_directory = os.path.join(group_home,results_dir,username,code,\"run\"+run_number)\n if (res_file_subdir is not None):\n res_directory = os.path.join(res_directory,res_file_subdir)\n\n return res_directory","def track_path(self, filename):\n return os.path.join(os.path.dirname(__file__), 'testdata', filename)","def track_path(self, filename):\n return os.path.join(os.path.dirname(__file__), 'testdata', filename)","def track_path(self, filename):\n return os.path.join(os.path.dirname(__file__), 'testdata', filename)","def path(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"path\")","def get_sample_data_dir():\n \n return resource_filename('cdat_lite.test.test_cdms', 'sample_data')","def log_path(self):\n return os.path.join(self._sandbox, 'log')","def get_output_dir(self):\n return self.output_dir","def getLogPath(self, folder):\n path = join(self.folder,'experimentLog_0001.txt')\n for f_path in os.listdir(folder):\n if re.search('experimentLog_[0-9]*.txt', f_path):\n path = join(self.folder,f_path)\n break\n\n return path","def get_output_dir(imdb, net):\n path = os.path.abspath(os.path.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\n if net is None:\n return path\n else:\n return os.path.join(path, net.name)","def output_path(self):\n\n output_path = stringify(self._output_path)\n if output_path is None:\n with current_context() as ctx:\n output_path_relative = stringify(self.output_path_relative)\n if output_path_relative is not None:\n output_path = join_path(ctx.paths.output, output_path_relative)\n else:\n output_path = ctx.current.project.get_output_path(self.executor.output_type)\n return output_path","def _get_project_dir(self):\n return os.path.expanduser(\n self.sqlfluff_config.get_section(\n (self.templater_selector, self.name, \"project_dir\")\n )\n or os.getcwd()\n )","def get_pycqed_appdata_dir():\n if os.name == 'nt':\n path = os.path.expandvars(r'%LOCALAPPDATA%\\pycqed')\n else:\n path = os.path.expanduser('~/.pycqed')\n os.makedirs(path, exist_ok=True)\n return path"],"string":"[\n \"def data_abex_results_dir(experiment_name: str) -> Path: # pragma: no cover\\n return experiment_dir(experiment_name) / \\\"Results\\\"\",\n \"def data_abex_results_iteration_dir(experiment_name: str, iteration: int) -> Path: # pragma: no cover\\n return data_abex_results_dir(experiment_name) / iteration_name(iteration)\",\n \"def _get_results_path(self):\\n # if we already have the results path set, please return it\\n if self._results_path is not None:\\n return self._results_path\\n\\n self._validate_results_path()\\n\\n path = self.results_path\\n\\n if path is None:\\n for i in range(1, 10001):\\n name = f\\\"AutoML_{i}\\\"\\n if not os.path.exists(name):\\n self.create_dir(name)\\n self._results_path = name\\n return name\\n # If it got here, could not create, raise expection\\n raise AutoMLException(\\\"Cannot create directory for AutoML results\\\")\\n elif os.path.exists(self.results_path) and os.path.exists(\\n os.path.join(self.results_path, \\\"params.json\\\")\\n ): # AutoML already loaded, return path\\n self._results_path = path\\n return path\\n # Dir does not exist, create it\\n elif not os.path.exists(path):\\n self.create_dir(path)\\n self._results_path = path\\n return path\\n # Dir exists and is empty, use it\\n elif os.path.exists(path) and not len(os.listdir(path)):\\n self._results_path = path\\n return path\\n elif os.path.exists(path) and len(os.listdir(path)):\\n raise AutoMLException(\\n f\\\"Cannot set directory for AutoML. Directory '{path}' is not empty.\\\"\\n )\\n\\n raise AutoMLException(\\\"Cannot set directory for AutoML results\\\")\",\n \"def dir_results(assignment, user):\\n return os.path.join(repository, assignment, user, 'results')\",\n \"def experiment_dir(experiment_name: str) -> Path: # pragma: no cover\\n return EXPERIMENTS_DIR / experiment_name\",\n \"def ml_predict_results_path(self) -> str:\\n return join(self.machine_learning_path, 'results')\",\n \"def _get_R_script_dir(self):\\r\\n qiime_dir = get_qiime_project_dir()\\r\\n script_dir = join(qiime_dir, 'qiime', 'support_files', 'R')\\r\\n return script_dir\",\n \"def _get_R_script_dir(self):\\r\\n qiime_dir = get_qiime_project_dir()\\r\\n script_dir = join(qiime_dir, 'qiime', 'support_files', 'R')\\r\\n return script_dir\",\n \"def _get_R_script_dir(self):\\r\\n qiime_dir = get_qiime_project_dir()\\r\\n script_dir = join(qiime_dir, 'qiime', 'support_files', 'R')\\r\\n return script_dir\",\n \"def results_dir(filename = None):\\n path = 'results'\\n if os.path.isdir(path):\\n if not os.access(path, os.R_OK | os.W_OK):\\n raise EnvironmentError(\\\"{0} is not readable or writable\\\".format(os.path.abspath(path)))\\n return os.path.join(path, filename) if filename else path\\n os.mkdir(path) # raises if it fails\\n return os.path.join(path, filename) if filename else path\",\n \"def local_results(self):\\n\\n return self._local_results_path\",\n \"def get_result_path(self):\\n return logPath\",\n \"def results_directory(self, run_config):\\n suite_dir_name = '{}_{}'.format(run_config['test_suite_start_time'],\\n run_config['test_id'])\\n datetime_str = datetime.datetime.now().strftime('%Y%m%dT%H%M%S')\\n test_result_dir = '{}'.format(datetime_str)\\n result_dir = os.path.join(self.workspace, 'results', suite_dir_name,\\n test_result_dir)\\n\\n # Creates workspace and default log folder\\n if not os.path.exists(result_dir):\\n print('Making results directory:{}'.format(result_dir))\\n os.makedirs(result_dir)\\n\\n return result_dir\",\n \"def get_qiime_temp_dir():\\r\\n qiime_config = load_qiime_config()\\r\\n qiime_config_value = qiime_config['temp_dir']\\r\\n if qiime_config_value is not None:\\r\\n result = qiime_config_value\\r\\n else:\\r\\n result = '/tmp/'\\r\\n return result\",\n \"def getRelativeRootExperimentPath(self):\\n return userId + \\\"/\\\" + \\\\\\n self._rootExportPath[self._rootExportPath.rfind(self._properties['export_dir']):]\",\n \"def output_path(self) -> str:\\n if self._output_path is None:\\n if not self._root_folder:\\n self._root_folder = self._env.experiments_folder\\n folder = os.path.join(self._root_folder, self.key)\\n\\n if not os.path.exists(folder):\\n os.makedirs(folder)\\n\\n self._output_path = folder\\n\\n return self._output_path\",\n \"def results(results_dir):\\n\\n if not isinstance(results_dir, str):\\n raise TypeError(\\\"results_dir must be a string!\\\")\\n\\n if not os.path.exists(results_dir):\\n os.makedirs(results_dir)\\n\\n return results_dir\",\n \"def get_trial_dir() -> str:\\n return logging.root._log_dir # type: ignore\",\n \"def index_path(self):\\n\\t\\treturn os.path.normpath(self.output + \\\"/\\\" + self.resultset_index)\",\n \"def remote_results(self):\\n\\n return self._remote_results_path\",\n \"def config_data_path(experiment_name: str) -> Path: # pragma: no cover\\n return experiment_dir(experiment_name) / DATA_CONFIG\",\n \"def get_archive_file_path(self,results):\\n path = os.path.join(self.archive_path,results.version)\\n if not os.path.exists(path):\\n os.makedirs(path)\\n return os.path.join(path,self.get_archive_filename(results))\",\n \"def get_log_dir():\\n base_dir = os.path.realpath(cfg.CONF.ruiner.log_dir.rstrip('/'))\\n return os.path.join(base_dir, test_start_time_tag())\",\n \"def get_qiime_scripts_dir():\\r\\n script_fp = which('print_qiime_config.py')\\r\\n\\r\\n if script_fp is None:\\r\\n raise ScriptsDirError(\\\"Could not find the directory containing QIIME \\\"\\r\\n \\\"scripts. QIIME scripts must be accessible via \\\"\\r\\n \\\"the PATH environment variable, and they must \\\"\\r\\n \\\"be executable. Please ensure that you have a \\\"\\r\\n \\\"valid QIIME installation (see the QIIME \\\"\\r\\n \\\"Installation Guide: \\\"\\r\\n \\\"http://qiime.org/install/install.html).\\\")\\r\\n\\r\\n return dirname(script_fp)\",\n \"def config_abex_path(experiment_name: str) -> Path: # pragma: no cover\\n return experiment_dir(experiment_name) / ABEX_CONFIG\",\n \"def test_get_result_directory(self):\\n pass\",\n \"def get_output_path(self):\\n output_path = '%s/%s' % (\\n os.path.expanduser(JOB_OUTPUT_PATH), self.get_unique_name())\\n return output_path\",\n \"def _fetch_results_dir(self, backend=None, results_dir=None):\\n if backend is None and results_dir is not None:\\n return results_dir\\n elif backend is not None and results_dir is None:\\n return Config().get_results_dir(backend)\\n elif backend is None and results_dir is None:\\n return self.nominal_results_dir\\n else:\\n raise ResultsAttributeError('Invalid combination of attributes!')\",\n \"def _getResultsFileName(self, toilPath):\\n return os.path.join(toilPath, \\\"results.txt\\\")\",\n \"def output_path(self):\\r\\n return '%s/%s' % (os.path.abspath(os.path.dirname(__file__) + 'outputs'),\\r\\n self.identifier)\",\n \"def output_dir(self):\\n return os.path.join(self._sandbox, 'output' + os.path.sep)\",\n \"def queries_path(tmpdir):\\n return Path(tmpdir) / \\\"queries\\\"\",\n \"def get_output_path():\\n return os.getcwd() + \\\"/output/\\\"\",\n \"def sirv_truth_dir(self):\\n return op.join(self.root_dir, \\\"SIRV\\\")\",\n \"def data_abex_input_dir(experiment_name: str) -> Path: # pragma: no cover\\n return experiment_dir(experiment_name) / DATA_DIR / \\\"ABEX-Inputs\\\"\",\n \"def test_get_qiime_scripts_dir(self):\\r\\n obs = get_qiime_scripts_dir()\\r\\n\\r\\n # We can't do much testing of the observed value, but let's at least\\r\\n # check that the directory exists.\\r\\n self.assertTrue(isdir(obs))\",\n \"def simulation_dir(self):\\n try:\\n return (self.output_directory / self.sim_id).expand()\\n except AttributeError:\\n return Path()\",\n \"def _get_R_script_path(self):\\r\\n return join(self._get_R_script_dir(), self._r_script)\",\n \"def _get_R_script_path(self):\\r\\n return join(self._get_R_script_dir(), self._r_script)\",\n \"def _get_R_script_path(self):\\r\\n return join(self._get_R_script_dir(), self._R_script)\",\n \"def get_benchmark_file_path(cls, results_dir):\\n return os.path.join(results_dir, \\\"benchmarks.json\\\")\",\n \"def getTradeOutputDir():\\n\\tglobal config\\n\\treturn config['directory']['output']\",\n \"def data_abex_input_path(experiment_name: str, iteration: int) -> Path: # pragma: no cover\\n iteration_csv: str = f\\\"{iteration_name(iteration)}.csv\\\"\\n return data_abex_input_dir(experiment_name) / iteration_csv\",\n \"def get_qiime_project_dir():\\r\\n # Get the full path of util.py\\r\\n current_file_path = abspath(__file__)\\r\\n # Get the directory containing util.py\\r\\n current_dir_path = dirname(current_file_path)\\r\\n # Return the directory containing the directory containing util.py\\r\\n return dirname(current_dir_path)\",\n \"def tempdir(self):\\n path = tempfile.gettempdir()\\n return os.path.join(path, 'parquet-index-test-' + str(uuid.uuid4()))\",\n \"def format_result_paths(self):\\n if self.file_blacklist == \\\"ALL\\\" or self.results_path is None:\\n return\\n\\n # Blacklist the prediction files for any datasets that were not given\\n if self.holdout_dataset is None:\\n self.file_blacklist.append(\\\"predictions_holdout\\\")\\n if self.test_dataset is None:\\n self.file_blacklist.append(\\\"predictions_test\\\")\\n\\n # Add given `experiment_recorders` to `result_paths`\\n for recorder in self.experiment_recorders:\\n try:\\n recorder, result_path = recorder\\n except IndexError:\\n raise IndexError(f\\\"Expected `recorder` to be tuple of (class, str), not {recorder}\\\")\\n\\n self.result_paths[recorder.result_path_key] = result_path\\n\\n # Set full filepath for result files relative to `results_path`, or to None (blacklist)\\n for k in self.result_paths.keys():\\n if k == \\\"root\\\":\\n continue\\n elif k not in self.file_blacklist:\\n # If `k` not in `RESULT_FILE_SUB_DIR_PATHS`, then added via `experiment_recorders`\\n self.result_paths[k] = os.path.join(\\n self.results_path, RESULT_FILE_SUB_DIR_PATHS.get(k, self.result_paths[k])\\n )\\n else:\\n self.result_paths[k] = None\\n # G.debug('Result file \\\"{}\\\" has been blacklisted'.format(k))\",\n \"def get_resultdir(project_obj, result_folder):\\n description = project_obj.description.replace(' ', '') # remove any spaces in the project name\\n return 'documents/%s/%s/reports/%s' % (str(project_obj.date.date()), description, result_folder)\",\n \"def get_tranquility_path():\\n return os.path.join(get_appdata(), 'CCP\\\\\\\\EVE\\\\\\\\d_eve_sharedcache_tq_tranquility')\",\n \"def build_result_folder(timestamp=str(int(time.time()))):\\n out_path = os.path.abspath(os.path.join(os.path.curdir, \\\"runs\\\", timestamp))\\n print(\\\"Writing to {}\\\\n\\\".format(out_path))\\n\\n data_path = os.path.abspath(os.path.join(out_path, \\\"data\\\"))\\n evaluation_path = os.path.abspath(os.path.join(out_path, \\\"evaluation\\\"))\\n\\n if not os.path.exists(out_path):\\n os.makedirs(data_path)\\n os.makedirs(evaluation_path)\\n return out_path\",\n \"def out_path(dataset, work_dir=consts.WORK_DIR):\\r\\n return join_path(dataset_path(dataset, work_dir), consts.OUTPUT_DIR)\",\n \"def output_abspath(self):\\n return os.path.join(self.queue.data_abspath, self.id)\",\n \"def get_fuzzer_filestore_path(benchmark_df, fuzzer):\\n fuzzer_df = benchmark_df[benchmark_df.fuzzer == fuzzer]\\n filestore_path = fuzzer_df.experiment_filestore.unique()[0]\\n exp_name = fuzzer_df.experiment.unique()[0]\\n return posixpath.join(filestore_path, exp_name)\",\n \"def get_score_path(cfg):\\n return os.path.join(\\n get_score_dir(cfg),\\n \\\"ener.csv\\\")\",\n \"def questionDirectoryPath(instance, filename):\\n return \\\"phanluot/{}/{}\\\".format(instance.questionID, filename)\",\n \"def fasta_dir(self):\\n return op.join(self.root_dir, 'fasta')\",\n \"def ml_evaluate_samples_path(self) -> str:\\n return join(self.machine_learning_path, 'evaluate')\",\n \"def set_results_path(self):\\n\\n self.results_input.delete(0, END)\\n path = set_path()\\n self.results_input.insert(0, path)\",\n \"def assure_experiment_dir(self):\\n if not os.path.exists(self.experiment_dir):\\n os.makedirs(self.experiment_dir)\\n experiment_conf_dir = os.path.join(self.experiment_dir, 'conf')\\n if not os.path.exists(experiment_conf_dir):\\n os.makedirs(experiment_conf_dir)\",\n \"def _fetch_run_dir(self, run_id, backend=None, results_dir=None):\\n results_dir = self._fetch_results_dir(backend=backend, results_dir=results_dir)\\n return os.path.join(results_dir, run_id)\",\n \"def get_test_data_path():\\n return os.path.abspath(os.path.join(os.path.dirname(__file__), \\\"data\\\") + os.path.sep)\",\n \"def create_experiment_path(self, experiment):\\n # get communications object as link to microscope hardware\\n communicatons_object = self._get_control_software().connection\\n experiment_path = communicatons_object.create_experiment_path(\\n experiment, self.experiment_folder\\n )\\n return experiment_path\",\n \"def default_agasc_dir():\\n if 'AGASC_DIR' in os.environ:\\n out = Path(os.environ['AGASC_DIR'])\\n else:\\n out = Path(os.environ['SKA'], 'data', 'agasc')\\n return out\",\n \"def get_results_directory(self, high_level_directory):\\n batch_num_dir_name = \\\"BN{}\\\".format(self.config_manager.get(ConfigManager.CONFIG_BATCH_MO_NUMBER))\\n serial_num_dir_name = \\\"SN{}-{}\\\".format(self.config_manager.get(ConfigManager.CONFIG_BATCH_MO_NUMBER),\\n self.config_manager.get(ConfigManager.CONFIG_SERIAL_NUMBER))\\n results_path = os.path.join(high_level_directory, batch_num_dir_name, serial_num_dir_name)\\n os.makedirs(results_path, exist_ok=True, mode=0o660)\\n \\n return results_path\",\n \"def tests_path(self, version):\\n base = self.version_path(version)\\n return osp.normpath(osp.join(base, os.pardir, os.pardir,\\n \\\"share\\\", \\\"aster\\\", \\\"tests\\\"))\",\n \"def resultFilepath(result):\\n basePath = RESULTS_PATH+'/'+result['type']+'/'\\n if result['type'] == 'artist':\\n return basePath + result['name']['ids']['nameId']+'.json'\\n else:\\n print '__ERR : type de reponse non pris en charge'\",\n \"def dataset_path(cls):\\n basepath = os.path.dirname(__file__)\\n filepath = os.path.abspath(\\n os.path.join(basepath, \\\"..\\\", \\\"datasets\\\", get_env('DATA_FILENAME')))\\n return filepath\",\n \"def return_output_path(self):\\n # Return the path of the output file\\n return os.path.join(self._output_file_location, self._output_filename)\",\n \"def test_get_qiime_scripts_dir(self):\\r\\n # get_qiime_scripts_dir will raise an error if it can't find a scripts\\r\\n # directory.\\r\\n scripts_dir = get_qiime_scripts_dir()\\r\\n self.assertTrue(isdir(scripts_dir), \\\"The QIIME scripts directory does \\\"\\r\\n \\\"not exist: %s\\\" % scripts_dir)\",\n \"def output_path():\\n folder = path.join(path.curdir, \\\"stages\\\")\\n folder = path.abspath(folder)\\n return ensure_path(folder)\",\n \"def data_characterization_dir(experiment_name: str) -> Path: # pragma: no cover\\n return experiment_dir(experiment_name) / DATA_DIR / \\\"Characterization\\\"\",\n \"def tmp_dir_path(self) -> str:\\n return self._tmp_dir_path\",\n \"def test_data_dir(self):\\n return os.path.join(os.path.dirname(os.path.abspath(__file__)), 'data')\",\n \"def _output_path(name):\\n output = Path(\\\"../Analysis Results/\\\").joinpath(str(date.today()))\\n output.mkdir(parents=True, exist_ok=True)\\n return output.joinpath(f\\\"{name}.png\\\")\",\n \"def data_characterization_path(experiment_name: str, iteration: int) -> Path: # pragma: no cover\\n iteration_csv: str = f\\\"{iteration_name(iteration)}.csv\\\"\\n return data_characterization_dir(experiment_name) / iteration_csv\",\n \"def get_axebindir():\\n import sys\\n\\n if 'axesrc' in sys.modules:\\n modfile = sys.modules['axesrc'].__file__\\n axebindir = os.path.abspath(os.path.join(os.path.dirname(modfile),'../bin/'))\\n\\n else:\\n from pyraf import iraf\\n\\n # just read all variables\\n all_variables = iraf.getVarDict()\\n\\n arch = all_variables['arch']\\n stsdas = all_variables['stsdas']\\n # compose the bin directory\\n axebindir = os.path.join(stsdas, 'bin'+arch)\\n #axe = all_variables['axe']\\n #axebindir = all_variables['axebin']\\n\\n # compose the bin directory\\n #axebindir = os.path.join(axe, 'bin')\\n\\n # return the path\\n return axebindir\",\n \"def get_score_dir(cfg):\\n return os.path.join(\\n BASE_DATA_DIR,\\n \\\"capt\\\",\\n \\\"pH\\\" + str(cfg.pH),\\n str(cfg.mut))\",\n \"def return_testvideo_path():\\r\\n\\tpath = '{}/Downloads/Test_videos/BigBuckBunny.mp4'.format(os.environ['USERPROFILE'] if os.name == 'nt' else os.environ['HOME'])\\r\\n\\treturn os.path.abspath(path)\",\n \"def test_dir():\\n return os.path.abspath(os.path.dirname(__file__))\",\n \"def get_test_file_path(self):\\n xml_file_path_prefix = \\\"./tests/\\\"\\n return xml_file_path_prefix + self.test_name + \\\"_data/\\\"\",\n \"def form_results():\\n folder_name = \\\"/{0}_{1}_{2}_{3}_{4}_{5}_autoencoder\\\". \\\\\\n format(datetime.datetime.now(), z_dim, learning_rate, batch_size, n_epochs, beta1)\\n tensorboard_path = results_path + folder_name + '/Tensorboard'\\n saved_model_path = results_path + folder_name + '/Saved_models/'\\n log_path = results_path + folder_name + '/log'\\n if not os.path.exists(results_path + folder_name):\\n os.mkdir(results_path + folder_name)\\n os.mkdir(tensorboard_path)\\n os.mkdir(saved_model_path)\\n os.mkdir(log_path)\\n return tensorboard_path, saved_model_path, log_path\",\n \"def getJobDir(jobName=None):\\n if jobName is None:\\n jobName = getJobName()\\n return os.path.join(os.environ['LCATR_INSTALL_AREA'], jobName,\\n os.environ['LCATR_VERSION'])\",\n \"def get_report_path(self):\\n report_path = os.path.join(logPath, \\\"report.html\\\")\\n return report_path\",\n \"def get_lr_root():\\n data_acis_lr = Path(\\\"data\\\", \\\"acis\\\", \\\"LoadReviews\\\")\\n path = \\\"/\\\" / data_acis_lr\\n if not path.exists():\\n path = os.environ[\\\"SKA\\\"] / data_acis_lr\\n if not path.exists():\\n raise FileNotFoundError(\\\"no available ACIS load review directory\\\")\\n return path\",\n \"def rdap_info_cache_directory() -> str:\\n current_path = Path(__file__).resolve().parent\\n return os.path.join(current_path, 'cache', 'rdap')\",\n \"def GetResultFile(self):\\n\\n file_path = self.configfile.map['ResultFilePath']\\n\\n # Check if several entrie\\n if file_path is not None:\\n if len(file_path) > 1:\\n warning(\\n 'Many path for the result file are setted ({}), I will take the first one'\\n .format(file_path))\\n file_path = file_path[0]\\n\\n # If the storing file is elsewhere\\n if file_path != \\\"#\\\":\\n sys.path.insert(0, file_path)\\n base = DBASE.open('Anna')\\n\\n if base is not None:\\n return base\\n else:\\n error(\\n 'Cannot find Anna file in {}'\\n .format(file_path))\\n return None\\n\\n else:\\n base = DBASE.open('Anna')\\n if base is not None:\\n return base\\n else:\\n error(\\n 'Cannot find Anna file in {}'\\n .format(file_path))\\n return None\",\n \"def __get_output_dir(self, conf):\\n return conf[self.conf_item.get_output_dir()]\",\n \"def form_results():\\n folder_name = \\\"/{0}_{1}_{2}_{3}_{4}_{5}_Adversarial_Autoencoder\\\". \\\\\\n format(time.strftime(\\\"%Y-%m-%d %Hh%Mm%Ss\\\", time.localtime()), z_dim,\\n learning_rate, batch_size, n_epochs, beta1)\\n tensorboard_path = results_path + folder_name + '/Tensorboard'\\n saved_model_path = results_path + folder_name + '/Saved_models/'\\n log_path = results_path + folder_name + '/log'\\n if not os.path.exists(results_path + folder_name):\\n os.mkdir(results_path + folder_name)\\n os.mkdir(tensorboard_path)\\n os.mkdir(saved_model_path)\\n os.mkdir(log_path)\\n return tensorboard_path, saved_model_path, log_path\",\n \"def res_file_directory(username,code,run_number,results_dir=\\\"results\\\",res_file_subdir=os.path.join(\\\"results\\\",\\\"res\\\")):\\n\\n group_home = os.environ.get(\\\"GROUP_HOME\\\")\\n if (type(group_home) is not str):\\n raise(ValueError(\\\"Need to set environment variable GROUP_HOME\\\"))\\n\\n res_directory = os.path.join(group_home,results_dir,username,code,\\\"run\\\"+run_number)\\n if (res_file_subdir is not None):\\n res_directory = os.path.join(res_directory,res_file_subdir)\\n\\n return res_directory\",\n \"def track_path(self, filename):\\n return os.path.join(os.path.dirname(__file__), 'testdata', filename)\",\n \"def track_path(self, filename):\\n return os.path.join(os.path.dirname(__file__), 'testdata', filename)\",\n \"def track_path(self, filename):\\n return os.path.join(os.path.dirname(__file__), 'testdata', filename)\",\n \"def path(self) -> pulumi.Output[str]:\\n return pulumi.get(self, \\\"path\\\")\",\n \"def get_sample_data_dir():\\n \\n return resource_filename('cdat_lite.test.test_cdms', 'sample_data')\",\n \"def log_path(self):\\n return os.path.join(self._sandbox, 'log')\",\n \"def get_output_dir(self):\\n return self.output_dir\",\n \"def getLogPath(self, folder):\\n path = join(self.folder,'experimentLog_0001.txt')\\n for f_path in os.listdir(folder):\\n if re.search('experimentLog_[0-9]*.txt', f_path):\\n path = join(self.folder,f_path)\\n break\\n\\n return path\",\n \"def get_output_dir(imdb, net):\\n path = os.path.abspath(os.path.join(__C.ROOT_DIR, 'output', __C.EXP_DIR, imdb.name))\\n if net is None:\\n return path\\n else:\\n return os.path.join(path, net.name)\",\n \"def output_path(self):\\n\\n output_path = stringify(self._output_path)\\n if output_path is None:\\n with current_context() as ctx:\\n output_path_relative = stringify(self.output_path_relative)\\n if output_path_relative is not None:\\n output_path = join_path(ctx.paths.output, output_path_relative)\\n else:\\n output_path = ctx.current.project.get_output_path(self.executor.output_type)\\n return output_path\",\n \"def _get_project_dir(self):\\n return os.path.expanduser(\\n self.sqlfluff_config.get_section(\\n (self.templater_selector, self.name, \\\"project_dir\\\")\\n )\\n or os.getcwd()\\n )\",\n \"def get_pycqed_appdata_dir():\\n if os.name == 'nt':\\n path = os.path.expandvars(r'%LOCALAPPDATA%\\\\pycqed')\\n else:\\n path = os.path.expanduser('~/.pycqed')\\n os.makedirs(path, exist_ok=True)\\n return path\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.80512667","0.7191955","0.68996114","0.6845597","0.68339694","0.66065645","0.65667313","0.65667313","0.65667313","0.65351224","0.63939637","0.6320295","0.61587936","0.6123075","0.60877836","0.60146594","0.5972927","0.5961885","0.5882054","0.58809346","0.5845682","0.5831248","0.5815053","0.57882553","0.57843715","0.574206","0.5716158","0.5699615","0.5683362","0.5673101","0.56584567","0.5619277","0.56152874","0.559876","0.55766433","0.5568953","0.5566138","0.5544834","0.5544834","0.55414873","0.55372864","0.5533345","0.55184895","0.5497518","0.5493019","0.5490097","0.5483502","0.548034","0.5464465","0.5458607","0.54467773","0.54435253","0.5434052","0.542069","0.5416532","0.541214","0.5388817","0.5386616","0.537702","0.5369012","0.536298","0.534746","0.53414756","0.53385115","0.5332305","0.5331681","0.53314906","0.5325333","0.53203815","0.53184193","0.5310373","0.53062963","0.5300834","0.5296873","0.52886343","0.5284749","0.5268316","0.5265501","0.5263195","0.5262423","0.526051","0.52584326","0.5256575","0.5254926","0.5252969","0.52506286","0.5249883","0.5246273","0.522035","0.522035","0.522035","0.5219927","0.5212773","0.5211824","0.5210138","0.5207362","0.5201455","0.5187998","0.5174206","0.5168886"],"string":"[\n \"0.80512667\",\n \"0.7191955\",\n \"0.68996114\",\n \"0.6845597\",\n \"0.68339694\",\n \"0.66065645\",\n \"0.65667313\",\n \"0.65667313\",\n \"0.65667313\",\n \"0.65351224\",\n \"0.63939637\",\n \"0.6320295\",\n \"0.61587936\",\n \"0.6123075\",\n \"0.60877836\",\n \"0.60146594\",\n \"0.5972927\",\n \"0.5961885\",\n \"0.5882054\",\n \"0.58809346\",\n \"0.5845682\",\n \"0.5831248\",\n \"0.5815053\",\n \"0.57882553\",\n \"0.57843715\",\n \"0.574206\",\n \"0.5716158\",\n \"0.5699615\",\n \"0.5683362\",\n \"0.5673101\",\n \"0.56584567\",\n \"0.5619277\",\n \"0.56152874\",\n \"0.559876\",\n \"0.55766433\",\n \"0.5568953\",\n \"0.5566138\",\n \"0.5544834\",\n \"0.5544834\",\n \"0.55414873\",\n \"0.55372864\",\n \"0.5533345\",\n \"0.55184895\",\n \"0.5497518\",\n \"0.5493019\",\n \"0.5490097\",\n \"0.5483502\",\n \"0.548034\",\n \"0.5464465\",\n \"0.5458607\",\n \"0.54467773\",\n \"0.54435253\",\n \"0.5434052\",\n \"0.542069\",\n \"0.5416532\",\n \"0.541214\",\n \"0.5388817\",\n \"0.5386616\",\n \"0.537702\",\n \"0.5369012\",\n \"0.536298\",\n \"0.534746\",\n \"0.53414756\",\n \"0.53385115\",\n \"0.5332305\",\n \"0.5331681\",\n \"0.53314906\",\n \"0.5325333\",\n \"0.53203815\",\n \"0.53184193\",\n \"0.5310373\",\n \"0.53062963\",\n \"0.5300834\",\n \"0.5296873\",\n \"0.52886343\",\n \"0.5284749\",\n \"0.5268316\",\n \"0.5265501\",\n \"0.5263195\",\n \"0.5262423\",\n \"0.526051\",\n \"0.52584326\",\n \"0.5256575\",\n \"0.5254926\",\n \"0.5252969\",\n \"0.52506286\",\n \"0.5249883\",\n \"0.5246273\",\n \"0.522035\",\n \"0.522035\",\n \"0.522035\",\n \"0.5219927\",\n \"0.5212773\",\n \"0.5211824\",\n \"0.5210138\",\n \"0.5207362\",\n \"0.5201455\",\n \"0.5187998\",\n \"0.5174206\",\n \"0.5168886\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.873001"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4993,"cells":{"query":{"kind":"string","value":"estimate an MxF user factor matrix and an FxN item factor matrix from the MxN rating matrix"},"document":{"kind":"string","value":"def factor_mat(all_dat, f_num, iterations, regularization):\n\n\t# get # of users and # of items\n\t[u_num, i_num] = all_dat.shape\n\n\t# init user factors and item factors with random values\n\tu_fac = np.matrix(np.random.rand(u_num, f_num))\t# MxF\n\ti_fac = np.matrix(np.random.rand(i_num, f_num))\t# NxF\n\n\t# calculate the preference matrix\n\tpreference = cal_preference(all_dat)\n\n\t# calculate the confidence matrix\n\tconfidence = cal_confidence(all_dat)\n\t\n\t# recalculate the user factors and item factors using the alternating least square method\n\tfor itr in range(iterations):\n\t\tu_fac = alternate_ls(u_num, i_fac, preference, confidence, regularization)\n\t\t#print itr, \"u_fac\"\n\t\ti_fac = alternate_ls(i_num, u_fac, preference.T, confidence.T, regularization)\n\t\t#print itr, \"i_fac\"\n\t\n\t# save the output\n\tdf = pd.DataFrame(u_fac)\n\tdf.to_csv(\"tmp/u_fac.tmp\", index=False, header=False, sep='\\t', encoding='utf-8')\n\tdf = pd.DataFrame(i_fac.T)\n\tdf.to_csv(\"tmp/i_fac.tmp\", index=False, header=False, sep='\\t', encoding='utf-8')\n\n\t# an MxF user factor matrix and an FxN item factor matrix\n\treturn [u_fac, i_fac.T]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_matrix(self):\n\n self.matrix = np.zeros((len(self.users), len(self.items)))\n\n for user in self.train_set['users']:\n for item in self.train_set['feedback'][user]:\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\n self.train_set['feedback'][user][item]","def get_user_item_matrix(datafile, user_index, product_index):\n num_users = len(user_index)\n num_items = len(product_index)\n result = np.zeros((num_users, num_items))\n num_reviews = len(datafile)\n result_dense = np.zeros((num_reviews, 3))\n for line in datafile.iterrows():\n i = line[0]\n user_id = datafile['user_id'][i]\n product_id = datafile['business_id'][i]\n user = user_index[user_id]\n product = product_index[product_id]\n rating = datafile['stars'][i]\n result[user, product] = rating\n result_dense[i, 0] = user\n result_dense[i, 1] = product\n result_dense[i, 2] = rating\n return result, result_dense","def create_user_item_matrix(data,type='unary'): \n if type == 'unary':\n\n # for unary rating drop duplicates\n data = data.drop_duplicates()\n\n # create sparse matrix\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\n\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\n # get all non empty rows and cols\n rows, cols = matrix.nonzero()\n unique_rows = np.unique(rows)\n unique_cols = np.unique(cols)\n\n # select only rows and cols with values\n matrix = matrix[unique_rows]\n matrix = matrix[:,unique_cols]\n\n return matrix\n\n if type == 'count':\n\n # create sparse matrix with counted ratings\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\n\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\n # get all non empty rows and cols\n rows, cols = matrix.nonzero()\n unique_rows = np.unique(rows)\n unique_cols = np.unique(cols)\n\n # select only rows and cols with values\n matrix = matrix[unique_rows]\n matrix = matrix[:,unique_cols]\n\n '''\n Im Gegensatz zum Memory Based approach, muss beim Model Based Approach noch das Rating angepasst werden. \n Das heisst, dass Produkte die viel eingekauft wurden ein höhers Rating erhalten und solche die weniger \n eingekauft wudren ein tieferes. Gleichzeitig muss das Maximum limitiert werden. Dies wird mittels \n dem max_count integer in der Funktion bewerkstelligt\n '''\n\n # create diagonal Matrix with 1 divided by maximum values per row. This needs to be done because there is no divide function for csr matrices implemented\n # source: https://stackoverflow.com/questions/42225269/scipy-sparse-matrix-division\n diag = diags(1/matrix.max(axis=1).A.ravel())\n\n # multipy the matrix with the maximum values to get range from 0-1\n matrix = diag.dot(matrix)\n\n # sort indices; not really needed, just cosmetics\n matrix.sort_indices()\n\n return matrix","def example():\n num_user, num_item, ratings = build_ticket()\n \n # suffle_data\n np.random.shuffle(ratings)\n\n # split data to training & validation\n train_pct = 0.9\n train_size = int(train_pct * len(ratings))\n train = ratings[:train_size]\n validation = ratings[train_size:]\n\n # params\n num_feature = 5\n bmf_model = BayesianMatrixFactorization(\n num_user, num_item, num_feature, train, validation, max_rating=1, min_rating=0, ratingsMatirx=ratings)\n\n start_time = time.clock()\n bmf_model.estimate(10)\n end_time = time.clock()\n \n mat = np.matrix(bmf_model.item_features)\n with open('../data/ticket/item_feature', 'w') as f:\n for line in mat:\n np.savetxt(f, line, fmt='%.5f')\n\n print \"time spend = %.3f\" % (end_time - start_time)\n\n return bmf_model","def get_user_feature_matrix_p(user_dict, user_index, aspect_index, N, popularity, A_dense, Polarity):\n result = np.zeros((len(user_index), len(aspect_index)))\n for key in user_dict.keys():\n index_user = user_index[key]\n user_reviews = user_dict[key]\n count_dict = {}\n max = 0\n min = 1000\n for review in user_reviews:\n feature = review[0]\n if feature not in aspect_index:\n continue\n aspect = aspect_index[feature]\n if aspect not in count_dict:\n count_dict[aspect] = 0;\n if Polarity == False:\n count_dict[aspect] += 1\n else:\n count_dict[aspect] += review[1]\n for aspect in count_dict.keys():\n count = count_dict[aspect]\n if count > max:\n max = count\n if count < min:\n min = count\n for aspect in count_dict.keys():\n count = count_dict[aspect]\n result[index_user, aspect] = (((count - min)/(max - min))*5)\n\n if len(popularity) > 0:\n col = np.zeros((len(result), 1))\n result = np.append(result, col, axis=1)\n for i in range(len(result)):\n items = A_dense[A_dense[:, 0] == i][:, 1]\n items = items.astype(int)\n result[i, len(result[1]) - 1] = np.mean(popularity[items, 1])\n return result","def fit(self, users, items, ratings, test_users=[], test_items=[], test_ratings=[], **kargs):\n global_mean_bias_init = np.float32(np.mean(ratings))\n global_mean_bias_init = 0.01\n self.model = DeepFM_(**self.dfm_params, global_mean_bias_init=global_mean_bias_init, first_half_fit_only_fm=self.first_half_fit_only_fm)\n \n # もし、CTR予測の場合は、y=0のデータをランダム生成する。\n if self.ctr_prediction:\n users = list(users) + list(np.random.choice(list(set(users)), size=len(users)))\n items = list(items) + list(np.random.choice(list(set(items)), size=len(items)))\n ratings = list((np.array(ratings)>0).astype(int)) + [0]*len(ratings)\n test_ratings = list((np.array(test_ratings)>0).astype(int))\n \n Xi, Xv = self.data_manager.transform_users_and_items_to_Xi_Xv(users, items)\n \n if len(test_users)>0:\n test_Xi, test_Xv = self.data_manager.transform_users_and_items_to_Xi_Xv(test_users, test_items)\n self.model.fit(Xi, Xv, ratings, test_Xi, test_Xv, test_ratings, early_stopping=True)\n else:\n self.model.fit(Xi, Xv, ratings, early_stopping=True, **kargs)\n \n # load data\n self.trained_users = list(set(users))\n self.trained_items = list(set(items))\n self.global_mean = self.model.predict(Xi, Xv).mean()","def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\n #print \"--------------------------------------------------\"\n #print \"calculate_recommendations\"\n #print \"--------------------------------------------------\"\n\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\n\n # U = np.array('users')\n # D = np.array('video_games')\n\n # R = |U| cross |D|\n\n # We want to discover K latent features\n\n # Find\n # P(a | |U| corss K matrix)\n # Q(a | |D| cross K matrix)\n # Such that their product approximates R\n # R approx= P cross transpose(Q) = hat(R)\n #\n\n # r[i][j] = transpose(p)[i] * q[j]\n # = sum( 1..k, p[i][k] * q[k][j] )\n\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\n # squared error, estimated rating can be either higher or lower than the real thing\n\n # find the gradient\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\n\n # update rules\n # alpha = settings.alpha # learning_rate\n # alpha = 0.0002 # learning_rate\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\n\n # training data\n # T = (u[i], d[j], r[i][j])\n # np.array()\n\n # iterate until convergance\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\n # - sum(1..k, p[i][k]*q[k][j]))**2\n\n # regularization\n # beta = 0.02\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\n #\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\n\n data = np.array(vote_list)\n\n encoder = OneHotEncoder()\n\n users = data[:,0]\n unique_users = list(set(users))\n for i in range(len(users)):\n users[i] = unique_users.index(users[i])\n\n video_games = data[:,1]\n unique_games = list(set(video_games))\n for i in range(len(video_games)):\n video_games[i] = unique_games.index(video_games[i])\n\n ratings = data[:,2]\n M = len(set(video_games))\n N = len(set(users))\n R = np.zeros((N,M))\n for i in range(len(users)):\n user = users[i]\n game = video_games[i]\n rating = ratings[i]\n R[user][game] = rating\n\n K = 2\n\n P = np.random.rand(N,K)\n Q = np.random.rand(M,K)\n\n nP, nQ = self.matrix_factorization(R, P, Q, K)\n nR = np.dot(nP, nQ.T)\n\n itemMatch = {}\n for i in range(N):\n user = unique_users[i]\n itemMatch[user] = []\n for j in range(M):\n if R[i][j] == 0:\n video_game = unique_games[j]\n recommendation = (video_game, nR[i][j])\n itemMatch[user].append(recommendation)\n itemMatch[None] = []\n print 'pmf recommendations', itemMatch.items()\n print '\\n'\n recommendations = itemMatch.items()\n\n # returns\n # [\n # (<user1>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # (<user2>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # ]\n\n return recommendations","def init_matrix(self, train, num_features):\n user_matrix = np.random.rand(self.num_users, num_features)\n item_matrix = np.random.rand(num_features, self.num_items)\n item_nnz = train.getnnz(axis=0)\n item_sum = train.sum(axis=0)\n item_matrix[0, :] = item_sum / item_nnz\n return user_matrix, item_matrix","def create_adjust_matrix(self, is_sub: bool):\n matrix = None\n if not is_sub:\n ratings = np.ones_like(self._user, dtype=np.float32)\n matrix = sp.csr_matrix(\n (ratings, (self._user, self._item + self.n_users)),\n shape=(self.n_users + self.n_items, self.n_users + self.n_items),\n )\n else:\n if self.type == \"ND\":\n drop_user = self.rand_sample(\n self.n_users,\n size=int(self.n_users * self.drop_ratio),\n replace=False,\n )\n drop_item = self.rand_sample(\n self.n_items,\n size=int(self.n_items * self.drop_ratio),\n replace=False,\n )\n R_user = np.ones(self.n_users, dtype=np.float32)\n R_user[drop_user] = 0.0\n R_item = np.ones(self.n_items, dtype=np.float32)\n R_item[drop_item] = 0.0\n R_user = sp.diags(R_user)\n R_item = sp.diags(R_item)\n R_G = sp.csr_matrix(\n (\n np.ones_like(self._user, dtype=np.float32),\n (self._user, self._item),\n ),\n shape=(self.n_users, self.n_items),\n )\n res = R_user.dot(R_G)\n res = res.dot(R_item)\n\n user, item = res.nonzero()\n ratings = res.data\n matrix = sp.csr_matrix(\n (ratings, (user, item + self.n_users)),\n shape=(self.n_users + self.n_items, self.n_users + self.n_items),\n )\n\n elif self.type == \"ED\" or self.type == \"RW\":\n keep_item = self.rand_sample(\n len(self._user),\n size=int(len(self._user) * (1 - self.drop_ratio)),\n replace=False,\n )\n user = self._user[keep_item]\n item = self._item[keep_item]\n\n matrix = sp.csr_matrix(\n (np.ones_like(user), (user, item + self.n_users)),\n shape=(self.n_users + self.n_items, self.n_users + self.n_items),\n )\n\n matrix = matrix + matrix.T\n D = np.array(matrix.sum(axis=1)) + 1e-7\n D = np.power(D, -0.5).flatten()\n D = sp.diags(D)\n return D.dot(matrix).dot(D)","def forward(self, user, item):\n item_emb = self.product_factors(item.view(-1)) + self.product_bias(\n item.view(-1)\n )\n user_emb = self.user_factors(user.view(-1)) + self.user_bias(user.view(-1))\n mat_mult = (item_emb * user_emb).sum(1)\n\n return mat_mult","def affinity_matrix(test_specs):\n\n np.random.seed(test_specs[\"seed\"])\n\n # uniform probability for the 5 ratings\n s = [(1 - test_specs[\"spars\"]) / test_specs[\"ratings\"]] * test_specs[\"ratings\"]\n s.append(test_specs[\"spars\"])\n P = s[::-1]\n\n # generates the user/item affinity matrix. Ratings are from 1 to 5, with 0s denoting unrated items\n X = np.random.choice(\n test_specs[\"ratings\"] + 1, (test_specs[\"users\"], test_specs[\"items\"]), p=P\n )\n\n Xtr, Xtst = numpy_stratified_split(\n X, ratio=test_specs[\"ratio\"], seed=test_specs[\"seed\"]\n )\n\n return Xtr, Xtst","def update_model(self):\n for itemidx, itemid in self._allitems.iterrows():\n self.__itemid2idx[str(itemid['itemid'])] = itemidx\n self.__itemidx2id[itemidx] = str(itemid['itemid'])\n for useridx, userid in enumerate(self._uservisits['userid'].unique()):\n self.__userid2idx[str(userid)] = useridx\n self.__useridx2id[useridx] = str(userid)\n userid = self._uservisits['userid'].values\n itemid = self._uservisits['itemid'].values\n rating = self._uservisits['rating'].values\n useridx = [self.__userid2idx[str(int(uid))] for uid in userid]\n itemidx = [self.__itemid2idx[str(int(iid))] for iid in itemid]\n rating = list(map(numpy.double, rating))\n self.__itemuser = csr_matrix((rating, (useridx, itemidx)), shape=(len(set(useridx)), len(set(itemidx))))\n self.__recommender = implicit.als.AlternatingLeastSquares(factors=self.__numtopics)\n self.__recommender.fit(self.__itemuser)","def recommend_NMF(new_user,movies_num,movies_ratings):\n list_id_movies = movies_ratings['movieId'].unique()\n nmf,Q = load_NMF_model()\n new_user_vector = pd.DataFrame(new_user, index=list_id_movies).T\n new_user_vector_filled = new_user_vector.fillna(3)\n #calculate Matrix P (Genres)\n P = nmf.transform(new_user_vector_filled)\n #make predictions\n predictions = np.dot(P,Q)\n recommendations = pd.DataFrame(predictions.reshape(-1), index=list_id_movies).T\n #Remove already watched movies:\n not_watched_movies_mask = np.isnan(new_user_vector)\n not_watched = recommendations[not_watched_movies_mask]\n\n top_movies_ids = not_watched.T.sort_values(by=[0], ascending=False).index[:movies_num]\n\n Top_recommended = movieId_to_title(top_movies_ids,movies_ratings) \n return Top_recommended","def fit(self, df):\n\n # generate continuous indices if this hasn't been done\n if self.index2item is None:\n self.set_index(df)\n\n logger.info(\"Collecting user affinity matrix\")\n if not np.issubdtype(df[self.col_rating].dtype, np.number):\n raise TypeError(\"Rating column data type must be numeric\")\n\n # copy the DataFrame to avoid modification of the input\n temp_df = df[[self.col_user, self.col_item, self.col_rating]].copy()\n\n if self.time_decay_flag:\n logger.info(\"Calculating time-decayed affinities\")\n # if time_now is None use the latest time\n if not self.time_now:\n self.time_now = df[self.col_timestamp].max()\n\n # apply time decay to each rating\n temp_df[self.col_rating] *= exponential_decay(\n value=df[self.col_timestamp],\n max_val=self.time_now,\n half_life=self.time_decay_half_life,\n )\n\n # group time decayed ratings by user-item and take the sum as the user-item affinity\n temp_df = (\n temp_df.groupby([self.col_user, self.col_item]).sum().reset_index()\n )\n else:\n # without time decay use the latest user-item rating in the dataset as the affinity score\n logger.info(\"De-duplicating the user-item counts\")\n temp_df = temp_df.drop_duplicates(\n [self.col_user, self.col_item], keep=\"last\"\n )\n\n logger.info(\"Creating index columns\")\n # map users and items according to the two dicts. Add the two new columns to temp_df.\n temp_df.loc[:, self.col_item_id] = temp_df[self.col_item].map(self.item2index)\n temp_df.loc[:, self.col_user_id] = temp_df[self.col_user].map(self.user2index)\n\n # retain seen items for removal at prediction time\n self.seen_items = temp_df[[self.col_user_id, self.col_item_id]].values\n\n # affinity matrix\n logger.info(\"Building user affinity sparse matrix\")\n self.user_affinity = self.compute_affinity_matrix(\n temp_df, self.n_users, self.n_items\n )\n\n # calculate item co-occurrence\n logger.info(\"Calculating item co-occurrence\")\n item_cooccurrence = self.compute_coocurrence_matrix(\n temp_df, self.n_users, self.n_items\n )\n\n # free up some space\n del temp_df\n\n self.item_frequencies = item_cooccurrence.diagonal()\n\n logger.info(\"Calculating item similarity\")\n if self.similarity_type == sar.SIM_COOCCUR:\n self.item_similarity = item_cooccurrence\n elif self.similarity_type == sar.SIM_JACCARD:\n logger.info(\"Calculating jaccard\")\n self.item_similarity = jaccard(item_cooccurrence).astype(\n df[self.col_rating].dtype\n )\n elif self.similarity_type == sar.SIM_LIFT:\n logger.info(\"Calculating lift\")\n self.item_similarity = lift(item_cooccurrence).astype(\n df[self.col_rating].dtype\n )\n else:\n raise ValueError(\n \"Unknown similarity type: {0}\".format(self.similarity_type)\n )\n\n # free up some space\n del item_cooccurrence\n\n logger.info(\"Done training\")","def fit_data(self, matrix, user_features=None, item_features=None):\r\n matrix.sort_index(inplace=True)\r\n matrix.sort_index(inplace=True, axis=1)\r\n dataset = Dataset()\r\n dataset.fit((x for x in matrix.index),\r\n (x for x in matrix.columns))\r\n interactions = pd.melt(matrix.replace(0, np.nan).reset_index(),\r\n id_vars='index',\r\n value_vars=list(matrix.columns[1:]),\r\n var_name='plu_id',\r\n value_name='rating').dropna().sort_values('index')\r\n interactions.columns = ['crd_no', 'plu_id', 'rating']\r\n self.interactions, self.weights = dataset.build_interactions([tuple(x) for x in interactions.values])\r\n\r\n if user_features is not None:\r\n user_features.sort_index(inplace=True)\r\n dataset.fit_partial(users=user_features.index,\r\n user_features=user_features)\r\n self.user_features = dataset.build_user_features(\r\n ((index, dict(row)) for index, row in user_features.iterrows()))\r\n else:\r\n self.user_features = None\r\n if item_features is not None:\r\n item_features.sort_index(inplace=True)\r\n dataset.fit_partial(items=item_features.index,\r\n item_features=item_features)\r\n self.item_features = dataset.build_item_features(\r\n ((index, dict(row)) for index, row in item_features.iterrows()))\r\n else:\r\n self.item_features = None","def __init__(self, ratings, rank, user_reg_loss, item_reg_loss):\n self._ratings = ratings\n self._users_num, self._items_num = ratings.shape\n self._rank = rank\n self._user_reg_loss = user_reg_loss\n self._item_reg_loss = item_reg_loss\n \n self._train_function = self._als_partial_step_explicit\n \n # DONE init latent factors for user and item matrix\n # losowo ustalamy inicjalne wartości X i Y\n self._user_factors = np.random.random((self._users_num, rank))\n self._item_factors = np.random.random((self._items_num, rank))","def predict_rating(user_id,item_id):\n user_preference = latent_user_preferences[user_id]\n item_preference = latent_item_features[item_id]\n return user_preference.dot(item_preference)","def compute_affinity_matrix(self, df, n_users, n_items):\n\n return sparse.coo_matrix(\n (df[self.col_rating], (df[self.col_user_id], df[self.col_item_id])),\n shape=(n_users, n_items),\n ).tocsr()","def init_MF(train, num_features):\n num_user = train.shape[1]\n num_item = train.shape[0]\n user_features = np.random.rand(num_features,num_user) # user_features shape (20,943)\n item_features = np.random.rand(num_item, num_features) # item_features shape (1152,20)\n return user_features, item_features","def feature_matrix(df, user_id=None, item_id=None):\n print(\"get feature matrix\")\n df1 = df.drop_duplicates(subset=['user_id'], keep='first', inplace=False)\n user_x = None\n if user_id is not None:\n user_x = int(np.argwhere(df1['user_id'].values == user_id))\n user_features = df1[['average_stars']].values\n csr_user_features = sparse.csr_matrix(user_features)\n\n df2 = df.drop_duplicates(\n subset=['business_id'],\n keep='first',\n inplace=False)\n item_x = None\n if item_id is not None:\n item_x = int(np.argwhere(df2['business_id'].values == item_id))\n item_features = df2.iloc[:, 10:].values\n\n csr_item_features = sparse.csr_matrix(item_features)\n return csr_user_features, csr_item_features, user_x, item_x","def simMatrix(self, d = 1/5):\n \n self.fit_baseline(d)\n self.evalBaseline()\n \n \n df_mat = np.array(self.df[[\"user ind\", \"item ind\", \"rating\"]].merge(self.r_b, on = [\"user ind\", \"item ind\"]))\n df_ind = df_mat[:,:2].astype(int)\n df_rat = df_mat[:,2] - df_mat[:,3]\n \n \n self.M = np.zeros((self.n_us, self.n_it))\n \n \n widgets = ['Test: ', Percentage(), ' ', Bar(\"#\"), ' ', ETA()]\n pbar = ProgressBar(widgets = widgets, maxval = self.n_us)\n pbar.start()\n \n for us in self.user_ind:\n it = df_ind[np.where(df_ind[:,0] == us)[0], 1]\n rat1 = df_rat[np.where(df_ind[:,0] == us)[0]]\n self.M[us,it] = rat1\n \n pbar.update(us)\n \n pbar.finish()\n \n #self.M = self.UI.toarray()\n pbar = ProgressBar(widgets = widgets, maxval = self.n_it * (self.n_it - 1) / 2)\n pbar.start()\n \n self.S = np.empty((self.n_it, self.n_it)) * np.nan\n \n for i1 in range(self.n_it):\n # self.S[i1,i1] = 1\n x1 = self.M[:,i1]\n for i2 in range(i1+1,self.n_it):\n x2 = self.M[:,i2]\n I = np.logical_and(x1, x2)\n if (len(I) > 1):\n self.S[i1,i2] = self.S[i2,i1] = Sim.cos2(x1.T[I], self.M[:,i2].T[I])\n \n pbar.update((self.n_it)*(i1+1) - (i1+2)*(i1+1)/2)\n \n pbar.finish()\n \n return self.S","def score_items(X, U, mu,\n scoremethod='lowhigh',\n missingmethod='none',\n feature_weights=[]):\n\n # Use U to model and then reconstruct the data in X.\n # 1. Project all data in X into space defined by U,\n # then reconstruct it.\n if missingmethod.lower() != 'ignore':\n # All missing values should have been replaced with 0,\n # or non-existent.\n # 1a. Subtract the mean and project onto U\n proj = np.dot(U.T, (X - mu))\n # 1b. Reconstruct by projecting back up and adding mean\n reproj = np.dot(U, proj) + mu\n # 1c. Compute the residual\n #print('X:', X.T)\n #print('reproj:', reproj.T)\n err = X - reproj\n #print('err:', err.T)\n #input()\n \n else:\n # Missing method must be 'ignore' (Brand 2002)\n (err, reproj) = compute_error_with_missing(X, U, mu)\n\n # 2. Compute reconstruction error\n if scoremethod == 'low': # Blank out all errors > 0\n err[err>0] = 0\n elif scoremethod == 'high': # Blank out all errors < 0\n err[err<0] = 0\n else: # default, count everything\n pass\n \n # Weight features if requested\n if len(feature_weights) > 0:\n for i in range(len(feature_weights)):\n err[i,:] = err[i,:] * feature_weights[i]\n\n if missingmethod.lower() == 'ignore':\n # Only tally error for observed features.\n # This means that items with missing values are not penalized\n # for those features, which is probably the best we can do.\n scores = np.nansum(np.array(np.power(err, 2)), axis=0)\n else:\n scores = np.sum(np.array(np.power(err, 2)), axis=0)\n\n #print('scores:', scores)\n #print('reproj:', reproj)\n #input()\n return (scores, reproj)","def ratings_to_matrix(ratings_df, user_col, item_col, rating_col, forced_shape=None):\n users_num = ratings_df.user_id.max() + 1\n items_num = ratings_df.item_id.max() + 1\n \n if forced_shape:\n users_num = max(users_num, forced_shape[0])\n items_num = max(items_num, forced_shape[1])\n \n ratings_mat = np.zeros([users_num, items_num])\n for rating in ratings_df.itertuples():\n ratings_mat[rating[user_col], rating[item_col]] = rating[rating_col]\n \n return ratings_mat","def __init__(self, user_factors, item_factors):\n self._user_factors = np.copy(user_factors)\n self._item_factors = np.copy(item_factors)\n \n self._users_num = user_factors.shape[0]\n self._items_num = item_factors.shape[0]\n\n assert user_factors.shape[1] == item_factors.shape[1]","def fit(self, ratings):\n # Training proceeds in 2 steps:\n # 1. Normalize item vectors to be mean-centered and unit-normalized\n # 2. Compute similarities with pairwise dot products\n self._timer = util.Stopwatch()\n\n init_rmat, users, items = matrix.sparse_ratings(ratings)\n n_items = len(items)\n _logger.info('[%s] made sparse matrix for %d items (%d ratings from %d users)',\n self._timer, len(items), init_rmat.nnz, len(users))\n\n rmat, item_means = self._mean_center(ratings, init_rmat, items)\n\n rmat = self._normalize(rmat)\n\n _logger.info('[%s] computing similarity matrix', self._timer)\n smat = self._compute_similarities(rmat)\n\n _logger.info('[%s] got neighborhoods for %d of %d items',\n self._timer, np.sum(np.diff(smat.rowptrs) > 0), n_items)\n\n _logger.info('[%s] computed %d neighbor pairs', self._timer, smat.nnz)\n\n self.item_index_ = items\n self.item_means_ = item_means\n self.item_counts_ = np.diff(smat.rowptrs)\n self.sim_matrix_ = smat\n self.user_index_ = users\n self.rating_matrix_ = init_rmat\n\n return self","def important_factors_based_on_ratings(data: pd.DataFrame) -> np.ndarray:\n # Turn labels into binary classification for equal class distribution\n data = utils.add_ratings_binary(data)\n # Get feature and label data for classifcation from original dataset\n X, y = utils.get_rating_features_labels(data)\n\n # Grab features from feature matrix\n features = X.columns\n\n # split data into train and test set\n X_train, X_test, y_train, y_test = model_selection.train_test_split(X.values, y, test_size=0.2) \n\n # Instantiate and train xgboost model for rating classfication\n xgb_model = xgboost.XGBClassifier()\n xgb_model.fit(X_train, y_train)\n\n # Grab feature importance scores from trained model\n feature_importance = xgb_model.feature_importances_\n # Find indices of top 2 important features\n top_important_features_ind = np.argpartition(feature_importance, -2)[-2:]\n\n print(f\"The top 2 important features are {features[top_important_features_ind]}\")\n\n return feature_importance","def get_user_feature_matrix(user_dict, user_index, aspect_index, N):\n result = np.zeros((len(user_index), len(aspect_index)))\n for key in user_dict.keys():\n index_user = user_index[key]\n user_reviews = user_dict[key]\n count_dict = {}\n for review in user_reviews:\n feature = review[0]\n if feature not in aspect_index:\n continue\n aspect = aspect_index[feature]\n if aspect not in count_dict:\n count_dict[aspect] = 0;\n count_dict[aspect] += 1\n for aspect in count_dict.keys():\n count = count_dict[aspect]\n result[index_user, aspect] = 1 + (N - 1) * (2 / (1 + exp(-count)) - 1)\n return result","def personalization(prediction, n):\n # prediction\n # n top n recommendation\n\n top_n = get_top_n(prediction, n)\n\n rec_dict = {}\n for uid, user_ratings in top_n.items():\n rec_dict[uid] = [iid for (iid, _) in user_ratings]\n\n rec_user_ls = [pred[0] for pred in prediction]\n rec_item_ls = [pred[1] for pred in prediction]\n\n unique_rec_user_ls = np.unique(rec_user_ls)\n unique_rec_item_ls = np.unique(rec_item_ls)\n\n # assign each item with index number\n unique_rec_item_dict = {item: ind for ind,\n item in enumerate(unique_rec_item_ls)}\n\n n_unique_rec_user = len(unique_rec_user_ls)\n n_unique_rec_item = len(unique_rec_item_ls)\n\n # recommended user item matrix\n rec_matrix = np.zeros(shape=(n_unique_rec_user, n_unique_rec_item))\n\n # represent recommended item for each user as binary 0/1\n for user in range(n_unique_rec_user):\n # get userid\n user_id = unique_rec_user_ls[user]\n # get rec item list\n item_ls = rec_dict[user_id]\n\n for item_id in item_ls:\n # get item index\n item = unique_rec_item_dict[item_id]\n rec_matrix[user, item] = 1\n\n # calculate cosine similarity matrix across all user recommendations\n similarity = cosine_similarity(X=rec_matrix, dense_output=False)\n # calculate average of upper triangle of cosine matrix\n upper_right = np.triu_indices(similarity.shape[0], k=1)\n # personalization is 1-average cosine similarity\n score = 1 - np.mean(similarity[upper_right])\n return score","def update_item_feature(\n train, item_features, user_features, lambda_item,\n nz_item_userindices, I):\n for n, item_n in enumerate(nz_item_userindices):\n nnz_users_per_item = len(item_n[1]) # Number of users who rated item n\n if (nnz_users_per_item == 0): nnz_users_per_item = 1\n # Least squares solution\n A_n = np.dot(user_features[:,item_n[1]], user_features[:,item_n[1]].T) + lambda_item * nnz_users_per_item * I\n V_n = np.dot(user_features[:,item_n[1]], train.T[item_n[1],item_n[0]].todense())\n #if (n%3 == 0): print(\"item_n: {}\".format(item_n[0]), np.linalg.det(A_n))\n if (np.linalg.det(A_n) != 0): item_features.T[:,item_n[0]] = np.linalg.solve(A_n,V_n)\n else: \n A_n[0,0] += 1; A_n[1,1] += 1; A_n[2,2] += 1; A_n[3,3] += 1; A_n[4,4] += 1; A_n[5,5] += 1 # if matrix A_n is singular, slightly modify several values\n item_features.T[:,item_n[0]] = np.linalg.solve(A_n,V_n)","def item_user_matrix(X):\n X['user_id'] = X['user_id'].astype(\"category\")\n X['song_id'] = X['song_id'].astype(\"category\")\n\n row = X['song_id'].cat.codes.copy()\n col = X['user_id'].cat.codes.copy()\n\n nrow = len(X['song_id'].cat.categories)\n ncol = len(X['user_id'].cat.categories)\n\n item_user = csr_matrix((X['score'], (row, col)), shape=(nrow, ncol))\n\n user = dict(enumerate(X['user_id'].cat.categories))\n user_index = {u: i for i, u in user.items()}\n\n item = dict(enumerate(X['song_id'].cat.categories))\n item_index = {s: i for i, s in item.items()}\n\n return item_user, item_index, user_index","def fit(self, ratings_mat):\n self.logger.debug(\"starting fit\")\n # self.n = ratings.max()['user']+1\n # self.p = ratings.max()['movie']+1\n self.ratings_mat = ratings_mat\n self.k = ratings_mat.shape[0]//20\n\n #ratings_array = ratings[ratings.columns[:-1].values].values\n\n #self.ratings_mat = np.zeros((self.n, self.p))\n\n #for i, rating in ratings.iterrows():\n # self.ratings_mat[( rating['user'], rating['movie'] )] = rating['rating']\n\n self.cosine_dists = squareform(pdist(ratings_mat, 'cosine'))\n\n #if a user has no ratings data, cosine dist will return a nan. In this case, we assume they are as different as possible, since we cannot predict using those users anyways\n self.cosine_dists = 1 - np.nan_to_num(1 - self.cosine_dists)\n\n self.similarity_ranks = self.cosine_dists.argsort(axis = 1)\n\n # ...\n\n self.logger.debug(\"finishing fit\")\n return(self)","def FM(user_feature_columns, item_feature_columns, l2_reg_embedding=1e-6, loss_type='softmax', temperature=0.05,\n sampler_config=None, seed=1024,\n ):\n\n embedding_matrix_dict = create_embedding_matrix(user_feature_columns + item_feature_columns, l2_reg_embedding,\n seed=seed,\n seq_mask_zero=True)\n\n user_features = build_input_features(user_feature_columns)\n user_inputs_list = list(user_features.values())\n user_sparse_embedding_list, _ = input_from_feature_columns(user_features,\n user_feature_columns,\n l2_reg_embedding, seed=seed,\n support_dense=False,\n embedding_matrix_dict=embedding_matrix_dict)\n\n item_features = build_input_features(item_feature_columns)\n item_inputs_list = list(item_features.values())\n item_sparse_embedding_list, _ = input_from_feature_columns(item_features,\n item_feature_columns,\n l2_reg_embedding, seed=seed,\n support_dense=False,\n embedding_matrix_dict=embedding_matrix_dict)\n\n user_dnn_input = concat_func(user_sparse_embedding_list, axis=1)\n user_vector_sum = Lambda(lambda x: reduce_sum(x, axis=1, keep_dims=False))(user_dnn_input)\n user_vector_sum = l2_normalize(user_vector_sum)\n\n item_dnn_input = concat_func(item_sparse_embedding_list, axis=1)\n item_vector_sum = Lambda(lambda x: reduce_sum(x, axis=1, keep_dims=False))(item_dnn_input)\n item_vector_sum = l2_normalize(item_vector_sum)\n\n if loss_type == \"logistic\":\n score = inner_product(user_vector_sum, item_vector_sum, temperature)\n output = PredictionLayer(\"binary\", False)(score)\n\n elif loss_type == \"softmax\":\n output = InBatchSoftmaxLayer(sampler_config._asdict(), temperature)(\n [user_vector_sum, item_vector_sum, item_features[sampler_config.item_name]])\n else:\n raise ValueError(' `loss_type` must be `logistic` or `softmax` ')\n\n model = Model(inputs=user_inputs_list + item_inputs_list, outputs=output)\n\n model.__setattr__(\"user_input\", user_inputs_list)\n model.__setattr__(\"user_embedding\", user_vector_sum)\n\n model.__setattr__(\"item_input\", item_inputs_list)\n model.__setattr__(\"item_embedding\", item_vector_sum)\n\n return model","def getUserItemMatrix(self):\n\t\tdf = self.getrating()\n\n\t\trows_index = df.user_id.unique()\n\t\tcolumn_index = df.venue_id.unique() \n\n\t\trow_len = len(rows_index)\n\t\tcol_len = len(column_index)\n\n\t\tX = lil_matrix((row_len, col_len))\n\t\trow_map = dict(zip(rows_index, range(row_len)))\n\t\tcol_map = dict(zip(column_index, range(col_len)))\n\n\t\t# Get mapping table for rows and columns\n\t\td = {}\n\t\td[\"row\"] = row_map\n\t\td[\"col\"] = col_map\n\n\t\tfor index, row in df.iterrows():\n\t\t\tX[d[\"row\"][row[\"user_id\"]], d[\"col\"][row[\"venue_id\"]]] = row[\"Rating\"]\n\n\t\tX = X.tocsr() # Allow efficient row slicing\n\n\t\treturn [d,X]","def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\n active_user = actives[0][0]\n active_item = actives[0][1]\n\n # -----------------------------------\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\n\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\n return (active_user, active_item), 2.5\n\n # all user, ratings that have rated active_item\n if active_item in train_rdd_gbitem_dict:\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\n else:\n # item not found in training set\n # new item problem.\n average_of_user_list = train_rdd_gbuser_dict[active_user]\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\n return (active_user, active_item), average_of_user\n\n # user rated items - all (item, ratings) that the user has rated\n if active_user in train_rdd_gbuser_dict:\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\n else:\n # user not found in training set\n # new user problem.\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\n\n similarity_list = []\n for item, rating in active_user_rated_items:\n item_dict = dict(train_rdd_gbitem_dict[item][0])\n item_avg = train_rdd_gbitem_dict[item][1]\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\n similarity_list.append((rating, similarity))\n\n # Have obtained similarity list for active item and item from the above code.\n # Filter according to a top 'N' items and then take avg rating.\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\n # similarity_list = similarity_list[:len(similarity_list) // 4]\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\n # print(similarity_list)\n pred_rating = find_weighted_average(similarity_list, num_items)\n\n # for i in similarity_list:\n # print(i)\n # print(\"Pred-rating: \", pred_rating)\n\n return (active_user, active_item), pred_rating","def convert_fidelity_matrix(fidelities, fidelity, sx, factor):\n\n matrix = np.zeros((sx, fidelities - 1))\n for idx in range(0, fidelity):\n matrix[:, idx] = np.ones((sx)) * factor[fidelity]\n\n return matrix","def train_nmf(movies_ratings):\n \n #pivot the dataframe\n movies_ratings = movies_ratings.pivot_table(index='userId', columns='movieId', values='rating')\n #Fill Nan with 3.0 rating:\n movies_ratings.fillna(3.0, inplace=True)\n\n nmf_model = NMF(\n n_components=20,\n init='random',\n random_state=10,\n max_iter=10000\n )\n nmf_model.fit(movies_ratings)\n\n #save nmf model\n pickle.dump(nmf_model,open(\"models/nmf_model.sav\", 'wb'))","def metric_test(self):\n k = 10\n latent_factor = 10\n n_users = 10\n n_items = 12\n\n interactions, user_features, item_features = util.generate_dummy_data_with_indicator (num_users=n_users, num_items=n_items, interaction_density=.5)\n print (\"interactiosn shape={}\".format( np.shape(interactions) ))\n print (\"user features shape={}\".format( np.shape(user_features.toarray()) ))\n print (\"item features shape={}\".format( np.shape(item_features.toarray()) ))\n\n model = TensorRec(n_components=latent_factor)\n\n model.fit(interactions, user_features, item_features, epochs=19)\n\n ranks = model.predict_rank(user_features=user_features, item_features=item_features)\n\n print (\"Ranks shape={}\".format(np.shape(ranks)))\n\n self.assertTrue(np.shape(interactions) == np.shape(ranks))\n\n tr_recall_result = eval.recall_at_k(predicted_ranks=ranks, test_interactions=interactions, k=k, preserve_rows=False)\n # print (tr_recall_result.mean())\n\n tr_precision_result = eval.precision_at_k(predicted_ranks=ranks, test_interactions=interactions, k=k, preserve_rows=False)\n # print(tr_precision_result.mean())\n\n # we need csr for interactions data\n interactions_ = interactions.tocsr()\n recall_result = metrics.recall_at_k(ranks, interactions_, k=k, preserve_rows=False)\n # print(recall_result.mean())\n\n precision_result = metrics.precision_at_k(ranks, interactions_, k=k, preserve_rows=False)\n # print (precision_result.mean())\n\n self.assertTrue (tr_recall_result.mean() == recall_result.mean())\n self.assertTrue (tr_precision_result.mean() == precision_result.mean())","def update_user_feature(\n train, user_features, item_features, lambda_user,\n nz_user_itemindices, I):\n for d, user_d in enumerate(nz_user_itemindices): # iterate over non zero users\n nnz_items_per_user = len(user_d[1]) # Number of items user d has rated\n if (nnz_items_per_user == 0): nnz_items_per_user = 1\n \n # Least squares solution\n A_d = np.dot(item_features[user_d[1]].T, item_features[user_d[1]]) + lambda_user * nnz_items_per_user * I\n V_d = np.dot(item_features[user_d[1]].T, train[user_d[1],user_d[0]].todense())\n user_features[:,user_d[0]] = np.linalg.solve(A_d,V_d)","def _estimate_ratings(self, U, V):\n Rhat = np.matmul(U, V.transpose()) # estimate R with UV^T\n Rhat = np.where(self.R_missing, 0, Rhat) # fill in missing values of R with 0s\n return Rhat","def estimate(self, u, j):\n if not (self.trainset.knows_user(u) and self.trainset.knows_item(j)):\n raise PredictionImpossible('User and/or item is unknown.')\n\n u_ratings = self.trainset.ur[u]\n\n if self.weighting == 'linear':\n weight = sum(self.freqs[i, j, self.to_index(r)] for i, r in u_ratings)\n score = sum(self.sums[i, j, self.to_index(r)] for i, r in u_ratings)\n return score / weight\n\n # self.weighting == 'log' or None\n weights = [self.freqs[i, j, self.to_index(r)] for i, r in u_ratings]\n reciprocals = [1 / w if w else 0 for w in weights]\n scores = [self.sums[i, j, self.to_index(r)] for i, r in u_ratings]\n scores = [s * w for s, w in zip(scores, reciprocals)]\n\n if self.weighting is None:\n return np.mean(scores)\n # self.weighting == 'log'\n logs = [np.log(w + 1) if w >= 1 else 0 for w in weights]\n return np.dot(scores, logs) / np.sum(logs)","def compute_user_user_sim_base_on_common_items(self):\n self.sim_matrix = {}\n for item in self.items.values():\n # convert to list of tuples for indexing\n users = list(item.covered_users.items())\n item_popularity = len(users)\n # iter through all user pairs\n for i in range(len(users)-1):\n for j in range(i+1, len(users)):\n user_A_info, user_B_info = users[i], users[j]\n # remember to update pair wise!\n self.update_user_user_sim(user_A_info, user_B_info,\n item_popularity)\n self.update_user_user_sim(user_B_info, user_A_info,\n item_popularity)","def compute_pmf(X_inp, rank, c1, c2):\n\n X_arr = []\n u_arr = []\n v_arr = []\n d_arr = []\n\n X = deepcopy(X_inp)\n\n v_init = np.ones((np.shape(X)[1],1))\n\n for i in range(rank):\n X_arr.append(X)\n (d,u,v) = compute_factor(X, v_init, c1, c2)\n\n\n assert abs(npla.norm(u) - 1 ) < 1e-3\n assert abs(npla.norm(v) - 1 ) < 1e-3\n\n d_arr.append(d)\n u_arr.append(u)\n v_arr.append(v)\n\n toSub = np.outer(u,v)\n assert np.shape(toSub) == np.shape(X)\n X -= d * toSub\n\n return (X_arr, u_arr, v_arr, d_arr)","def item_based_CF(G):\n\n\tcode, pmid = nx.bipartite.sets(G)\n\tX = nx.bipartite.biadjacency_matrix(G,pmid,column_order=code)\n\tmean_X = np.mean(X,axis=0)\n\tadjusted_X = X - mean_X\n\tsimilarity = cosine_similarity(X.T)\n\trating = mean_X + np.dot(adjusted_X,similarity)/np.sum(np.abs(similarity),axis=1)\n\tdf = pd.DataFrame(data=rating,index=pmid,columns=code)\n\n\treturn df","def predict_rating(self, user_id, item_id):\n user_preference = self.latent_user_preferences[user_id]\n item_feature = self.latent_item_features[item_id]\n return user_preference.dot(item_feature)","def create_user_item_array(self):\n user_em = self.user_factors.weight.detach()\n item_em = self.product_factors.weight.detach()\n user_b = self.user_bias.weight.detach()\n item_b = self.product_bias.weight.detach()\n\n user_item_array = (item_em + item_b) @ (user_em + user_b).transpose(0, 1)\n preds = self._prob_to_class(user_item_array).numpy()\n\n return preds","def als(user_ids : numpy.ndarray, item_ids : numpy.ndarray,\n ratings : numpy.ndarray, num_item_factors : int,\n num_users: int, num_items : int, min_r_decrease=0.01,\n max_iterations=200, algorithm=1):\n # allocate \"user_factors\" and \"item_factors\"\n num_user_factors = num_item_factors + 1\n user_factors = numpy.random.uniform(-1, 1, num_users * num_user_factors)\n item_factors = numpy.random.uniform(-1, 1, num_items * num_item_factors)\n\n # argument construction\n user_ids_ptr = user_ids.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n item_ids_ptr = item_ids.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n\n ratings_length = len(ratings)\n ratings_ptr = ratings.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n\n user_factors_length = len(user_factors)\n user_factors_ptr = user_factors.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n\n item_factors_length = len(item_factors)\n item_factors_ptr = item_factors.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\n\n iterations = _dll.als_from_python(\n user_ids_ptr, item_ids_ptr, ratings_length, ratings_ptr,\n num_item_factors, user_factors_length, user_factors_ptr,\n item_factors_length, item_factors_ptr, ctypes.c_double(min_r_decrease),\n max_iterations, algorithm)\n\n return user_factors, item_factors, iterations","def NMF(model, maxIter=100, beliefs=None, verbose=False):\n if beliefs is None: beliefs = [Factor([Xi],1.0/Xi.states) for Xi in model.X]\n \n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\n for f in model.factors:\n m = f.log()\n for v in f.vars: m *= beliefs[v]\n lnZ += m.sum()\n if verbose: print(\"Iter 0: \"+str(lnZ))\n\n for t in xrange(1,maxIter+1): # for each iteration:\n # Update all the beliefs via coordinate ascent:\n for Xi in model.X: # for each variable, \n bNew = 0.0 # compute E[ log f ] as a function of Xi:\n for f in model.factorsWith(Xi,copy=False): # for each factor f_a, compute:\n m = f.log() # E[log f_a] = \\sum \\log f_a \\prod b_v\n for v in f.vars - [Xi]: m *= beliefs[v]\n bNew += m.marginal([Xi]) # sum them up to get E[log f]\n bNew -= bNew.max() # (numerical issues)\n bNew = bNew.exp()\n bNew /= bNew.sum() # set b(Xi) = exp( E[log f] ) / Z\n beliefs[Xi] = bNew\n #\n # Compute the lower bound on the partition function:\n # E_b [ log f ] + H(b) = \\sum_a E[log f_a] + \\sum_i H(b_i) for independent beliefs\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\n for f in model.factors:\n m = f.log()\n for v in f.vars: m *= beliefs[v]\n lnZ += m.sum()\n if verbose: print(\"Iter \"+str(t)+\": \"+str(lnZ))\n return lnZ,beliefs","def final_recommendation_score_matrix_helper_for_different_knn_types(self, type_of_method, index_matrix, value_matrix):\n if type_of_method == \"user\":\n for i in range(index_matrix.shape[1]):\n temp = index_matrix[:,i].astype(int)\n k_similar_users_profiles = self.utility_matrix[temp]\n k_similar_users_similarity_values = value_matrix[:,i]\n self.final_score_matrix[i,:] = np.dot(k_similar_users_similarity_values,k_similar_users_profiles)\n elif type_of_method == \"item\":\n for i in range(index_matrix.shape[1]):\n temp = index_matrix[:,i].astype(int)\n k_similar_item_profiles = self.utility_matrix.T[temp]\n k_similar_item_similarity_values = value_matrix[:,i]\n self.final_score_matrix[:,i] = np.dot(k_similar_item_similarity_values,k_similar_item_profiles)","def get_users_features_matrix(games_features_matrix: csr_matrix, users_games_matrix: csr_matrix) -> csr_matrix:\n logging.getLogger(__name__).debug('Users features matrix calculating...')\n users_features_matrix = users_games_matrix * games_features_matrix\n logging.getLogger(__name__).debug('users_features_matrix.shape: ' + str(users_features_matrix.shape))\n return users_features_matrix","def NMF(X,r):\n nmf_mdl = nmf.NMF(X,num_bases=r)\n nmf_mdl.initialization()\n nmf_mdl.factorize()\n return nmf_mdl.W,nmf_mdl.H,np.dot(nmf_mdl.W,nmf_mdl.H)","def fit(self, data, num_features, lambda_user, lambda_item, gamma):\n user_matrix, item_matrix = self.init_matrix(data, num_features)\n nnz_users, nnz_items = data.nonzero()\n nnz_data = list(zip(nnz_users, nnz_items))\n for it in tqdm(range(self.num_epochs)):\n gamma /= 1.1\n np.random.shuffle(nnz_data)\n for u, i in nnz_data:\n user = user_matrix[u, :]\n item = item_matrix[:, i]\n err = data[u, i] - user @ item\n user_matrix[u, :] += gamma * (err * item - lambda_user * user)\n item_matrix[:, i] += gamma * (err * user - lambda_item * item)\n\n self.user_matrix = user_matrix\n self.item_matrix = item_matrix","def evaluate_hmdb51_fusion():\n vlen = 0\n ob_suffix = '-max.feat.npy.gz'\n fv_suffix = '_fv.npy.gz'\n ob_root = '/home/syq/research_final/data/features/ob_hmdb51_pooled_python/'\n fv_root = '/home/syq/research_final/data/dense-traj/fv_hmdb51_python/'\n hmdb_splits = 'testTrainMulti_7030_splits/'\n categories = os.listdir(fv_root)\n weight = 1.0\n weights = [i / 20.0 for i in range(21)]\n acc_to_weights = {}\n\n for weight in weights:\n print \"Weight: %.2f\" % weight\n accs = np.zeros(3)\n for splitnum in range(1,4):\n ts = time.time()\n trainfiles, testfiles = hmdb51_splits.loadsplit(categories,\n hmdb_splits,\n splitnum)\n print 'Have %d train files' % len(trainfiles)\n print 'Have %d test files' % len(testfiles)\n\n if not vlen:\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(trainfiles[0][0][:-4],\n ob_suffix)),\"rb\")\n vlen_ob = len(np.load(fp))\n fp.close()\n print \"OB vector length is %d\" % vlen_ob\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(trainfiles[0][0][:-4],\n fv_suffix)),\"rb\")\n vlen_fv = len(np.load(fp))\n fp.close()\n print \"IDTFV vector length is %d\" % vlen_fv\n\n Dtrain_ob = np.zeros( (len(trainfiles),vlen_ob), np.float32 )\n Dtrain_fv = np.zeros( (len(trainfiles),vlen_fv), np.float32 )\n\n Ytrain = np.ones ( (len(trainfiles) )) * -1000\n\n for fi,f in enumerate(trainfiles):\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\n ob_suffix)),\"rb\")\n Dtrain_ob[fi][:] = np.load(fp)\n fp.close()\n Ytrain[fi] = f[1]\n\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\n fv_suffix)),\"rb\")\n Dtrain_fv[fi][:] = np.load(fp)\n fp.close()\n\n Dtest_ob = np.zeros( (len(testfiles),vlen_ob), np.float32 )\n Dtest_fv = np.zeros( (len(testfiles),vlen_fv), np.float32 )\n\n Ytest = np.ones ( (len(testfiles) )) * -1000\n\n for fi,f in enumerate(testfiles):\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\n ob_suffix)),\"rb\")\n Dtest_ob[fi][:] = np.load(fp)\n fp.close()\n Ytest[fi] = f[1]\n\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\n fv_suffix)),\"rb\")\n Dtest_fv[fi][:] = np.load(fp)\n fp.close()\n\n \"\"\"\n Early fusion\n Dtrain = np.hstack((Dtrain_ob, Dtrain_fv))\n Dtest = np.hstack((Dtest_ob, Dtest_fv))\n\n clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\n acc = clf.fit(Dtrain, Ytrain).score(Dtest, Ytest)\n \"\"\"\n fv_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\n\n ob_clf = OneVsRestClassifier(estimator=SVC(C=10,\n cache_size=1000,\n kernel='linear',\n probability=True),\n n_jobs=-1)\n\n # Get probabilities for late fusion\n Dtrain_fv = fv_clf.fit(Dtrain_fv, Ytrain).decision_function(Dtrain_fv)\n Dtrain_ob = ob_clf.fit(Dtrain_ob, Ytrain).decision_function(Dtrain_ob)\n Dtest_fv = fv_clf.decision_function(Dtest_fv)\n Dtest_ob = ob_clf.decision_function(Dtest_ob)\n\n # Scale decision values b/w 0 and 1\n Dtrain_fv = preprocessing.normalize(Dtrain_fv)\n Dtrain_ob = preprocessing.normalize(Dtrain_ob)\n Dtest_fv = preprocessing.normalize(Dtest_fv)\n Dtest_ob = preprocessing.normalize(Dtest_ob)\n\n # Late fusion\n scores_train = (Dtrain_fv * weight) + (Dtrain_ob * (1 - weight))\n latefusion_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=-1)\n latefusion_clf.fit(scores_train, Ytrain)\n\n scores_test = (Dtest_fv * weight) + (Dtest_ob * (1 - weight))\n acc = latefusion_clf.score(scores_test, Ytest)\n print 'Fold', splitnum, 'late fusion acc', acc\n print \"Train & testing time %.3f\" % (time.time() - ts)\n accs[splitnum-1] = acc\n acc_to_weights[weight] = accs\n\n print \"Mean accuracy: %.3f\" % accs.mean()\n with open(\"hmdb51_weight_gridsearch.txt\", \"w\") as f:\n for weight, accs in acc_to_weights.items():\n f.write(str(weight) + str(accs) + '\\n')\n return acc_to_weights\n\n \"\"\"\n with open('fv_hmdb51_accs.txt', 'w') as f:\n f.write(\"%s\\nMean:%.3f\" % (str(accs), np.mean(accs)))\n \"\"\"","def mrr(self):\n _test = self.drop_bad_ratings()\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\n ['user', 'item', 'rating_x', 'rating_y']]\n nott = np.vectorize(lambda x: not x)\n mrrs = []\n for user in merged.user.unique():\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\n true_ratings = frame.rating_x.values\n positions = np.where(nott(np.isnan(true_ratings)))[0]\n if len(positions) > 0:\n mrrs.append(1 / (positions[0] + 1))\n else:\n mrrs.append(0)\n\n return sum(mrrs) / len(mrrs)","def feature_processing(array2d):\n new_array2d = np.zeros([array2d.shape[0], 29])\n # items/ orders\n new_array2d[:, 0] = array2d[:, 4] / array2d[:, 3]\n # cancels / orders\n new_array2d[:, 1] = array2d[:, 5] / array2d[:, 3]\n # returns / items\n new_array2d[:, 2] = array2d[:, 6] / array2d[:, 4]\n # voucher / orders\n new_array2d[:, 3] = array2d[:, 10] / array2d[:, 3]\n # female_items / female_items + male_items\n new_array2d[:, 4] = array2d[:, 15] / ([1 if x == 0 else x for x in (array2d[:, 15] + array2d[:, 16])])\n # male_items / female_items + male_items\n new_array2d[:, 5] = array2d[:, 16] / ([1 if x == 0 else x for x in (array2d[:, 15] + array2d[:, 16])])\n # unisex_items / items\n new_array2d[:, 6] = array2d[:, 17] / array2d[:, 4]\n # wapp_items / items\n new_array2d[:, 7] = array2d[:, 18] / array2d[:, 4]\n # wftw_items / items\n new_array2d[:, 8] = array2d[:, 19] / array2d[:, 4]\n # mapp_items / items\n new_array2d[:, 9] = array2d[:, 20] / array2d[:, 4]\n # wacc_items / items\n new_array2d[:, 10] = array2d[:, 21] / array2d[:, 4]\n # macc_items / items\n new_array2d[:, 11] = array2d[:, 22] / array2d[:, 4]\n # mftw_items / items\n new_array2d[:, 12] = array2d[:, 23] / array2d[:, 4]\n # wspt_items / items\n new_array2d[:, 13] = array2d[:, 24] / array2d[:, 4]\n # mspt_items / items\n new_array2d[:, 14] = array2d[:, 25] / array2d[:, 4]\n # curvy_items / items\n # Curvy item has a strong correlation with gender, however they are very right-skewed use np.power(1/6) to smooth it\n new_array2d[:, 15] = np.power(array2d[:, 26] / array2d[:, 4], 1 / 6)\n # sacc_items / items\n new_array2d[:, 16] = array2d[:, 27] / array2d[:, 4]\n # msite_orders / orders\n new_array2d[:, 17] = array2d[:, 28] / array2d[:, 3]\n # desktop_orders / orders\n new_array2d[:, 18] = array2d[:, 29] / array2d[:, 3]\n # android_orders / orders\n new_array2d[:, 19] = array2d[:, 30] / array2d[:, 3]\n # ios_orders / orders\n new_array2d[:, 20] = array2d[:, 31] / array2d[:, 3]\n # other_device_orders / orders\n new_array2d[:, 21] = array2d[:, 32] / array2d[:, 3]\n # work_orders / orders\n new_array2d[:, 22] = array2d[:, 33] / array2d[:, 3]\n # home_orders / orders\n new_array2d[:, 23] = array2d[:, 34] / array2d[:, 3]\n # parcelpoint_orders / orders\n new_array2d[:, 24] = array2d[:, 35] / array2d[:, 3]\n # other_collection_orders / orders\n new_array2d[:, 25] = array2d[:, 36] / array2d[:, 3]\n # average_discount_onoffer\n new_array2d[:, 26] = array2d[:, 39]\n # average_discount_used\n new_array2d[:, 27] = array2d[:, 40]\n # revenue / order\n new_array2d[:, 28] = array2d[:, 41] / array2d[:, 3]\n\n # normalize by each feature\n new_array2d = normalize(new_array2d, axis=0, norm='max')\n return new_array2d","def __init__(\n self,\n n_users,\n n_products,\n n_factors=20,\n optimizer=torch.optim.SGD,\n lr=0.001,\n l2=0,\n momentum=0,\n loss_fn=nn.BCEWithLogitsLoss,\n activation=nn.Sigmoid,\n ):\n super(NNMatrixFactorization, self).__init__()\n\n self.l2 = l2\n self.lr = lr\n self.momentum = momentum\n self.user_factors = ScaledEmbedding(n_users, n_factors)\n self.product_factors = ScaledEmbedding(n_products, n_factors)\n self.user_bias = ZeroEmbedding(n_users, 1)\n self.product_bias = ZeroEmbedding(n_products, 1)\n\n self.activation = activation()\n self.loss_fn = loss_fn()\n self.optimizer = optimizer(\n self.parameters(), lr=self.lr, weight_decay=self.l2, momentum=self.momentum\n )","def get_scores(self):\n hist = self.confusion_matrix\n # hist = [TN,FP;FN,TP]\n acc = np.diag(hist).sum() / hist.sum()\n acc_cls = np.diag(hist) / hist.sum(axis=1)\n acc_cls = np.nanmean(acc_cls)\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\n # iou = iu.sum() / self.n_classes\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\n freq = hist.sum(axis=1) / hist.sum()\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\n cls_iou = dict(zip(range(self.n_classes), iu))\n\n ##############################################\n tn = hist[0, 0]\n tp = np.diag(hist).sum() - tn\n fp = np.triu(hist, 1).sum()\n fn = np.tril(hist, -1).sum()\n precision = tp / (tp + fp)\n recall = tp / (tp + fn)\n f1 = 2 * precision * recall / (precision + recall)\n\n # for medical img, img_seg \\in [0,1]\n dice = 2 * tp / (tp + tp + fn + fp)\n # dice = f1-score\n dsc = 2 * tp / (tp + fn + fp)\n # dsc = jaccard\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\n # voe = 1 - dsc\n\n k2 = {\n # \"Overall Acc: \\t\": acc,\n 'Mean Acc': float(judge_nan(acc_cls)),\n # \"FreqW Acc : \\t\": fwavacc,\n 'Mean IoU': float(judge_nan(mean_iou)),\n 'F1-score': float(judge_nan(f1)),\n 'DSC': float(judge_nan(dsc)),\n 'Precision': float(judge_nan(precision)),\n 'Recall': float(judge_nan(recall)),\n }\n\n return k2","def predict(user_id, item_id, ratings):\n\n # convert long to wide\n ratings_wide = ratings.pivot(index='user', columns='movie', values='rating')\n\n # compute user similarities\n similarities = compute_similarities(user_id, ratings_wide)\n \n prediction = predict_rating(item_id, ratings_wide, similarities, N=N_NEIGHBORS)\n \n return prediction","def __factor_matrix(self, R, K, alpha, steps, beta, error_limit):\n # Transform regular array to numpy array\n R = numpy.array(R)\n\n # Generate P - N x K\n # Use random values to start. Best performance\n N = len(R)\n M = len(R[0])\n P = numpy.random.rand(N, K)\n\n # Generate Q - M x K\n # Use random values to start. Best performance\n Q = numpy.random.rand(M, K)\n Q = Q.T\n\n error = 0\n\n # iterate through max # of steps\n for step in xrange(steps):\n\n # iterate each cell in r\n for i in xrange(len(R)):\n for j in xrange(len(R[i])):\n if R[i][j] > 0:\n\n # get the eij (error) side of the equation\n eij = R[i][j] - numpy.dot(P[i, :], Q[:, j])\n\n for k in xrange(K):\n # (*update_rule) update pik_hat\n P[i][k] = P[i][k] + alpha * (2 * eij * Q[k][j] - beta * P[i][k])\n\n # (*update_rule) update qkj_hat\n Q[k][j] = Q[k][j] + alpha * ( 2 * eij * P[i][k] - beta * Q[k][j] )\n\n # Measure error\n error = self.__error(R, P, Q, K, beta)\n\n # Terminate when we converge\n if error < error_limit:\n break\n\n # track Q, P (learned params)\n # Q = Products x feature strength\n # P = Users x feature strength\n self.Q = Q.T\n self.P = P\n\n self.__print_fit_stats(error, N, M)","def recommend(self, user_id, N=10):\n scores = self.user_factors[user_id] @ self.product_factors.T\n best = np.argpartition(scores, -N)[-N:]\n return sorted(zip(best, scores[best]), key=lambda x: -x[1])","def weighted_majority_vote(c_pred,m_pred,f_pred,acc_c,acc_m,acc_f, dataset):\n c,m,f = np.argmax(c_pred),np.argmax(m_pred),np.argmax(f_pred)\n coarse = np.zeros(2)\n middle = np.zeros(4)\n fine = np.zeros(10)\n\n if dataset == 'cifar10':\n middle = np.zeros(5)\n coarse[c] = 1\n middle[m] = 1\n fine[f] = 1\n res = np.zeros(10)\n w1 = np.log(acc_c/(1.-acc_c))\n w2 = np.log(acc_m/(1.-acc_m))\n w3 = np.log(acc_f/(1.-acc_f))\n if dataset == 'cifar10':\n for i in range(10):\n if i <2:\n res[i] = w1*coarse[0] + w2*middle[0] + w3*fine[i]\n elif 2<=i <4:\n res[i] = w1*coarse[0] + w2*middle[1] + w3*fine[i]\n elif 4 <=i<6:\n res[i] = w1*coarse[1] + w2*middle[2] + w3*fine[i]\n elif 6<=i<8:\n res[i] = w1*coarse[1] + w2*middle[3] + w3*fine[i]\n else:\n res[i] = w1*coarse[1] + w2*middle[4] + w3*fine[i]\n else :\n for i in range(10):\n if i <3:\n res[i] = w1*coarse[0] + w2*middle[0] + w3*fine[i]\n elif 3<=i <5:\n res[i] = w1*coarse[0] + w2*middle[1] + w3*fine[i]\n elif 5 <=i<8:\n res[i] = w1*coarse[1] + w2*middle[2] + w3*fine[i]\n else:\n res[i] = w1*coarse[1] + w2*middle[3] + w3*fine[i]\n index = np.argmax(res)\n return(index)","def _compute_mu_factor2(*input_mols):\n mu_factor = 1\n for mol in input_mols:\n mu_factor *= np.prod(fact(mol))\n return mu_factor","def update_model(self):\n temp_uservisits = self._uservisits\n unique_users = temp_uservisits['userid'].unique()\n for itemidx, itemid in self._allitems.iterrows():\n self.__itemid2idx[str(itemid['itemid'])] = itemidx\n self.__itemidx2id[itemidx] = str(itemid['itemid'])\n for useridx, userid in enumerate(unique_users):\n self.__userid2idx[str(userid)] = useridx\n self.__useridx2id[useridx] = str(userid)\n useritem = set(temp_uservisits[temp_uservisits['userid'] == userid]['itemid'].astype('str').values)\n allitem = set(self.__itemid2idx.keys())\n itemsnotinuser = allitem - useritem\n self.__useridx2nvitems[useridx] = list(itemsnotinuser)\n temp = pandas.DataFrame([{\"userid\": userid, \"itemid\": t, \"rating\": 0, \"timestamp\": \"NA\"} for t in itemsnotinuser])\n temp_uservisits = pandas.concat([temp_uservisits, temp])\n userid = temp_uservisits['userid'].values\n itemid = temp_uservisits['itemid'].values\n rating = temp_uservisits['rating'].values\n useridx = [self.__userid2idx[str(int(uid))] for uid in userid]\n itemidx = [self.__itemid2idx[str(int(iid))] for iid in itemid]\n model = self.__get_model(num_users=len(temp_uservisits['userid'].unique()), num_items=len(self._allitems),\n mf_dim=self.__numtopics)\n if self.__learner.lower() == \"adagrad\":\n model.compile(optimizer=Adagrad(lr=self.__learningrate), loss='binary_crossentropy')\n elif self.__learner.lower() == \"rmsprop\":\n model.compile(optimizer=RMSprop(lr=self.__learningrate), loss='binary_crossentropy')\n elif self.__learner.lower() == \"adam\":\n model.compile(optimizer=Adam(lr=self.__learningrate), loss='binary_crossentropy')\n else:\n model.compile(optimizer=SGD(lr=self.__learningrate), loss='binary_crossentropy')\n\n for epoch in range(self.__numiterations):\n t1 = time.time()\n hist = model.fit([numpy.array(useridx), numpy.array(itemidx)], numpy.array(rating),\n batch_size=self.__batchsize, nb_epoch=1, verbose=0, shuffle=True)\n t2 = time.time()\n self.__recommender1 = model\n rating = list(map(numpy.double, rating))\n self.__itemuser = csr_matrix((rating, (useridx, itemidx)), shape=(len(set(useridx)), len(set(itemidx))))\n self.__recommender2 = implicit.als.AlternatingLeastSquares(factors=self.__numtopics)\n self.__recommender2.fit(self.__itemuser)","def create_matrix(ratings_df, jokes_df):\r\n \"\"\" note: empty entries are populated with zeros \"\"\"\r\n\r\n matrix_handler = matrix_object()\r\n\r\n num_joke_features = 5\r\n\r\n ''' add all joke features '''\r\n for row_idx in range(0, jokes_df.shape[0]):\r\n joke_idx = int(jokes_df.iloc[row_idx][\"Idx\"])\r\n isAggressive = jokes_df.iloc[row_idx][\"isAggressive\"]\r\n isIncongruence = jokes_df.iloc[row_idx][\"isIncongruence\"]\r\n generation = jokes_df.iloc[row_idx][\"Generation\"]\r\n isMillenial = (generation == \"Millenial\")\r\n isGenX = (generation == \"Gen X\")\r\n isGenZ = (generation == \"Gen Z\")\r\n\r\n if(int(isMillenial) == 1.0 and int(isGenX) == 1.0):\r\n raise Valueerror()\r\n\r\n matrix_handler.add_value(joke_idx - 1, 0, int(isAggressive))\r\n matrix_handler.add_value(joke_idx - 1, 1, int(isIncongruence))\r\n matrix_handler.add_value(joke_idx - 1, 2, int(isMillenial))\r\n matrix_handler.add_value(joke_idx - 1, 3, int(isGenX))\r\n matrix_handler.add_value(joke_idx - 1, 4, int(isGenZ))\r\n\r\n ''' add all ratings '''\r\n for row_idx in range(0, ratings_df.shape[0]):\r\n for joke_idx in range(1, 122):\r\n col_name = \"joke\" + str(joke_idx)\r\n matrix_handler.add_value(joke_idx - 1, row_idx + num_joke_features, ratings_df.iloc[row_idx][col_name])\r\n\r\n matrix = matrix_handler.compile_matrix()\r\n new_df = matrix_handler.to_df(matrix)\r\n\r\n return matrix, new_df","def feature_selection_classifier_3(array2d):\n newArray2d = np.zeros([array2d.shape[0], 18])\n # female_items / female_items + male_items\n newArray2d[:, 0] = array2d[:, 4]\n # male_items / female_items + male_items\n newArray2d[:, 1] = array2d[:, 5]\n # wapp_items / items\n newArray2d[:, 2] = array2d[:, 7]\n # wftw_items / items\n newArray2d[:, 3] = array2d[:, 8]\n # mapp_items / items\n newArray2d[:, 4] = array2d[:, 9]\n # wacc_items / items\n newArray2d[:, 5] = array2d[:, 10]\n # macc_items / items\n newArray2d[:, 6] = array2d[:, 11]\n # mftw_items / items\n newArray2d[:, 7] = array2d[:, 12]\n # curvy_items / items\n newArray2d[:, 8] = array2d[:, 15]\n # msite_orders / orders\n newArray2d[:, 9] = array2d[:, 17]\n # desktop_orders / orders\n newArray2d[:, 10] = array2d[:, 18]\n # android_orders / orders\n newArray2d[:, 11] = array2d[:, 19]\n # ios_orders / orders\n newArray2d[:, 12] = array2d[:, 20]\n # other_device_orders / orders\n newArray2d[:, 13] = array2d[:, 21]\n # home_orders / orders\n newArray2d[:, 14] = array2d[:, 23]\n # other_collection_orders / orders\n newArray2d[:, 15] = array2d[:, 25]\n # average_discount_onoffer\n newArray2d[:, 16] = array2d[:, 26]\n # average_discount_used\n newArray2d[:, 17] = array2d[:, 27]\n return newArray2d","def fit(self):\n\n rmse_old = .0\n for epoch in range(self.epochs):\n error_final = .0\n\n for user, item, feedback in self.feedback_triples:\n pu = self.p[user] + self.y_sum_rows(user)\n\n # Calculate error\n eui = feedback - self._predict_svd_plus_plus_score(user, item, pu, False)\n error_final += (eui ** 2.0)\n\n # update bu and bi\n self.bu[user] += self.bias_learn_rate * (eui - self.delta_bias * self.bu[user])\n self.bi[item] += self.bias_learn_rate * (eui - self.delta_bias * self.bi[item])\n\n # Adjust the factors\n norm_eui = eui / self.n_u[user]\n\n i_f = self.q[item]\n\n # Compute factor updates\n delta_u = np.subtract(np.multiply(eui, i_f), np.multiply(self.delta, self.p[user]))\n self.p[user] += np.multiply(self.learn_rate, delta_u)\n\n delta_i = np.subtract(np.multiply(eui, pu), np.multiply(self.delta, i_f))\n self.q[item] += np.multiply(self.learn_rate, delta_i)\n\n # update y (implicit factor)\n common_update = norm_eui * i_f\n\n for j in self.items_id_seen_by_user[user]:\n delta_y = np.subtract(common_update, self.delta * self.y[j])\n self.y[j] += self.learn_rate * delta_y\n\n rmse_new = np.sqrt(error_final / self.train_set[\"number_interactions\"])\n\n if np.fabs(rmse_new - rmse_old) <= self.stop_criteria:\n break\n else:\n rmse_old = rmse_new","def ndpm(self):\n\n merged = pd.merge(left=self.test, right=self.predict, on=['user', 'item'], how='inner')[\n ['user', 'rating_x', 'rating_y']]\n ndpms = []\n for user in merged.user.unique():\n frame = merged[merged.user == user]\n if frame.shape[0] <= 1:\n continue\n C_plus = self.num_of_ordered_positive(frame, 'rating_x', 'rating_y')\n C_minus = self.num_of_ordered_negative(frame, 'rating_x', 'rating_y')\n C_u = self.num_of_ordered(frame, 'rating_x')\n if C_u == 0:\n continue\n C_s = self.num_of_ordered(frame, 'rating_y')\n C_u0 = C_u - (C_plus + C_minus)\n ndpms.append(1 - (C_minus + 0.5 * C_u0) / C_u)\n\n return sum(ndpms) / len(ndpms)","def gen_W(users, items, ratings):\n\n # initiate graph\n user = users.tolist()\n item = items.tolist()\n rating = ratings.tolist()\n B = nx.Graph()\n B.add_nodes_from(user, bipartite=0)\n B.add_nodes_from(item, bipartite=1)\n\n # create edges\n for i in range(len(user)):\n B.add_edges_from([(user[i], item[i])])\n B[user[i]][item[i]]['weight'] = rating[i]\n\n users_unique = users.unique() \n items_unique = items.unique()\n\n # BiAdjacency matrix - for bipartite network\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\n\n # sparce form of Biadjacency matrix\n W = spa.csr_matrix(W)\n print('Shape of W: '+str(W.shape))\n\n return W, users_unique, items_unique","def alternate_ls (u_num, Y, P, C, reg):\n\n\t# get # of items/users and # of latent factors\n\t[i_num, f_num] = Y.shape\n\n\t# output buffer\n\tX = np.zeros((u_num, f_num))\n\n\t# precalculate YtY to improve the performance\n\tYtY = Y.T * Y\n\n\t# iterate over each user/item\n\tfor u in range(u_num):\n\n\t\t# store the diagonal elements of the matrix Cu discussed in the paper in a vector\n\t\tCu = C[u,:]\n\n\t\t# store the coresponding row/column of the preference matrix\n\t\tPu = P[u,:]\n\n\t\t# compute Cu-I\n\t\tCu_I = Cu - 1\n\n\t\t# calculate Yt(Cu-I)Y\n\t\tYtCu_IY = np.zeros((f_num, f_num))\n\t\tCuIY = np.multiply(Y, Cu_I.T) # weight each row of Y with Cu-I\n\t\tfor row in range(f_num):\n\t\t\tfor col in range(f_num):\n\t\t\t\tYtCu_IY[row,col] = Y[:,row].T * CuIY[:,col]\n\t\t\n\t\t# left term : ((YtCuY + regI)^(-1)) = (YtY + Yt(Cu-I)Y + regI)^(-1)\n\t\tleft_inv = YtY + YtCu_IY + reg*np.eye(f_num)\n\t\tleft = np.linalg.inv(left_inv)\n\n\t\t# right term : YtCuPu\n\t\tright = Y.T * np.multiply(Cu.T, Pu.T)\n\n\t\t# compute the latent factor of the user/item\n\t\tx = left * right\n\t\t\n\t\t# store it in a matrix\n\t\tX[u,:] = x.T\n\n\t# return an MxF or NxF matrix\n\treturn np.matrix(X)","def calc_score(self, user_id, item_id): \n p = np.dot(self.U[user_id], self.V[item_id])\n if self.trunc_score_rule==None:pass\n else: p=self.trunc_score_rule(p)\n \n return p","def evaluate_ucf50_fusion():\n accs = np.zeros(3)\n ob_suffix = '-max.feat.npy.gz'\n fv_suffix = '_fv.npy.gz'\n ob_root = '/home/syq/research_final/data/features/ob_ucf50_pooled_python/'\n fv_root = '/home/syq/research_final/data/features/fv_ucf50_python/'\n fv_groups, full, sets = utility.split_data(fv_root,\n suffix=fv_suffix,\n useLooCV=False)\n\n ob_groups, _, _ = utility.split_data(ob_root,\n suffix=ob_suffix,\n useLooCV=False)\n weights = [i / 20.0 for i in range(8, 13)]\n acc_to_weights = {}\n\n for weight in weights:\n print \"Weight: %.2f\" % weight\n accs = np.zeros(2)\n for i in xrange(2):\n ts = time.time()\n Dtrain_fv, Dtest_fv, Ytrain, Ytest = utility.load_groups(\n fv_groups, np.setdiff1d(full, sets[i]),\n sets[i], scale=False, verbose=False)\n\n Dtrain_ob, Dtest_ob, Ytrain, Ytest = utility.load_groups(\n ob_groups, np.setdiff1d(full, sets[i]),\n sets[i], scale=False, verbose=False)\n\n fv_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\n\n ob_clf = OneVsRestClassifier(estimator=SVC(C=10,\n cache_size=1000,\n kernel='linear',\n probability=True),\n n_jobs=-1)\n\n # Get probabilities for late fusion\n Dtrain_fv = fv_clf.fit(Dtrain_fv, Ytrain).decision_function(Dtrain_fv)\n Dtrain_ob = ob_clf.fit(Dtrain_ob, Ytrain).decision_function(Dtrain_ob)\n Dtest_fv = fv_clf.decision_function(Dtest_fv)\n Dtest_ob = ob_clf.decision_function(Dtest_ob)\n\n # Scale decision values b/w 0 and 1\n Dtrain_fv = preprocessing.normalize(Dtrain_fv)\n Dtrain_ob = preprocessing.normalize(Dtrain_ob)\n Dtest_fv = preprocessing.normalize(Dtest_fv)\n Dtest_ob = preprocessing.normalize(Dtest_ob)\n\n # weighted averaging\n scores_train = (Dtrain_fv * weight) + (Dtrain_ob * (1 - weight))\n latefusion_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=-1)\n latefusion_clf.fit(scores_train, Ytrain)\n\n scores_test = (Dtest_fv * weight) + (Dtest_ob * (1 - weight))\n latefusion_acc = latefusion_clf.score(scores_test, Ytest)\n print 'Fold', i, 'late fusion acc', latefusion_acc\n print \"Train & testing time %.3f\" % (time.time() - ts)\n accs[i] = latefusion_acc\n\n print \"Mean accuracy: %.3f\" % accs.mean()\n with open(\"fv_ucf50_accs_5fold_gridsearch.txt\", \"w\") as f:\n for weight, accs in acc_to_weights.items():\n f.write(str(weight) + str(accs) + '\\n')\n return acc_to_weights","def _predict_user_item(self, user, item):\n if not isinstance(user, int):\n user = self._user_to_ndx[user]\n if not isinstance(item, int):\n item = self._item_to_ndx[item]\n\n try:\n rating_mean = self._averages[user]\n except AttributeError:\n raise RuntimeError('Must fit before predicting')\n\n other_users = [other for other in self._users if other != user and\n np.isfinite(self._votes[other][item])]\n weights = np.array([self._weight(user, other)\n for other in other_users])\n deviations = np.array([self._votes[other][item] - self._averages[other]\n for other in other_users])\n\n weight_sum = np.sum(np.absolute(weights))\n if weight_sum < _EPSILON:\n return rating_mean # No similar users, so guess their avg rating\n\n norm_const = 1 / weight_sum\n\n weighted_avg = np.sum(weights * deviations)\n return rating_mean + norm_const * weighted_avg","def construct_classifier_for_user(user_indexed_reviews, restaurant_indexed_reviews):\t\n # compute all_reviews\n all_reviews = []\n for restaurant in restaurant_indexed_reviews:\n reviews_content = ''\n for user in restaurant_indexed_reviews[restaurant]:\n reviews = restaurant_indexed_reviews[restaurant][user]\n for review in reviews:\n reviews_content += review['text'][0:len(review['text'])-1]\n all_reviews.append(reviews_content)\n\n print 'extract feature...'\n # construct classifier\n X_total, y_total, restaurant_feature = extracttfidf_user(user_indexed_reviews, all_reviews, restaurant_indexed_reviews)\n\n print 'construct classifier...'\n i = 0\n for user in user_indexed_reviews:\n print i\n i += 1\n classifier = MultinomialNB(alpha=.01)\n X_train = X_total[user]\n y_train = y_total[user]\n if X_train != None:\n try:\n classifier.fit(X_train, y_train)\n update_rating(user, restaurant_feature, classifier, user_indexed_reviews, restaurant_indexed_reviews)\n except:\n continue","def model_frequency(ref, alt, bases_all_reads, f_vector, error_rates):\n # model Mx: NO alt allele\n if ref == alt:\n return np.array([error_rates[ref][eb] for eb in \"ACGT-\"])\n # model Mxy: two alleles\n mat = np.zeros((K, 5))\n for b, base in enumerate(\"ACGT-\"):\n for i, observed_base in enumerate(bases_all_reads):\n mat[i][b] = error_rates[base][observed_base]\n\n m2 = (mat * f_vector)[:, [bases_index[alt], bases_index[ref]]]\n alt_ref_f_vector = (m2 / m2.sum(axis=1)[:, np.newaxis]).sum(axis=0) / K\n\n l = [alt_ref_f_vector[0], ]*5\n l[bases_index[ref]] = alt_ref_f_vector[1]\n updated_f_vector = np.array(l)\n\n return updated_f_vector","def __init__(self, customer_vendor_full, valid_rating_mean):\r\n super(User_CF, self).__init__()\r\n self.customer_vendor_full = customer_vendor_full\r\n self.customer_vendor_ratings = self.select_features()\r\n self.customer_vendor_matrix = self.customer_vendor_ratings.pivot(\r\n index='customer_id', columns='vendor_id', values='mean_rating') # (26779, 100)\r\n self.rating_matrix = self.customer_vendor_matrix.fillna(0).values.astype(np.float32)\r\n self.valid_rating_mean = valid_rating_mean\r\n self.vendor2rating = self.get_vendors_mean()\r\n self.customer_similarity, = self.get_similarity()","def __init__(self, dim=20, nIter=5, lamb=0.05, alph=40,\n user_features=[\"user\"], item_features=[\"item\"]):\n self.setParams(dim,nIter, lamb, alph)\n self.user_features = {}\n self.item_features = {}\n self.factors = {}\n\n self.user_column_names = user_features\n self.item_column_names = item_features","def evaluate_model(test_user_item_matrix, user_mat, portfolio_mat):\r\n n = np.count_nonzero(~np.isnan(test_user_item_matrix))\r\n\r\n # keep track of the sum of squares\r\n sse = 0\r\n\r\n for user_id in test_user_item_matrix.index:\r\n for offer_id in test_user_item_matrix.columns.values:\r\n if ~np.isnan(test_user_item_matrix.loc[user_id, offer_id]):\r\n pred = predict(test_user_item_matrix, user_mat, portfolio_mat, user_id, offer_id)\r\n if pred:\r\n diff = test_user_item_matrix.loc[user_id, offer_id] - pred\r\n sse += diff ** 2\r\n return sse / n","def make_predictions(movies, ratings_train, ratings_test):\n ###TODO\n \n user_result = [] \n \n for index,row in ratings_test.iterrows():\n userid_test = row['userId']\n #print(\"userid_test::\",userid_test) \n movieid_test = row['movieId'] \n #print(\"movieid_test::\",movieid_test) \n x = list(movies[movies.movieId==movieid_test]['features'])[0]\n #print(\"CSR_GOTT+X::\",x)\n #print(\"TYPE of CSR_GOTT_X::\",type(x))\n subset_train = ratings_train[ratings_train.userId == userid_test]\n #print(\"SUB MOVIE SET::\",subset_train)\n #print(\"TYPE of SUB MOVIE SET::\",type(x))\n total_if_zero=0\n rating_if_zero=0\n sum_main_result=0\n sum_cosine=0 \n for index1,row1 in subset_train.iterrows():\n userid_train = row1['userId']\n #print(\"userid_train::\",userid_train) \n if(userid_test == userid_train ):\n #print(\"HII IN IFFF:::\")\n movieid_train = row1['movieId']\n #print(\"movieid_train::\",movieid_train)\n rating_train = row1['rating']\n #print(\"rating_train::\",rating_train)\n total_if_zero = total_if_zero + 1 \n rating_if_zero = rating_if_zero + rating_train\n y = list(movies[movies.movieId==movieid_train]['features'])[0]\n #print(\"CSR_GOTT_Y::\",y)\n #print(\"TYPE of CSR_GOTT_Y::\",type(y))\n result_cos = cosine_sim(x,y)\n sum_main_result += result_cos * rating_train\n sum_cosine += result_cos \n \n if(sum_main_result != 0):\n user_result.append(sum_main_result/sum_cosine)\n #print(\"user_result::\",user_result) \n else:\n user_result.append(rating_if_zero / total_if_zero)\n #print(\"user_result::\",user_result) \n \n return_result_arr = np.array(user_result) \n \n return return_result_arr\n \n pass","def predict(self, user_id, item_id):\n # DONEreturn prediction for given pair\n return self._user_factors[user_id, : ].dot(self._item_factors[item_id, :])","def get_user_vector(self, user_id):\r\n if user_id in self.df_ratmat.index:\r\n # user from base dataset\r\n return np.array([self.df_ratmat.loc[user_id]])\r\n # construct a vector out of app user rating data\r\n movies_rated = self.get_valid_user_ratings(user_id)\r\n movie_size = self.df_ratmat.shape[1]\r\n cols = [str(i) for i in range(1, movie_size + 1)]\r\n df = pd.DataFrame(columns=cols)\r\n new_row = {}\r\n for i, r in movies_rated[['item_id', 'rating']].iterrows():\r\n new_row[str(int(r['item_id']))] = int(r['rating'])\r\n df = df.append(new_row, ignore_index=True)\r\n # mark 0 (=not rated) if not rated by the user\r\n return df.fillna(0)","def _factorsX(self, inputs):\n return tensor.dot(inputs[0], self.wxf)","def print_maxes(mat):\r\n u_to_likes = load_or_create(\"/Matrix/UserIdToLikes.matrix\", create_matrix_user_likes)\r\n dict_names = load_or_create('/DICT/MovieIdToName.dict', create_dict_names)\r\n dict_ecc = load_or_create('/DICT/MovieIdToItemEccentricity.dict', create_dict_ecc)\r\n user_to_ecc = load_or_create('/DICT/UserIdToUserEccentricity.dict',createDictUserIdToUserEccentricity)\r\n dict_userid_to_moviesliked = load_or_create('/DICT/UserIdToLikedMovies.dict', create_dict_user_id_to_liked_items)\r\n\r\n dict_userid_to_recommends = dict()\r\n print(\"STARTING ECC CALC\")\r\n recommends = []\r\n for i in range(int(mat.shape[0]*0.5)):\r\n row = mat.getrow(i)\r\n if len(row.nonzero()[0]) != 0:\r\n # print(u_to_likes.getrow(i).nonzero()[1])\r\n if len(u_to_likes.getrow(i).nonzero()[1])<10 and user_to_ecc[i+1]>0:\r\n # print(\"Amount of recommends:\",len(row.nonzero()[0]))\r\n row = row.toarray()[0].tolist()\r\n max_val = max(val for val in row if str(row.index(val) + 1) not in dict_userid_to_moviesliked[i+1])\r\n print('SUM is:',sum(val for val in row if str(row.index(val) + 1) not in dict_userid_to_moviesliked[i+1]))\r\n print('SUM with all is:',sum(val for val in row))\r\n\r\n index_max=row.index(max_val) + 1\r\n\r\n recommends.append(\r\n [max_val, row.index(max_val) + 1, i + 1, [i + 1 for i in u_to_likes.getrow(i).nonzero()[1]],\r\n [row.index(max_val) + 1],user_to_ecc[i+1]])\r\n\r\n recommends = sorted(recommends, key=itemgetter(0))\r\n\r\n for i in recommends[-100:]:\r\n print(\"MAX id:\", i[1])\r\n print(\"MAX val:\", i[0])\r\n print(\"Users ECC:\",i[5])\r\n print(\"for user:\", i[2])\r\n print(\"MOVIES HE ALREADY LIKED\", 50 * \"=\")\r\n item_names_print(i[3], dict_names, dict_ecc)\r\n print(\"Movie Well recommend:\" + 50 * '*')\r\n item_names_print(i[4], dict_names, dict_ecc)\r\n print(50 * \"#\")","def test_matrix(self, tol):\n\n res_static = qml.QFT.compute_matrix(2)\n res_dynamic = qml.QFT(wires=[0, 1]).matrix()\n res_reordered = qml.QFT(wires=[0, 1]).matrix([1, 0])\n\n expected = np.array(\n [\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\n [0.5 + 0.0j, 0.0 + 0.5j, -0.5 + 0.0j, -0.0 - 0.5j],\n [0.5 + 0.0j, -0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j],\n [0.5 + 0.0j, -0.0 - 0.5j, -0.5 + 0.0j, 0.0 + 0.5j],\n ]\n )\n\n assert np.allclose(res_static, expected, atol=tol, rtol=0)\n assert np.allclose(res_dynamic, expected, atol=tol, rtol=0)\n\n expected_permuted = [\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\n [0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j, -0.5 + 0.0j],\n [0.5 + 0.0j, -0.5 + 0.0j, 0.0 + 0.5j, -0.0 - 0.5j],\n [0.5 + 0.0j, -0.5 + 0.0j, -0.0 - 0.5j, 0.0 + 0.5j],\n ]\n assert np.allclose(res_reordered, expected_permuted, atol=tol, rtol=0)","def calculate_total(self, calcu_user_n=20, user_n=20, item_n=10, seed=1):\n self._split_data(seed=seed)\n self._set_top(user_n=user_n, item_n=item_n)\n test_user_list = list(set(self.test['userId'].unique()))\n user_list = [test_user_list[random.randint(0, len(test_user_list)) - 1]\n for i in range(calcu_user_n)]\n hit = 0 # Hit score\n all_recom = 0 # num of all recommendations, calculate the accuracy rate\n like_item = 0 # num of the item the user likes in the test set, calculate the recall rate\n all_recom_set = set()\n all_item = set(self.train['movieId'].unique())\n item_popular = Counter(self.train['movieId'].values)\n ret = 0\n n = 0\n print('\\nCalculate all evaluation indicators...')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user, )\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n like_item += len(user_item)\n all_recom += len(recom_item)\n all_recom_set.update(recom_item)\n for rec in set([data[0] for data in recom_data]):\n ret += math.log(1 + item_popular.get(rec))\n n += 1\n print('\\nCalculate over')\n print('Precision is: ', hit / (all_recom * 1.0))\n print('Recall is: ', hit / (like_item * 1.0))\n print('Coverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\n print('Popularity is:', (ret / n * 1.0))","def prediction(prediction_file_name, clusters_list, svd_use_flag):\n \n coords = misc_functions.getWindowCoords()\n \n test_users = range(coords[0], coords[2] + 1) \n test_items = range(coords[1], coords[3] + 1)\n \n #print \"len(test_users) = \", len(test_users)\n #print \"len(test_items) = \", len(test_items)\n #print \"test_items = \", test_items\n \n # this matrix to be written as result finally\n #misc_functions.step()\n prediction_matrix = zeros((len(test_users), len(test_items)), dtype = float)\n \n training_matrix = scipy.io.mmio.mmread(\"history.mtx\").tocsr()\n \n item_X_meta_matrix = scipy.io.mmio.mmread(\"../../../well_done/items-metas_global.mtx\").toarray()\n \n # getting meta matrices for corresponding using metas\n meta_ctr = 0\n meta_matrices = []\n for meta in METAS_TO_USE:\n if svd_use_flag:\n meta_matrice_file_name = \"users-\" + METAS_TO_USE[meta] + \".svd.mtx\"\n else:\n meta_matrice_file_name = \"users-\" + METAS_TO_USE[meta] + \".mtx\"\n exec(\"meta_matrices.append(scipy.io.mmio.mmread(\\\"\" + meta_matrice_file_name + \"\\\").toarray())\")\n\n #user_counter = 0\n #for user in test_users:\n for cur_cluster in clusters_list:\n \n #print \"cur_cluster[0] = \", cur_cluster[0]\n user = int (cur_cluster[0].split(\"\\t\")[1])\n #print \"user #\", user\n \n #user_metas = {} - changed to list because of problem with dimension\n user_metas = []\n \n values = zeros((len(METAS_TO_USE), len(test_items)), dtype = float)\n meta_ctr = 0\n for meta in METAS_TO_USE:\n \n #print \" meta_matrices = \", meta_matrices\n #print \" meta_matrices[meta_ctr] = \", meta_matrices[meta_ctr]\n user_vector = meta_matrices[meta_ctr][user]\n #print \" user_vector = \", user_vector\n #print \" len(user_metas) = \", len(user_metas)\n #print \" meta_ctr = \", meta_ctr\n #print \"meta = \", meta\n #misc_functions.step()\n \n # normalizing counts of visited metas to use them as weights later\n if max(user_vector) != 0:\n user_metas.append(1.0 * user_vector / max(user_vector))\n else:\n user_metas.append(zeros((len(user_vector), ), dtype = float))\n #print \" user_metas[meta_ctr] = \", user_metas[meta_ctr]\n #print \" user_metas[meta_ctr].shape = \", user_metas[meta_ctr].shape\n \n #for item in test_items:\n for cluster in cur_cluster[1 : ]:\n start_cluster_item = int(cluster.split(\"\\t\")[0])\n stop_cluster_item = int(cluster.split(\"\\t\")[2])\n \n cluster_items = range(start_cluster_item, stop_cluster_item + 1)\n \n for item in cluster_items:\n meta_value = item_X_meta_matrix[item, meta]\n \n # PRICE\n if meta == 8:\n meta_value = priceToPriceCat(meta_value)\n \n # CITY HEURISTIC\n if meta == 11:\n if user_metas[meta_ctr][meta_value - 1] < CITY_TRESHOLD:\n values[:, item - coords[1]] *= CITY_COEF\n \"\"\"\n # DAYTIME\n if meta == 17:\n meta_value = dayTime(meta_value)\n \"\"\"\n \n #print \" meta_value = \", meta_value\n #print \" item = \", item\n #step()\n values[meta_ctr][item - coords[1]] = (user_metas[meta_ctr])[meta_value - 1]\n \n \"\"\"HEURISTICS \"\"\"\n \n \n \n \n \n \"\"\"\\\\ HEURISTICS \"\"\"\n\n meta_ctr += 1\n #print \"values[:, 0:10] = \", values[:, 0:10]\n prediction_vector = numpy.sum(META_WEIGHTS * values, axis = 0)\n #print \"prediction_vector[0:10] = \", prediction_vector[0:10]\n #print \"sum(prediction_vector) = \", sum(prediction_vector)\n prediction_matrix[user - coords[0]] = prediction_vector\n \n #step()\n \n# ===== END OF MAIN CYCLE ===== \n\n result_matrix = scipy.sparse.csr_matrix(prediction_matrix)\n scipy.io.mmio.mmwrite(prediction_file_name, result_matrix, field = 'real', precision = 5)","def test_init_ratings():\n env = FixedRating(num_users=50,\n num_items=50,\n rating_frequency=1.0,\n num_init_ratings=100)\n env.seed(0)\n _, _, ratings = env.reset()\n assert len(ratings) == 100\n for (user_id, item_id), (rating, context) in ratings.items():\n assert context.shape == (0,)\n assert user_id < 50\n assert item_id < 50\n if rating == 5.0:\n assert item_id >= 25\n else:\n assert item_id < 25","def proba_fm(m_pred,f_pred, dataset):\n p = np.zeros(10)\n if dataset == 'cifar10':\n for i in range(10):\n if i <4:\n if i <2:\n p[i] = (m_pred[0])*(f_pred[i]/np.sum(f_pred[0:2]))\n else:\n p[i] = (m_pred[1])*(f_pred[i]/np.sum(f_pred[2:4]))\n else:\n if i <6:\n p[i] = (m_pred[2])*(f_pred[i]/np.sum(f_pred[4:6]))\n elif i <8:\n p[i] = (m_pred[3])*(f_pred[i]/np.sum(f_pred[6:8]))\n else:\n p[i] = (m_pred[4])*(f_pred[i]/np.sum(f_pred[8:]))\n else :\n for i in range(10):\n if i <5:\n if i <3:\n p[i] = (m_pred[0])*(f_pred[i]/np.sum(f_pred[0:3]))\n else:\n p[i] = (m_pred[1])*(f_pred[i]/np.sum(f_pred[3:5]))\n else:\n if i <8:\n p[i] = (m_pred[2])*(f_pred[i]/np.sum(f_pred[5:8]))\n else:\n p[i] = (m_pred[3])*(f_pred[i]/np.sum(f_pred[8:]))\n return(p)","def _create_sparse_train_and_test(ratings, n_users, n_items):\n \n # pick a random set of data as testing data, sorted ascending\n test_set_size = len(ratings) / TEST_SET_RATIO\n test_set_idx = np.random.choice(xrange(len(ratings)), size=test_set_size, replace=False)\n test_set_idx = sorted(test_set_idx)\n \n # use the remaining data to create a training set\n ts_ratings = ratings[test_set_idx]\n tr_ratings = np.delete(ratings, test_set_idx, axis=0)\n \n # create training and test matrices as coo_matrix\n u_tr, i_tr, r_tr = zip(*tr_ratings)\n tr_sparse = coo_matrix((r_tr, (u_tr, i_tr)), shape=(n_users, n_items))\n u_ts, i_ts, r_ts = zip(*ts_ratings)\n test_sparse = coo_matrix((r_ts, (u_ts, i_ts)), shape=(n_users, n_items))\n \n return tr_sparse, test_sparse","def prediction(uid, pair, rating_bd, sim_bd, item_bd):\n iid, real_rating = pair[0], pair[1]\n if iid not in sim_bd.value.keys():\n return ()\n iid_neighbors = [\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\n average_iid_rating = item_bd.value[iid][0]\n sim_rating = []\n for info in iid_neighbors:\n niid, nsim, ratings = info\n sim_rating += [\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\n for rating in ratings if uid in rating[0]]\n if len(sim_rating) != 0:\n sim_ratings = [\n (line[1] * line[2], abs(line[1]), line[3])\n for line in sim_rating]\n predicted_rating_no_decay = average_iid_rating + sum(\n map(lambda line: line[0], sim_ratings)) / sum(\n map(lambda line: line[1], sim_ratings))\n predicted_rating_decay = \\\n average_iid_rating + add_decay(sim_ratings)\n else:\n predicted_rating_no_decay = average_iid_rating\n predicted_rating_decay = average_iid_rating\n return iid, real_rating, \\\n self.bound_rating(predicted_rating_no_decay), \\\n self.bound_rating(predicted_rating_decay)","def select_next(X, U, mu,\n scoremethod='lowhigh',\n missingmethod='none',\n feature_weights=[],\n oldscores=[], oldreproj=[]):\n\n print(\"------------ SELECTING --------------\")\n if len(U) == 0:\n printt(\"Empty DEMUD model: selecting item number %d from data set\" % \\\n (opts['iitem']))\n return opts['iitem'], [], []\n\n if X.shape[1] < 1 or len(U) == 0 or len(mu) == 0:\n printt(\"Error: No data in X and/or U and/or mu.\")\n return None, [], []\n\n if X.shape[0] != U.shape[0] or X.shape[0] != mu.shape[0]:\n printt(\"Mismatch in dimensions; must have X mxn, U mxk, mu mx1.\")\n return None, [], []\n\n # If oldscores is empty, compute the score for each item\n if len(oldscores) == 0:\n (scores, reproj) = score_items(X, U, mu, scoremethod, missingmethod)\n elif len(oldreproj) == 0:\n printt(\"Error: oldscores provided, but not oldreproj.\")\n return None, [], []\n else: # both are valid, so use them here\n (scores, reproj) = (oldscores, oldreproj)\n\n # Select and return index of item with max reconstruction error,\n # plus the updated scores and reproj\n m = scores.argmax()\n #print('mu:',mu)\n #print('selected:', X[:,m])\n #print('selected-mu:', (X-mu)[:,m])\n #print('reproj:', reproj[:,m])\n #print('reproj-mu:', (reproj-mu)[:,m])\n #input()\n\n return m, scores, reproj","def test_conversion():\r\n f1 = factor([0,1],[2,2],scipy.rand(4))\r\n f2 = factor([1,2],[2,2],scipy.rand(4))\r\n f3 = factor([3],[2],scipy.rand(2))\r\n\r\n F = FactorList([f1,f2,f3])\r\n theta = factors2ExpFam(F)\r\n F2 = expfam2Factors(theta)\r\n ratio = F2.JointDistn().val/ (F.JointDistn().val)\r\n ratio = ratio/ratio[0]\r\n print scipy.allclose(ratio,1)","def get5x5matrix(self): #modified from nxvasc get3x3matrix()\n try:\n i = na.identity(3)\n \n self.d124 = i.copy()\n self.ds124 = na.zeros(124,na.float64)\n \n for k in range(1,124):\n self.d124 = na.concatenate((self.d124,i))\n# print len(self.d124)\n count = 0\n a = []\n for k in range(-2,3):\n for j in range(-2,3):\n for i in range(-2,3):\n if( i != 0 or j != 0 or k != 0 ):\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\n count += 1\n a.append(i)\n a.append(j)\n a.append(k)\n# print len(a)\n a = na.reshape(na.array(a),(372,1))\n# print len(self.d124)\n self.d124 = na.concatenate((self.d124,a),axis=1)\n except Exception as error:\n print(\"failed in get5x5matrix(): \", error)","def fit(self, user_x_product, latent_features_guess=2, learning_rate=0.0002, steps=5000, regularization_penalty=0.02, convergeance_threshold=0.001):\n print 'training model...'\n return self.__factor_matrix(user_x_product, latent_features_guess, learning_rate, steps, regularization_penalty, convergeance_threshold)","def update_factors(self,u,i,j,update_u=True,update_i=True):\n #print(\"session run\")\n loss_v = self.sess.run(self.train_step , feed_dict={\n self.u: u,\n self.i: i,\n self.j: j})\n\n returnText = \"\"\n\n if self.alg_type == \"TFL\" or self.alg_type == \"TFLWM\":\n sum_lambda = 0\n for k in self.sim_matrix_names:\n sum_lambda += abs(self.sim_lambda[k].eval())\n #print(sum_lambda,self.sim_lambda)\n for k in self.sim_matrix_names:\n if math.isnan(sum_lambda):\n print(\"sim_lambda overflow\")\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\n returnText = \"sim_lambda overflow\"\n else:\n tf.assign(self.sim_lambda[k], self.sim_lambda[k].eval()/sum_lambda).eval()\n else:\n for k in self.sim_matrix_names:\n val = self.sim_lambda[k].eval()\n if math.isnan(val[0]):\n print(\"sim_lambda overflow\")\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\n returnText = \"sim_lambda overflow\"\n if val[0] <= 0.0:\n tf.assign(self.sim_lambda[k], [self.delta], validate_shape=False).eval()\n elif val[0] >= 1.0:\n tf.assign(self.sim_lambda[k], [self.one - self.delta], validate_shape=False).eval()\n\n return returnText","def calc_adv_U(self):\n num_U = 0\n adv_U = numpy.zeros((3,3), float)\n\n for atm in self:\n ## use the atom's U matrix if it exists, otherwise use the\n ## temperature factor\n\n if atm.U is not None:\n adv_U += atm.U\n num_U += 1\n\n return adv_U / num_U","def calculate_user_similarity_profile(self, ratings_vector):\r\n num_users, num_movies = self.ratings_matrix.get_shape()\r\n\r\n user_similarities = sp.dok_matrix((1, num_users))\r\n for i in range(num_users):\r\n\r\n user_similarities[0, i] = self.calculate_pairwise_user_similarity(self.ratings_matrix.getrow(i), ratings_vector)\r\n\r\n return user_similarities.tocsr()","def calc_metrics(metric_scores_list):\n\n N_split, N_miss, N_add, Q_P, Q_R, Q_F, N_gt, N_pred = [], [], [], [], [], [], [], []\n Q_rand, Q_jaccard, Q_aggregated_jaccard, Q_ctc, Q_piou = [], [], [], [], []\n tp, fp, fn = [], [], []\n\n for score in metric_scores_list:\n N_split.append(score['N_split']), N_miss.append(score['N_miss']), N_add.append(score['N_add'])\n Q_P.append(score['Q_P']), Q_R.append(score['Q_R']), Q_F.append(score['Q_F'])\n Q_rand.append(score['Q_rand']), Q_jaccard.append(score['Q_jaccard'])\n Q_aggregated_jaccard.append(score['Q_aggregated_jaccard'])\n if \"Q_ctc\" in score:\n Q_ctc.append(score['Q_ctc']), \n Q_piou.append(score['Q_piou'])\n N_gt.append(score['N_gt']), N_pred.append(score['N_pred'])\n tp.append(score['tp']), fp.append(score['fp']), fn.append(score['fn'])\n\n N_split, N_miss, N_add = np.array(N_split), np.array(N_miss), np.array(N_add)\n N_gt, N_pred = np.array(N_gt), np.array(N_pred)\n tp, fp, fn = np.array(tp), np.array(fp), np.array(fn)\n Q_P_macro, Q_R_macro, Q_F_macro = np.mean(np.array(Q_P)), np.mean(np.array(Q_R)), np.mean(np.array(Q_F))\n Q_P_micro = np.sum(tp) / (np.sum(tp) + np.sum(fp)) if (np.sum(tp) + np.sum(fp)) > 0 else 0\n Q_R_micro = np.sum(tp) / (np.sum(tp) + np.sum(fn)) if (np.sum(tp) + np.sum(fn)) > 0 else 0\n Q_rand_macro, Q_jaccard_macro = np.mean(np.array(Q_rand)), np.mean(np.array(Q_jaccard))\n Q_aggregated_jaccard_macro = np.mean(np.array(Q_aggregated_jaccard))\n Q_ctc_macro, Q_piou_macro = np.mean(np.array(Q_ctc)), np.mean(np.array(Q_piou))\n\n metrics = {\n 'Q_split_micro': float(np.sum(N_split) / np.sum(N_gt)),\n 'Q_split_macro': float(np.mean(N_split / N_gt)),\n 'Q_miss_micro': float(np.sum(N_miss) / np.sum(N_gt)),\n 'Q_miss_macro': float(np.mean(N_miss / N_gt)),\n 'Q_add_micro': float(np.sum(N_add) / np.sum(N_gt)),\n 'Q_add_macro': float(np.mean(N_add / N_gt)),\n 'N_gt': int(np.sum(N_gt)),\n 'N_pred': int(np.sum(N_pred)),\n 'Q_rand_macro': float(Q_rand_macro),\n 'Q_jaccard_macro': float(Q_jaccard_macro),\n 'Q_aggregated_jaccard_macro': float(Q_aggregated_jaccard_macro),\n 'Q_ctc_macro': float(Q_ctc_macro),\n 'Q_piou_macro': float(Q_piou_macro),\n 'Q_P_micro': float(Q_P_micro),\n 'Q_P_macro': float(Q_P_macro),\n 'Q_R_micro': float(Q_R_micro),\n 'Q_R_macro': float(Q_R_macro),\n 'Q_F_macro': float(Q_F_macro),\n 'Q_F_micro': float(2 * Q_P_micro * Q_R_micro / (Q_P_micro + Q_R_micro)) if (Q_P_micro + Q_R_micro) > 0 else 0\n }\n return metrics","def multiply_fisher_factor(self, vector: jnp.ndarray) -> jnp.ndarray:\n return utils.scalar_mul(\n self.multiply_fisher_factor_unweighted(vector), jnp.sqrt(self.weight))","def predict(self, u, i, P=None, Q=None, F=None, w=None, user_bias=None, item_bias=None):\n if P is None:\n P = self.P\n if Q is None:\n Q = self.Q\n if F is None:\n F = self.F\n if w is None:\n w = self.w\n if user_bias is None:\n user_bias = self.user_bias\n if item_bias is None:\n item_bias = self.item_bias\n\n known_user = self._known('user', u)\n known_item = self._known('item', i)\n rui_hat = self.mean\n if known_user:\n rui_hat += user_bias[u]\n if known_item:\n rui_hat += item_bias[i]\n if known_user and known_item:\n F_sum = np.sum(F[self.Fr[u], :], axis=0)\n #F_num = np.sqrt(self.Fr[u].shape[0]) # Try without sqrt\n F_num = self.Fr[u].shape[0]\n if F_num > 0:\n F_sum /= F_num\n rui_hat += (F_sum + w * P[u, :]).dot(Q[:, i])\n # Apply potential non-linearity (activation) g\n rui_hat = self.g(rui_hat)\n return rui_hat","def build_user_user_similarity_matrix(self, event_data):\n self.compute_user_user_sim_base_on_common_items()\n self.standardize_sim_values()","def test_lu_factor():\n\t#[A, b] = lu_read('test1.txt')\n\t# it is poor form to read an external file into a test function, as above\n\tA = np.array([\n\t\t[ 2., 3., -4., 2.],\n\t\t[-4., -5., 6., -3.],\n\t\t[ 2., 2., 1., 0.],\n\t\t[-6., -7., 14., -4.]])\t\n\tLU,p = lu_factor(A, pivot=False)\n\tLU_soln = np.array([\n\t\t[ 2, 3,-4, 2],\n\t\t[-2, 1,-2, 1],\n\t\t[ 1,-1, 3,-1],\n\t\t[-3, 2, 2, 2]])\t\n\tassert norm(LU - LU_soln) < 1.e-10\t\n\n\n\t# test 2\n\t[A2, b2] = lu_read('test2.txt')\t\t\t\t\t\t# read a matrix and RHS vector\n\tLU2,p2 = lu_factor(A2) \t\t\t\t\t\t\t\t# change display to False when LU_FACTOR working\n\tLU_soln2 = np.array([\n\t\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\n\t\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\n\t\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\n\t\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\n\t\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\n\t\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\n\t\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\n\t\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\n\tassert norm(LU2 - LU_soln2) < 1.e-10"],"string":"[\n \"def create_matrix(self):\\n\\n self.matrix = np.zeros((len(self.users), len(self.items)))\\n\\n for user in self.train_set['users']:\\n for item in self.train_set['feedback'][user]:\\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\\\\n self.train_set['feedback'][user][item]\",\n \"def get_user_item_matrix(datafile, user_index, product_index):\\n num_users = len(user_index)\\n num_items = len(product_index)\\n result = np.zeros((num_users, num_items))\\n num_reviews = len(datafile)\\n result_dense = np.zeros((num_reviews, 3))\\n for line in datafile.iterrows():\\n i = line[0]\\n user_id = datafile['user_id'][i]\\n product_id = datafile['business_id'][i]\\n user = user_index[user_id]\\n product = product_index[product_id]\\n rating = datafile['stars'][i]\\n result[user, product] = rating\\n result_dense[i, 0] = user\\n result_dense[i, 1] = product\\n result_dense[i, 2] = rating\\n return result, result_dense\",\n \"def create_user_item_matrix(data,type='unary'): \\n if type == 'unary':\\n\\n # for unary rating drop duplicates\\n data = data.drop_duplicates()\\n\\n # create sparse matrix\\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\\n\\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\\n # get all non empty rows and cols\\n rows, cols = matrix.nonzero()\\n unique_rows = np.unique(rows)\\n unique_cols = np.unique(cols)\\n\\n # select only rows and cols with values\\n matrix = matrix[unique_rows]\\n matrix = matrix[:,unique_cols]\\n\\n return matrix\\n\\n if type == 'count':\\n\\n # create sparse matrix with counted ratings\\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\\n\\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\\n # get all non empty rows and cols\\n rows, cols = matrix.nonzero()\\n unique_rows = np.unique(rows)\\n unique_cols = np.unique(cols)\\n\\n # select only rows and cols with values\\n matrix = matrix[unique_rows]\\n matrix = matrix[:,unique_cols]\\n\\n '''\\n Im Gegensatz zum Memory Based approach, muss beim Model Based Approach noch das Rating angepasst werden. \\n Das heisst, dass Produkte die viel eingekauft wurden ein höhers Rating erhalten und solche die weniger \\n eingekauft wudren ein tieferes. Gleichzeitig muss das Maximum limitiert werden. Dies wird mittels \\n dem max_count integer in der Funktion bewerkstelligt\\n '''\\n\\n # create diagonal Matrix with 1 divided by maximum values per row. This needs to be done because there is no divide function for csr matrices implemented\\n # source: https://stackoverflow.com/questions/42225269/scipy-sparse-matrix-division\\n diag = diags(1/matrix.max(axis=1).A.ravel())\\n\\n # multipy the matrix with the maximum values to get range from 0-1\\n matrix = diag.dot(matrix)\\n\\n # sort indices; not really needed, just cosmetics\\n matrix.sort_indices()\\n\\n return matrix\",\n \"def example():\\n num_user, num_item, ratings = build_ticket()\\n \\n # suffle_data\\n np.random.shuffle(ratings)\\n\\n # split data to training & validation\\n train_pct = 0.9\\n train_size = int(train_pct * len(ratings))\\n train = ratings[:train_size]\\n validation = ratings[train_size:]\\n\\n # params\\n num_feature = 5\\n bmf_model = BayesianMatrixFactorization(\\n num_user, num_item, num_feature, train, validation, max_rating=1, min_rating=0, ratingsMatirx=ratings)\\n\\n start_time = time.clock()\\n bmf_model.estimate(10)\\n end_time = time.clock()\\n \\n mat = np.matrix(bmf_model.item_features)\\n with open('../data/ticket/item_feature', 'w') as f:\\n for line in mat:\\n np.savetxt(f, line, fmt='%.5f')\\n\\n print \\\"time spend = %.3f\\\" % (end_time - start_time)\\n\\n return bmf_model\",\n \"def get_user_feature_matrix_p(user_dict, user_index, aspect_index, N, popularity, A_dense, Polarity):\\n result = np.zeros((len(user_index), len(aspect_index)))\\n for key in user_dict.keys():\\n index_user = user_index[key]\\n user_reviews = user_dict[key]\\n count_dict = {}\\n max = 0\\n min = 1000\\n for review in user_reviews:\\n feature = review[0]\\n if feature not in aspect_index:\\n continue\\n aspect = aspect_index[feature]\\n if aspect not in count_dict:\\n count_dict[aspect] = 0;\\n if Polarity == False:\\n count_dict[aspect] += 1\\n else:\\n count_dict[aspect] += review[1]\\n for aspect in count_dict.keys():\\n count = count_dict[aspect]\\n if count > max:\\n max = count\\n if count < min:\\n min = count\\n for aspect in count_dict.keys():\\n count = count_dict[aspect]\\n result[index_user, aspect] = (((count - min)/(max - min))*5)\\n\\n if len(popularity) > 0:\\n col = np.zeros((len(result), 1))\\n result = np.append(result, col, axis=1)\\n for i in range(len(result)):\\n items = A_dense[A_dense[:, 0] == i][:, 1]\\n items = items.astype(int)\\n result[i, len(result[1]) - 1] = np.mean(popularity[items, 1])\\n return result\",\n \"def fit(self, users, items, ratings, test_users=[], test_items=[], test_ratings=[], **kargs):\\n global_mean_bias_init = np.float32(np.mean(ratings))\\n global_mean_bias_init = 0.01\\n self.model = DeepFM_(**self.dfm_params, global_mean_bias_init=global_mean_bias_init, first_half_fit_only_fm=self.first_half_fit_only_fm)\\n \\n # もし、CTR予測の場合は、y=0のデータをランダム生成する。\\n if self.ctr_prediction:\\n users = list(users) + list(np.random.choice(list(set(users)), size=len(users)))\\n items = list(items) + list(np.random.choice(list(set(items)), size=len(items)))\\n ratings = list((np.array(ratings)>0).astype(int)) + [0]*len(ratings)\\n test_ratings = list((np.array(test_ratings)>0).astype(int))\\n \\n Xi, Xv = self.data_manager.transform_users_and_items_to_Xi_Xv(users, items)\\n \\n if len(test_users)>0:\\n test_Xi, test_Xv = self.data_manager.transform_users_and_items_to_Xi_Xv(test_users, test_items)\\n self.model.fit(Xi, Xv, ratings, test_Xi, test_Xv, test_ratings, early_stopping=True)\\n else:\\n self.model.fit(Xi, Xv, ratings, early_stopping=True, **kargs)\\n \\n # load data\\n self.trained_users = list(set(users))\\n self.trained_items = list(set(items))\\n self.global_mean = self.model.predict(Xi, Xv).mean()\",\n \"def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\\n #print \\\"--------------------------------------------------\\\"\\n #print \\\"calculate_recommendations\\\"\\n #print \\\"--------------------------------------------------\\\"\\n\\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\\n\\n # U = np.array('users')\\n # D = np.array('video_games')\\n\\n # R = |U| cross |D|\\n\\n # We want to discover K latent features\\n\\n # Find\\n # P(a | |U| corss K matrix)\\n # Q(a | |D| cross K matrix)\\n # Such that their product approximates R\\n # R approx= P cross transpose(Q) = hat(R)\\n #\\n\\n # r[i][j] = transpose(p)[i] * q[j]\\n # = sum( 1..k, p[i][k] * q[k][j] )\\n\\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\\n # squared error, estimated rating can be either higher or lower than the real thing\\n\\n # find the gradient\\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\\n\\n # update rules\\n # alpha = settings.alpha # learning_rate\\n # alpha = 0.0002 # learning_rate\\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\\n\\n # training data\\n # T = (u[i], d[j], r[i][j])\\n # np.array()\\n\\n # iterate until convergance\\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\\n # - sum(1..k, p[i][k]*q[k][j]))**2\\n\\n # regularization\\n # beta = 0.02\\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\\n #\\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\\n\\n data = np.array(vote_list)\\n\\n encoder = OneHotEncoder()\\n\\n users = data[:,0]\\n unique_users = list(set(users))\\n for i in range(len(users)):\\n users[i] = unique_users.index(users[i])\\n\\n video_games = data[:,1]\\n unique_games = list(set(video_games))\\n for i in range(len(video_games)):\\n video_games[i] = unique_games.index(video_games[i])\\n\\n ratings = data[:,2]\\n M = len(set(video_games))\\n N = len(set(users))\\n R = np.zeros((N,M))\\n for i in range(len(users)):\\n user = users[i]\\n game = video_games[i]\\n rating = ratings[i]\\n R[user][game] = rating\\n\\n K = 2\\n\\n P = np.random.rand(N,K)\\n Q = np.random.rand(M,K)\\n\\n nP, nQ = self.matrix_factorization(R, P, Q, K)\\n nR = np.dot(nP, nQ.T)\\n\\n itemMatch = {}\\n for i in range(N):\\n user = unique_users[i]\\n itemMatch[user] = []\\n for j in range(M):\\n if R[i][j] == 0:\\n video_game = unique_games[j]\\n recommendation = (video_game, nR[i][j])\\n itemMatch[user].append(recommendation)\\n itemMatch[None] = []\\n print 'pmf recommendations', itemMatch.items()\\n print '\\\\n'\\n recommendations = itemMatch.items()\\n\\n # returns\\n # [\\n # (<user1>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # (<user2>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # ]\\n\\n return recommendations\",\n \"def init_matrix(self, train, num_features):\\n user_matrix = np.random.rand(self.num_users, num_features)\\n item_matrix = np.random.rand(num_features, self.num_items)\\n item_nnz = train.getnnz(axis=0)\\n item_sum = train.sum(axis=0)\\n item_matrix[0, :] = item_sum / item_nnz\\n return user_matrix, item_matrix\",\n \"def create_adjust_matrix(self, is_sub: bool):\\n matrix = None\\n if not is_sub:\\n ratings = np.ones_like(self._user, dtype=np.float32)\\n matrix = sp.csr_matrix(\\n (ratings, (self._user, self._item + self.n_users)),\\n shape=(self.n_users + self.n_items, self.n_users + self.n_items),\\n )\\n else:\\n if self.type == \\\"ND\\\":\\n drop_user = self.rand_sample(\\n self.n_users,\\n size=int(self.n_users * self.drop_ratio),\\n replace=False,\\n )\\n drop_item = self.rand_sample(\\n self.n_items,\\n size=int(self.n_items * self.drop_ratio),\\n replace=False,\\n )\\n R_user = np.ones(self.n_users, dtype=np.float32)\\n R_user[drop_user] = 0.0\\n R_item = np.ones(self.n_items, dtype=np.float32)\\n R_item[drop_item] = 0.0\\n R_user = sp.diags(R_user)\\n R_item = sp.diags(R_item)\\n R_G = sp.csr_matrix(\\n (\\n np.ones_like(self._user, dtype=np.float32),\\n (self._user, self._item),\\n ),\\n shape=(self.n_users, self.n_items),\\n )\\n res = R_user.dot(R_G)\\n res = res.dot(R_item)\\n\\n user, item = res.nonzero()\\n ratings = res.data\\n matrix = sp.csr_matrix(\\n (ratings, (user, item + self.n_users)),\\n shape=(self.n_users + self.n_items, self.n_users + self.n_items),\\n )\\n\\n elif self.type == \\\"ED\\\" or self.type == \\\"RW\\\":\\n keep_item = self.rand_sample(\\n len(self._user),\\n size=int(len(self._user) * (1 - self.drop_ratio)),\\n replace=False,\\n )\\n user = self._user[keep_item]\\n item = self._item[keep_item]\\n\\n matrix = sp.csr_matrix(\\n (np.ones_like(user), (user, item + self.n_users)),\\n shape=(self.n_users + self.n_items, self.n_users + self.n_items),\\n )\\n\\n matrix = matrix + matrix.T\\n D = np.array(matrix.sum(axis=1)) + 1e-7\\n D = np.power(D, -0.5).flatten()\\n D = sp.diags(D)\\n return D.dot(matrix).dot(D)\",\n \"def forward(self, user, item):\\n item_emb = self.product_factors(item.view(-1)) + self.product_bias(\\n item.view(-1)\\n )\\n user_emb = self.user_factors(user.view(-1)) + self.user_bias(user.view(-1))\\n mat_mult = (item_emb * user_emb).sum(1)\\n\\n return mat_mult\",\n \"def affinity_matrix(test_specs):\\n\\n np.random.seed(test_specs[\\\"seed\\\"])\\n\\n # uniform probability for the 5 ratings\\n s = [(1 - test_specs[\\\"spars\\\"]) / test_specs[\\\"ratings\\\"]] * test_specs[\\\"ratings\\\"]\\n s.append(test_specs[\\\"spars\\\"])\\n P = s[::-1]\\n\\n # generates the user/item affinity matrix. Ratings are from 1 to 5, with 0s denoting unrated items\\n X = np.random.choice(\\n test_specs[\\\"ratings\\\"] + 1, (test_specs[\\\"users\\\"], test_specs[\\\"items\\\"]), p=P\\n )\\n\\n Xtr, Xtst = numpy_stratified_split(\\n X, ratio=test_specs[\\\"ratio\\\"], seed=test_specs[\\\"seed\\\"]\\n )\\n\\n return Xtr, Xtst\",\n \"def update_model(self):\\n for itemidx, itemid in self._allitems.iterrows():\\n self.__itemid2idx[str(itemid['itemid'])] = itemidx\\n self.__itemidx2id[itemidx] = str(itemid['itemid'])\\n for useridx, userid in enumerate(self._uservisits['userid'].unique()):\\n self.__userid2idx[str(userid)] = useridx\\n self.__useridx2id[useridx] = str(userid)\\n userid = self._uservisits['userid'].values\\n itemid = self._uservisits['itemid'].values\\n rating = self._uservisits['rating'].values\\n useridx = [self.__userid2idx[str(int(uid))] for uid in userid]\\n itemidx = [self.__itemid2idx[str(int(iid))] for iid in itemid]\\n rating = list(map(numpy.double, rating))\\n self.__itemuser = csr_matrix((rating, (useridx, itemidx)), shape=(len(set(useridx)), len(set(itemidx))))\\n self.__recommender = implicit.als.AlternatingLeastSquares(factors=self.__numtopics)\\n self.__recommender.fit(self.__itemuser)\",\n \"def recommend_NMF(new_user,movies_num,movies_ratings):\\n list_id_movies = movies_ratings['movieId'].unique()\\n nmf,Q = load_NMF_model()\\n new_user_vector = pd.DataFrame(new_user, index=list_id_movies).T\\n new_user_vector_filled = new_user_vector.fillna(3)\\n #calculate Matrix P (Genres)\\n P = nmf.transform(new_user_vector_filled)\\n #make predictions\\n predictions = np.dot(P,Q)\\n recommendations = pd.DataFrame(predictions.reshape(-1), index=list_id_movies).T\\n #Remove already watched movies:\\n not_watched_movies_mask = np.isnan(new_user_vector)\\n not_watched = recommendations[not_watched_movies_mask]\\n\\n top_movies_ids = not_watched.T.sort_values(by=[0], ascending=False).index[:movies_num]\\n\\n Top_recommended = movieId_to_title(top_movies_ids,movies_ratings) \\n return Top_recommended\",\n \"def fit(self, df):\\n\\n # generate continuous indices if this hasn't been done\\n if self.index2item is None:\\n self.set_index(df)\\n\\n logger.info(\\\"Collecting user affinity matrix\\\")\\n if not np.issubdtype(df[self.col_rating].dtype, np.number):\\n raise TypeError(\\\"Rating column data type must be numeric\\\")\\n\\n # copy the DataFrame to avoid modification of the input\\n temp_df = df[[self.col_user, self.col_item, self.col_rating]].copy()\\n\\n if self.time_decay_flag:\\n logger.info(\\\"Calculating time-decayed affinities\\\")\\n # if time_now is None use the latest time\\n if not self.time_now:\\n self.time_now = df[self.col_timestamp].max()\\n\\n # apply time decay to each rating\\n temp_df[self.col_rating] *= exponential_decay(\\n value=df[self.col_timestamp],\\n max_val=self.time_now,\\n half_life=self.time_decay_half_life,\\n )\\n\\n # group time decayed ratings by user-item and take the sum as the user-item affinity\\n temp_df = (\\n temp_df.groupby([self.col_user, self.col_item]).sum().reset_index()\\n )\\n else:\\n # without time decay use the latest user-item rating in the dataset as the affinity score\\n logger.info(\\\"De-duplicating the user-item counts\\\")\\n temp_df = temp_df.drop_duplicates(\\n [self.col_user, self.col_item], keep=\\\"last\\\"\\n )\\n\\n logger.info(\\\"Creating index columns\\\")\\n # map users and items according to the two dicts. Add the two new columns to temp_df.\\n temp_df.loc[:, self.col_item_id] = temp_df[self.col_item].map(self.item2index)\\n temp_df.loc[:, self.col_user_id] = temp_df[self.col_user].map(self.user2index)\\n\\n # retain seen items for removal at prediction time\\n self.seen_items = temp_df[[self.col_user_id, self.col_item_id]].values\\n\\n # affinity matrix\\n logger.info(\\\"Building user affinity sparse matrix\\\")\\n self.user_affinity = self.compute_affinity_matrix(\\n temp_df, self.n_users, self.n_items\\n )\\n\\n # calculate item co-occurrence\\n logger.info(\\\"Calculating item co-occurrence\\\")\\n item_cooccurrence = self.compute_coocurrence_matrix(\\n temp_df, self.n_users, self.n_items\\n )\\n\\n # free up some space\\n del temp_df\\n\\n self.item_frequencies = item_cooccurrence.diagonal()\\n\\n logger.info(\\\"Calculating item similarity\\\")\\n if self.similarity_type == sar.SIM_COOCCUR:\\n self.item_similarity = item_cooccurrence\\n elif self.similarity_type == sar.SIM_JACCARD:\\n logger.info(\\\"Calculating jaccard\\\")\\n self.item_similarity = jaccard(item_cooccurrence).astype(\\n df[self.col_rating].dtype\\n )\\n elif self.similarity_type == sar.SIM_LIFT:\\n logger.info(\\\"Calculating lift\\\")\\n self.item_similarity = lift(item_cooccurrence).astype(\\n df[self.col_rating].dtype\\n )\\n else:\\n raise ValueError(\\n \\\"Unknown similarity type: {0}\\\".format(self.similarity_type)\\n )\\n\\n # free up some space\\n del item_cooccurrence\\n\\n logger.info(\\\"Done training\\\")\",\n \"def fit_data(self, matrix, user_features=None, item_features=None):\\r\\n matrix.sort_index(inplace=True)\\r\\n matrix.sort_index(inplace=True, axis=1)\\r\\n dataset = Dataset()\\r\\n dataset.fit((x for x in matrix.index),\\r\\n (x for x in matrix.columns))\\r\\n interactions = pd.melt(matrix.replace(0, np.nan).reset_index(),\\r\\n id_vars='index',\\r\\n value_vars=list(matrix.columns[1:]),\\r\\n var_name='plu_id',\\r\\n value_name='rating').dropna().sort_values('index')\\r\\n interactions.columns = ['crd_no', 'plu_id', 'rating']\\r\\n self.interactions, self.weights = dataset.build_interactions([tuple(x) for x in interactions.values])\\r\\n\\r\\n if user_features is not None:\\r\\n user_features.sort_index(inplace=True)\\r\\n dataset.fit_partial(users=user_features.index,\\r\\n user_features=user_features)\\r\\n self.user_features = dataset.build_user_features(\\r\\n ((index, dict(row)) for index, row in user_features.iterrows()))\\r\\n else:\\r\\n self.user_features = None\\r\\n if item_features is not None:\\r\\n item_features.sort_index(inplace=True)\\r\\n dataset.fit_partial(items=item_features.index,\\r\\n item_features=item_features)\\r\\n self.item_features = dataset.build_item_features(\\r\\n ((index, dict(row)) for index, row in item_features.iterrows()))\\r\\n else:\\r\\n self.item_features = None\",\n \"def __init__(self, ratings, rank, user_reg_loss, item_reg_loss):\\n self._ratings = ratings\\n self._users_num, self._items_num = ratings.shape\\n self._rank = rank\\n self._user_reg_loss = user_reg_loss\\n self._item_reg_loss = item_reg_loss\\n \\n self._train_function = self._als_partial_step_explicit\\n \\n # DONE init latent factors for user and item matrix\\n # losowo ustalamy inicjalne wartości X i Y\\n self._user_factors = np.random.random((self._users_num, rank))\\n self._item_factors = np.random.random((self._items_num, rank))\",\n \"def predict_rating(user_id,item_id):\\n user_preference = latent_user_preferences[user_id]\\n item_preference = latent_item_features[item_id]\\n return user_preference.dot(item_preference)\",\n \"def compute_affinity_matrix(self, df, n_users, n_items):\\n\\n return sparse.coo_matrix(\\n (df[self.col_rating], (df[self.col_user_id], df[self.col_item_id])),\\n shape=(n_users, n_items),\\n ).tocsr()\",\n \"def init_MF(train, num_features):\\n num_user = train.shape[1]\\n num_item = train.shape[0]\\n user_features = np.random.rand(num_features,num_user) # user_features shape (20,943)\\n item_features = np.random.rand(num_item, num_features) # item_features shape (1152,20)\\n return user_features, item_features\",\n \"def feature_matrix(df, user_id=None, item_id=None):\\n print(\\\"get feature matrix\\\")\\n df1 = df.drop_duplicates(subset=['user_id'], keep='first', inplace=False)\\n user_x = None\\n if user_id is not None:\\n user_x = int(np.argwhere(df1['user_id'].values == user_id))\\n user_features = df1[['average_stars']].values\\n csr_user_features = sparse.csr_matrix(user_features)\\n\\n df2 = df.drop_duplicates(\\n subset=['business_id'],\\n keep='first',\\n inplace=False)\\n item_x = None\\n if item_id is not None:\\n item_x = int(np.argwhere(df2['business_id'].values == item_id))\\n item_features = df2.iloc[:, 10:].values\\n\\n csr_item_features = sparse.csr_matrix(item_features)\\n return csr_user_features, csr_item_features, user_x, item_x\",\n \"def simMatrix(self, d = 1/5):\\n \\n self.fit_baseline(d)\\n self.evalBaseline()\\n \\n \\n df_mat = np.array(self.df[[\\\"user ind\\\", \\\"item ind\\\", \\\"rating\\\"]].merge(self.r_b, on = [\\\"user ind\\\", \\\"item ind\\\"]))\\n df_ind = df_mat[:,:2].astype(int)\\n df_rat = df_mat[:,2] - df_mat[:,3]\\n \\n \\n self.M = np.zeros((self.n_us, self.n_it))\\n \\n \\n widgets = ['Test: ', Percentage(), ' ', Bar(\\\"#\\\"), ' ', ETA()]\\n pbar = ProgressBar(widgets = widgets, maxval = self.n_us)\\n pbar.start()\\n \\n for us in self.user_ind:\\n it = df_ind[np.where(df_ind[:,0] == us)[0], 1]\\n rat1 = df_rat[np.where(df_ind[:,0] == us)[0]]\\n self.M[us,it] = rat1\\n \\n pbar.update(us)\\n \\n pbar.finish()\\n \\n #self.M = self.UI.toarray()\\n pbar = ProgressBar(widgets = widgets, maxval = self.n_it * (self.n_it - 1) / 2)\\n pbar.start()\\n \\n self.S = np.empty((self.n_it, self.n_it)) * np.nan\\n \\n for i1 in range(self.n_it):\\n # self.S[i1,i1] = 1\\n x1 = self.M[:,i1]\\n for i2 in range(i1+1,self.n_it):\\n x2 = self.M[:,i2]\\n I = np.logical_and(x1, x2)\\n if (len(I) > 1):\\n self.S[i1,i2] = self.S[i2,i1] = Sim.cos2(x1.T[I], self.M[:,i2].T[I])\\n \\n pbar.update((self.n_it)*(i1+1) - (i1+2)*(i1+1)/2)\\n \\n pbar.finish()\\n \\n return self.S\",\n \"def score_items(X, U, mu,\\n scoremethod='lowhigh',\\n missingmethod='none',\\n feature_weights=[]):\\n\\n # Use U to model and then reconstruct the data in X.\\n # 1. Project all data in X into space defined by U,\\n # then reconstruct it.\\n if missingmethod.lower() != 'ignore':\\n # All missing values should have been replaced with 0,\\n # or non-existent.\\n # 1a. Subtract the mean and project onto U\\n proj = np.dot(U.T, (X - mu))\\n # 1b. Reconstruct by projecting back up and adding mean\\n reproj = np.dot(U, proj) + mu\\n # 1c. Compute the residual\\n #print('X:', X.T)\\n #print('reproj:', reproj.T)\\n err = X - reproj\\n #print('err:', err.T)\\n #input()\\n \\n else:\\n # Missing method must be 'ignore' (Brand 2002)\\n (err, reproj) = compute_error_with_missing(X, U, mu)\\n\\n # 2. Compute reconstruction error\\n if scoremethod == 'low': # Blank out all errors > 0\\n err[err>0] = 0\\n elif scoremethod == 'high': # Blank out all errors < 0\\n err[err<0] = 0\\n else: # default, count everything\\n pass\\n \\n # Weight features if requested\\n if len(feature_weights) > 0:\\n for i in range(len(feature_weights)):\\n err[i,:] = err[i,:] * feature_weights[i]\\n\\n if missingmethod.lower() == 'ignore':\\n # Only tally error for observed features.\\n # This means that items with missing values are not penalized\\n # for those features, which is probably the best we can do.\\n scores = np.nansum(np.array(np.power(err, 2)), axis=0)\\n else:\\n scores = np.sum(np.array(np.power(err, 2)), axis=0)\\n\\n #print('scores:', scores)\\n #print('reproj:', reproj)\\n #input()\\n return (scores, reproj)\",\n \"def ratings_to_matrix(ratings_df, user_col, item_col, rating_col, forced_shape=None):\\n users_num = ratings_df.user_id.max() + 1\\n items_num = ratings_df.item_id.max() + 1\\n \\n if forced_shape:\\n users_num = max(users_num, forced_shape[0])\\n items_num = max(items_num, forced_shape[1])\\n \\n ratings_mat = np.zeros([users_num, items_num])\\n for rating in ratings_df.itertuples():\\n ratings_mat[rating[user_col], rating[item_col]] = rating[rating_col]\\n \\n return ratings_mat\",\n \"def __init__(self, user_factors, item_factors):\\n self._user_factors = np.copy(user_factors)\\n self._item_factors = np.copy(item_factors)\\n \\n self._users_num = user_factors.shape[0]\\n self._items_num = item_factors.shape[0]\\n\\n assert user_factors.shape[1] == item_factors.shape[1]\",\n \"def fit(self, ratings):\\n # Training proceeds in 2 steps:\\n # 1. Normalize item vectors to be mean-centered and unit-normalized\\n # 2. Compute similarities with pairwise dot products\\n self._timer = util.Stopwatch()\\n\\n init_rmat, users, items = matrix.sparse_ratings(ratings)\\n n_items = len(items)\\n _logger.info('[%s] made sparse matrix for %d items (%d ratings from %d users)',\\n self._timer, len(items), init_rmat.nnz, len(users))\\n\\n rmat, item_means = self._mean_center(ratings, init_rmat, items)\\n\\n rmat = self._normalize(rmat)\\n\\n _logger.info('[%s] computing similarity matrix', self._timer)\\n smat = self._compute_similarities(rmat)\\n\\n _logger.info('[%s] got neighborhoods for %d of %d items',\\n self._timer, np.sum(np.diff(smat.rowptrs) > 0), n_items)\\n\\n _logger.info('[%s] computed %d neighbor pairs', self._timer, smat.nnz)\\n\\n self.item_index_ = items\\n self.item_means_ = item_means\\n self.item_counts_ = np.diff(smat.rowptrs)\\n self.sim_matrix_ = smat\\n self.user_index_ = users\\n self.rating_matrix_ = init_rmat\\n\\n return self\",\n \"def important_factors_based_on_ratings(data: pd.DataFrame) -> np.ndarray:\\n # Turn labels into binary classification for equal class distribution\\n data = utils.add_ratings_binary(data)\\n # Get feature and label data for classifcation from original dataset\\n X, y = utils.get_rating_features_labels(data)\\n\\n # Grab features from feature matrix\\n features = X.columns\\n\\n # split data into train and test set\\n X_train, X_test, y_train, y_test = model_selection.train_test_split(X.values, y, test_size=0.2) \\n\\n # Instantiate and train xgboost model for rating classfication\\n xgb_model = xgboost.XGBClassifier()\\n xgb_model.fit(X_train, y_train)\\n\\n # Grab feature importance scores from trained model\\n feature_importance = xgb_model.feature_importances_\\n # Find indices of top 2 important features\\n top_important_features_ind = np.argpartition(feature_importance, -2)[-2:]\\n\\n print(f\\\"The top 2 important features are {features[top_important_features_ind]}\\\")\\n\\n return feature_importance\",\n \"def get_user_feature_matrix(user_dict, user_index, aspect_index, N):\\n result = np.zeros((len(user_index), len(aspect_index)))\\n for key in user_dict.keys():\\n index_user = user_index[key]\\n user_reviews = user_dict[key]\\n count_dict = {}\\n for review in user_reviews:\\n feature = review[0]\\n if feature not in aspect_index:\\n continue\\n aspect = aspect_index[feature]\\n if aspect not in count_dict:\\n count_dict[aspect] = 0;\\n count_dict[aspect] += 1\\n for aspect in count_dict.keys():\\n count = count_dict[aspect]\\n result[index_user, aspect] = 1 + (N - 1) * (2 / (1 + exp(-count)) - 1)\\n return result\",\n \"def personalization(prediction, n):\\n # prediction\\n # n top n recommendation\\n\\n top_n = get_top_n(prediction, n)\\n\\n rec_dict = {}\\n for uid, user_ratings in top_n.items():\\n rec_dict[uid] = [iid for (iid, _) in user_ratings]\\n\\n rec_user_ls = [pred[0] for pred in prediction]\\n rec_item_ls = [pred[1] for pred in prediction]\\n\\n unique_rec_user_ls = np.unique(rec_user_ls)\\n unique_rec_item_ls = np.unique(rec_item_ls)\\n\\n # assign each item with index number\\n unique_rec_item_dict = {item: ind for ind,\\n item in enumerate(unique_rec_item_ls)}\\n\\n n_unique_rec_user = len(unique_rec_user_ls)\\n n_unique_rec_item = len(unique_rec_item_ls)\\n\\n # recommended user item matrix\\n rec_matrix = np.zeros(shape=(n_unique_rec_user, n_unique_rec_item))\\n\\n # represent recommended item for each user as binary 0/1\\n for user in range(n_unique_rec_user):\\n # get userid\\n user_id = unique_rec_user_ls[user]\\n # get rec item list\\n item_ls = rec_dict[user_id]\\n\\n for item_id in item_ls:\\n # get item index\\n item = unique_rec_item_dict[item_id]\\n rec_matrix[user, item] = 1\\n\\n # calculate cosine similarity matrix across all user recommendations\\n similarity = cosine_similarity(X=rec_matrix, dense_output=False)\\n # calculate average of upper triangle of cosine matrix\\n upper_right = np.triu_indices(similarity.shape[0], k=1)\\n # personalization is 1-average cosine similarity\\n score = 1 - np.mean(similarity[upper_right])\\n return score\",\n \"def update_item_feature(\\n train, item_features, user_features, lambda_item,\\n nz_item_userindices, I):\\n for n, item_n in enumerate(nz_item_userindices):\\n nnz_users_per_item = len(item_n[1]) # Number of users who rated item n\\n if (nnz_users_per_item == 0): nnz_users_per_item = 1\\n # Least squares solution\\n A_n = np.dot(user_features[:,item_n[1]], user_features[:,item_n[1]].T) + lambda_item * nnz_users_per_item * I\\n V_n = np.dot(user_features[:,item_n[1]], train.T[item_n[1],item_n[0]].todense())\\n #if (n%3 == 0): print(\\\"item_n: {}\\\".format(item_n[0]), np.linalg.det(A_n))\\n if (np.linalg.det(A_n) != 0): item_features.T[:,item_n[0]] = np.linalg.solve(A_n,V_n)\\n else: \\n A_n[0,0] += 1; A_n[1,1] += 1; A_n[2,2] += 1; A_n[3,3] += 1; A_n[4,4] += 1; A_n[5,5] += 1 # if matrix A_n is singular, slightly modify several values\\n item_features.T[:,item_n[0]] = np.linalg.solve(A_n,V_n)\",\n \"def item_user_matrix(X):\\n X['user_id'] = X['user_id'].astype(\\\"category\\\")\\n X['song_id'] = X['song_id'].astype(\\\"category\\\")\\n\\n row = X['song_id'].cat.codes.copy()\\n col = X['user_id'].cat.codes.copy()\\n\\n nrow = len(X['song_id'].cat.categories)\\n ncol = len(X['user_id'].cat.categories)\\n\\n item_user = csr_matrix((X['score'], (row, col)), shape=(nrow, ncol))\\n\\n user = dict(enumerate(X['user_id'].cat.categories))\\n user_index = {u: i for i, u in user.items()}\\n\\n item = dict(enumerate(X['song_id'].cat.categories))\\n item_index = {s: i for i, s in item.items()}\\n\\n return item_user, item_index, user_index\",\n \"def fit(self, ratings_mat):\\n self.logger.debug(\\\"starting fit\\\")\\n # self.n = ratings.max()['user']+1\\n # self.p = ratings.max()['movie']+1\\n self.ratings_mat = ratings_mat\\n self.k = ratings_mat.shape[0]//20\\n\\n #ratings_array = ratings[ratings.columns[:-1].values].values\\n\\n #self.ratings_mat = np.zeros((self.n, self.p))\\n\\n #for i, rating in ratings.iterrows():\\n # self.ratings_mat[( rating['user'], rating['movie'] )] = rating['rating']\\n\\n self.cosine_dists = squareform(pdist(ratings_mat, 'cosine'))\\n\\n #if a user has no ratings data, cosine dist will return a nan. In this case, we assume they are as different as possible, since we cannot predict using those users anyways\\n self.cosine_dists = 1 - np.nan_to_num(1 - self.cosine_dists)\\n\\n self.similarity_ranks = self.cosine_dists.argsort(axis = 1)\\n\\n # ...\\n\\n self.logger.debug(\\\"finishing fit\\\")\\n return(self)\",\n \"def FM(user_feature_columns, item_feature_columns, l2_reg_embedding=1e-6, loss_type='softmax', temperature=0.05,\\n sampler_config=None, seed=1024,\\n ):\\n\\n embedding_matrix_dict = create_embedding_matrix(user_feature_columns + item_feature_columns, l2_reg_embedding,\\n seed=seed,\\n seq_mask_zero=True)\\n\\n user_features = build_input_features(user_feature_columns)\\n user_inputs_list = list(user_features.values())\\n user_sparse_embedding_list, _ = input_from_feature_columns(user_features,\\n user_feature_columns,\\n l2_reg_embedding, seed=seed,\\n support_dense=False,\\n embedding_matrix_dict=embedding_matrix_dict)\\n\\n item_features = build_input_features(item_feature_columns)\\n item_inputs_list = list(item_features.values())\\n item_sparse_embedding_list, _ = input_from_feature_columns(item_features,\\n item_feature_columns,\\n l2_reg_embedding, seed=seed,\\n support_dense=False,\\n embedding_matrix_dict=embedding_matrix_dict)\\n\\n user_dnn_input = concat_func(user_sparse_embedding_list, axis=1)\\n user_vector_sum = Lambda(lambda x: reduce_sum(x, axis=1, keep_dims=False))(user_dnn_input)\\n user_vector_sum = l2_normalize(user_vector_sum)\\n\\n item_dnn_input = concat_func(item_sparse_embedding_list, axis=1)\\n item_vector_sum = Lambda(lambda x: reduce_sum(x, axis=1, keep_dims=False))(item_dnn_input)\\n item_vector_sum = l2_normalize(item_vector_sum)\\n\\n if loss_type == \\\"logistic\\\":\\n score = inner_product(user_vector_sum, item_vector_sum, temperature)\\n output = PredictionLayer(\\\"binary\\\", False)(score)\\n\\n elif loss_type == \\\"softmax\\\":\\n output = InBatchSoftmaxLayer(sampler_config._asdict(), temperature)(\\n [user_vector_sum, item_vector_sum, item_features[sampler_config.item_name]])\\n else:\\n raise ValueError(' `loss_type` must be `logistic` or `softmax` ')\\n\\n model = Model(inputs=user_inputs_list + item_inputs_list, outputs=output)\\n\\n model.__setattr__(\\\"user_input\\\", user_inputs_list)\\n model.__setattr__(\\\"user_embedding\\\", user_vector_sum)\\n\\n model.__setattr__(\\\"item_input\\\", item_inputs_list)\\n model.__setattr__(\\\"item_embedding\\\", item_vector_sum)\\n\\n return model\",\n \"def getUserItemMatrix(self):\\n\\t\\tdf = self.getrating()\\n\\n\\t\\trows_index = df.user_id.unique()\\n\\t\\tcolumn_index = df.venue_id.unique() \\n\\n\\t\\trow_len = len(rows_index)\\n\\t\\tcol_len = len(column_index)\\n\\n\\t\\tX = lil_matrix((row_len, col_len))\\n\\t\\trow_map = dict(zip(rows_index, range(row_len)))\\n\\t\\tcol_map = dict(zip(column_index, range(col_len)))\\n\\n\\t\\t# Get mapping table for rows and columns\\n\\t\\td = {}\\n\\t\\td[\\\"row\\\"] = row_map\\n\\t\\td[\\\"col\\\"] = col_map\\n\\n\\t\\tfor index, row in df.iterrows():\\n\\t\\t\\tX[d[\\\"row\\\"][row[\\\"user_id\\\"]], d[\\\"col\\\"][row[\\\"venue_id\\\"]]] = row[\\\"Rating\\\"]\\n\\n\\t\\tX = X.tocsr() # Allow efficient row slicing\\n\\n\\t\\treturn [d,X]\",\n \"def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\\n active_user = actives[0][0]\\n active_item = actives[0][1]\\n\\n # -----------------------------------\\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\\n\\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\\n return (active_user, active_item), 2.5\\n\\n # all user, ratings that have rated active_item\\n if active_item in train_rdd_gbitem_dict:\\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\\n else:\\n # item not found in training set\\n # new item problem.\\n average_of_user_list = train_rdd_gbuser_dict[active_user]\\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\\n return (active_user, active_item), average_of_user\\n\\n # user rated items - all (item, ratings) that the user has rated\\n if active_user in train_rdd_gbuser_dict:\\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\\n else:\\n # user not found in training set\\n # new user problem.\\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\\n\\n similarity_list = []\\n for item, rating in active_user_rated_items:\\n item_dict = dict(train_rdd_gbitem_dict[item][0])\\n item_avg = train_rdd_gbitem_dict[item][1]\\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\\n similarity_list.append((rating, similarity))\\n\\n # Have obtained similarity list for active item and item from the above code.\\n # Filter according to a top 'N' items and then take avg rating.\\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\\n # similarity_list = similarity_list[:len(similarity_list) // 4]\\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\\n # print(similarity_list)\\n pred_rating = find_weighted_average(similarity_list, num_items)\\n\\n # for i in similarity_list:\\n # print(i)\\n # print(\\\"Pred-rating: \\\", pred_rating)\\n\\n return (active_user, active_item), pred_rating\",\n \"def convert_fidelity_matrix(fidelities, fidelity, sx, factor):\\n\\n matrix = np.zeros((sx, fidelities - 1))\\n for idx in range(0, fidelity):\\n matrix[:, idx] = np.ones((sx)) * factor[fidelity]\\n\\n return matrix\",\n \"def train_nmf(movies_ratings):\\n \\n #pivot the dataframe\\n movies_ratings = movies_ratings.pivot_table(index='userId', columns='movieId', values='rating')\\n #Fill Nan with 3.0 rating:\\n movies_ratings.fillna(3.0, inplace=True)\\n\\n nmf_model = NMF(\\n n_components=20,\\n init='random',\\n random_state=10,\\n max_iter=10000\\n )\\n nmf_model.fit(movies_ratings)\\n\\n #save nmf model\\n pickle.dump(nmf_model,open(\\\"models/nmf_model.sav\\\", 'wb'))\",\n \"def metric_test(self):\\n k = 10\\n latent_factor = 10\\n n_users = 10\\n n_items = 12\\n\\n interactions, user_features, item_features = util.generate_dummy_data_with_indicator (num_users=n_users, num_items=n_items, interaction_density=.5)\\n print (\\\"interactiosn shape={}\\\".format( np.shape(interactions) ))\\n print (\\\"user features shape={}\\\".format( np.shape(user_features.toarray()) ))\\n print (\\\"item features shape={}\\\".format( np.shape(item_features.toarray()) ))\\n\\n model = TensorRec(n_components=latent_factor)\\n\\n model.fit(interactions, user_features, item_features, epochs=19)\\n\\n ranks = model.predict_rank(user_features=user_features, item_features=item_features)\\n\\n print (\\\"Ranks shape={}\\\".format(np.shape(ranks)))\\n\\n self.assertTrue(np.shape(interactions) == np.shape(ranks))\\n\\n tr_recall_result = eval.recall_at_k(predicted_ranks=ranks, test_interactions=interactions, k=k, preserve_rows=False)\\n # print (tr_recall_result.mean())\\n\\n tr_precision_result = eval.precision_at_k(predicted_ranks=ranks, test_interactions=interactions, k=k, preserve_rows=False)\\n # print(tr_precision_result.mean())\\n\\n # we need csr for interactions data\\n interactions_ = interactions.tocsr()\\n recall_result = metrics.recall_at_k(ranks, interactions_, k=k, preserve_rows=False)\\n # print(recall_result.mean())\\n\\n precision_result = metrics.precision_at_k(ranks, interactions_, k=k, preserve_rows=False)\\n # print (precision_result.mean())\\n\\n self.assertTrue (tr_recall_result.mean() == recall_result.mean())\\n self.assertTrue (tr_precision_result.mean() == precision_result.mean())\",\n \"def update_user_feature(\\n train, user_features, item_features, lambda_user,\\n nz_user_itemindices, I):\\n for d, user_d in enumerate(nz_user_itemindices): # iterate over non zero users\\n nnz_items_per_user = len(user_d[1]) # Number of items user d has rated\\n if (nnz_items_per_user == 0): nnz_items_per_user = 1\\n \\n # Least squares solution\\n A_d = np.dot(item_features[user_d[1]].T, item_features[user_d[1]]) + lambda_user * nnz_items_per_user * I\\n V_d = np.dot(item_features[user_d[1]].T, train[user_d[1],user_d[0]].todense())\\n user_features[:,user_d[0]] = np.linalg.solve(A_d,V_d)\",\n \"def _estimate_ratings(self, U, V):\\n Rhat = np.matmul(U, V.transpose()) # estimate R with UV^T\\n Rhat = np.where(self.R_missing, 0, Rhat) # fill in missing values of R with 0s\\n return Rhat\",\n \"def estimate(self, u, j):\\n if not (self.trainset.knows_user(u) and self.trainset.knows_item(j)):\\n raise PredictionImpossible('User and/or item is unknown.')\\n\\n u_ratings = self.trainset.ur[u]\\n\\n if self.weighting == 'linear':\\n weight = sum(self.freqs[i, j, self.to_index(r)] for i, r in u_ratings)\\n score = sum(self.sums[i, j, self.to_index(r)] for i, r in u_ratings)\\n return score / weight\\n\\n # self.weighting == 'log' or None\\n weights = [self.freqs[i, j, self.to_index(r)] for i, r in u_ratings]\\n reciprocals = [1 / w if w else 0 for w in weights]\\n scores = [self.sums[i, j, self.to_index(r)] for i, r in u_ratings]\\n scores = [s * w for s, w in zip(scores, reciprocals)]\\n\\n if self.weighting is None:\\n return np.mean(scores)\\n # self.weighting == 'log'\\n logs = [np.log(w + 1) if w >= 1 else 0 for w in weights]\\n return np.dot(scores, logs) / np.sum(logs)\",\n \"def compute_user_user_sim_base_on_common_items(self):\\n self.sim_matrix = {}\\n for item in self.items.values():\\n # convert to list of tuples for indexing\\n users = list(item.covered_users.items())\\n item_popularity = len(users)\\n # iter through all user pairs\\n for i in range(len(users)-1):\\n for j in range(i+1, len(users)):\\n user_A_info, user_B_info = users[i], users[j]\\n # remember to update pair wise!\\n self.update_user_user_sim(user_A_info, user_B_info,\\n item_popularity)\\n self.update_user_user_sim(user_B_info, user_A_info,\\n item_popularity)\",\n \"def compute_pmf(X_inp, rank, c1, c2):\\n\\n X_arr = []\\n u_arr = []\\n v_arr = []\\n d_arr = []\\n\\n X = deepcopy(X_inp)\\n\\n v_init = np.ones((np.shape(X)[1],1))\\n\\n for i in range(rank):\\n X_arr.append(X)\\n (d,u,v) = compute_factor(X, v_init, c1, c2)\\n\\n\\n assert abs(npla.norm(u) - 1 ) < 1e-3\\n assert abs(npla.norm(v) - 1 ) < 1e-3\\n\\n d_arr.append(d)\\n u_arr.append(u)\\n v_arr.append(v)\\n\\n toSub = np.outer(u,v)\\n assert np.shape(toSub) == np.shape(X)\\n X -= d * toSub\\n\\n return (X_arr, u_arr, v_arr, d_arr)\",\n \"def item_based_CF(G):\\n\\n\\tcode, pmid = nx.bipartite.sets(G)\\n\\tX = nx.bipartite.biadjacency_matrix(G,pmid,column_order=code)\\n\\tmean_X = np.mean(X,axis=0)\\n\\tadjusted_X = X - mean_X\\n\\tsimilarity = cosine_similarity(X.T)\\n\\trating = mean_X + np.dot(adjusted_X,similarity)/np.sum(np.abs(similarity),axis=1)\\n\\tdf = pd.DataFrame(data=rating,index=pmid,columns=code)\\n\\n\\treturn df\",\n \"def predict_rating(self, user_id, item_id):\\n user_preference = self.latent_user_preferences[user_id]\\n item_feature = self.latent_item_features[item_id]\\n return user_preference.dot(item_feature)\",\n \"def create_user_item_array(self):\\n user_em = self.user_factors.weight.detach()\\n item_em = self.product_factors.weight.detach()\\n user_b = self.user_bias.weight.detach()\\n item_b = self.product_bias.weight.detach()\\n\\n user_item_array = (item_em + item_b) @ (user_em + user_b).transpose(0, 1)\\n preds = self._prob_to_class(user_item_array).numpy()\\n\\n return preds\",\n \"def als(user_ids : numpy.ndarray, item_ids : numpy.ndarray,\\n ratings : numpy.ndarray, num_item_factors : int,\\n num_users: int, num_items : int, min_r_decrease=0.01,\\n max_iterations=200, algorithm=1):\\n # allocate \\\"user_factors\\\" and \\\"item_factors\\\"\\n num_user_factors = num_item_factors + 1\\n user_factors = numpy.random.uniform(-1, 1, num_users * num_user_factors)\\n item_factors = numpy.random.uniform(-1, 1, num_items * num_item_factors)\\n\\n # argument construction\\n user_ids_ptr = user_ids.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n item_ids_ptr = item_ids.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n\\n ratings_length = len(ratings)\\n ratings_ptr = ratings.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n\\n user_factors_length = len(user_factors)\\n user_factors_ptr = user_factors.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n\\n item_factors_length = len(item_factors)\\n item_factors_ptr = item_factors.ctypes.data_as(ctypes.POINTER(ctypes.c_double))\\n\\n iterations = _dll.als_from_python(\\n user_ids_ptr, item_ids_ptr, ratings_length, ratings_ptr,\\n num_item_factors, user_factors_length, user_factors_ptr,\\n item_factors_length, item_factors_ptr, ctypes.c_double(min_r_decrease),\\n max_iterations, algorithm)\\n\\n return user_factors, item_factors, iterations\",\n \"def NMF(model, maxIter=100, beliefs=None, verbose=False):\\n if beliefs is None: beliefs = [Factor([Xi],1.0/Xi.states) for Xi in model.X]\\n \\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\\n for f in model.factors:\\n m = f.log()\\n for v in f.vars: m *= beliefs[v]\\n lnZ += m.sum()\\n if verbose: print(\\\"Iter 0: \\\"+str(lnZ))\\n\\n for t in xrange(1,maxIter+1): # for each iteration:\\n # Update all the beliefs via coordinate ascent:\\n for Xi in model.X: # for each variable, \\n bNew = 0.0 # compute E[ log f ] as a function of Xi:\\n for f in model.factorsWith(Xi,copy=False): # for each factor f_a, compute:\\n m = f.log() # E[log f_a] = \\\\sum \\\\log f_a \\\\prod b_v\\n for v in f.vars - [Xi]: m *= beliefs[v]\\n bNew += m.marginal([Xi]) # sum them up to get E[log f]\\n bNew -= bNew.max() # (numerical issues)\\n bNew = bNew.exp()\\n bNew /= bNew.sum() # set b(Xi) = exp( E[log f] ) / Z\\n beliefs[Xi] = bNew\\n #\\n # Compute the lower bound on the partition function:\\n # E_b [ log f ] + H(b) = \\\\sum_a E[log f_a] + \\\\sum_i H(b_i) for independent beliefs\\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\\n for f in model.factors:\\n m = f.log()\\n for v in f.vars: m *= beliefs[v]\\n lnZ += m.sum()\\n if verbose: print(\\\"Iter \\\"+str(t)+\\\": \\\"+str(lnZ))\\n return lnZ,beliefs\",\n \"def final_recommendation_score_matrix_helper_for_different_knn_types(self, type_of_method, index_matrix, value_matrix):\\n if type_of_method == \\\"user\\\":\\n for i in range(index_matrix.shape[1]):\\n temp = index_matrix[:,i].astype(int)\\n k_similar_users_profiles = self.utility_matrix[temp]\\n k_similar_users_similarity_values = value_matrix[:,i]\\n self.final_score_matrix[i,:] = np.dot(k_similar_users_similarity_values,k_similar_users_profiles)\\n elif type_of_method == \\\"item\\\":\\n for i in range(index_matrix.shape[1]):\\n temp = index_matrix[:,i].astype(int)\\n k_similar_item_profiles = self.utility_matrix.T[temp]\\n k_similar_item_similarity_values = value_matrix[:,i]\\n self.final_score_matrix[:,i] = np.dot(k_similar_item_similarity_values,k_similar_item_profiles)\",\n \"def get_users_features_matrix(games_features_matrix: csr_matrix, users_games_matrix: csr_matrix) -> csr_matrix:\\n logging.getLogger(__name__).debug('Users features matrix calculating...')\\n users_features_matrix = users_games_matrix * games_features_matrix\\n logging.getLogger(__name__).debug('users_features_matrix.shape: ' + str(users_features_matrix.shape))\\n return users_features_matrix\",\n \"def NMF(X,r):\\n nmf_mdl = nmf.NMF(X,num_bases=r)\\n nmf_mdl.initialization()\\n nmf_mdl.factorize()\\n return nmf_mdl.W,nmf_mdl.H,np.dot(nmf_mdl.W,nmf_mdl.H)\",\n \"def fit(self, data, num_features, lambda_user, lambda_item, gamma):\\n user_matrix, item_matrix = self.init_matrix(data, num_features)\\n nnz_users, nnz_items = data.nonzero()\\n nnz_data = list(zip(nnz_users, nnz_items))\\n for it in tqdm(range(self.num_epochs)):\\n gamma /= 1.1\\n np.random.shuffle(nnz_data)\\n for u, i in nnz_data:\\n user = user_matrix[u, :]\\n item = item_matrix[:, i]\\n err = data[u, i] - user @ item\\n user_matrix[u, :] += gamma * (err * item - lambda_user * user)\\n item_matrix[:, i] += gamma * (err * user - lambda_item * item)\\n\\n self.user_matrix = user_matrix\\n self.item_matrix = item_matrix\",\n \"def evaluate_hmdb51_fusion():\\n vlen = 0\\n ob_suffix = '-max.feat.npy.gz'\\n fv_suffix = '_fv.npy.gz'\\n ob_root = '/home/syq/research_final/data/features/ob_hmdb51_pooled_python/'\\n fv_root = '/home/syq/research_final/data/dense-traj/fv_hmdb51_python/'\\n hmdb_splits = 'testTrainMulti_7030_splits/'\\n categories = os.listdir(fv_root)\\n weight = 1.0\\n weights = [i / 20.0 for i in range(21)]\\n acc_to_weights = {}\\n\\n for weight in weights:\\n print \\\"Weight: %.2f\\\" % weight\\n accs = np.zeros(3)\\n for splitnum in range(1,4):\\n ts = time.time()\\n trainfiles, testfiles = hmdb51_splits.loadsplit(categories,\\n hmdb_splits,\\n splitnum)\\n print 'Have %d train files' % len(trainfiles)\\n print 'Have %d test files' % len(testfiles)\\n\\n if not vlen:\\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(trainfiles[0][0][:-4],\\n ob_suffix)),\\\"rb\\\")\\n vlen_ob = len(np.load(fp))\\n fp.close()\\n print \\\"OB vector length is %d\\\" % vlen_ob\\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(trainfiles[0][0][:-4],\\n fv_suffix)),\\\"rb\\\")\\n vlen_fv = len(np.load(fp))\\n fp.close()\\n print \\\"IDTFV vector length is %d\\\" % vlen_fv\\n\\n Dtrain_ob = np.zeros( (len(trainfiles),vlen_ob), np.float32 )\\n Dtrain_fv = np.zeros( (len(trainfiles),vlen_fv), np.float32 )\\n\\n Ytrain = np.ones ( (len(trainfiles) )) * -1000\\n\\n for fi,f in enumerate(trainfiles):\\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\\n ob_suffix)),\\\"rb\\\")\\n Dtrain_ob[fi][:] = np.load(fp)\\n fp.close()\\n Ytrain[fi] = f[1]\\n\\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\\n fv_suffix)),\\\"rb\\\")\\n Dtrain_fv[fi][:] = np.load(fp)\\n fp.close()\\n\\n Dtest_ob = np.zeros( (len(testfiles),vlen_ob), np.float32 )\\n Dtest_fv = np.zeros( (len(testfiles),vlen_fv), np.float32 )\\n\\n Ytest = np.ones ( (len(testfiles) )) * -1000\\n\\n for fi,f in enumerate(testfiles):\\n fp = gzip.open(os.path.join(ob_root,'%s%s'%(f[0][:-4],\\n ob_suffix)),\\\"rb\\\")\\n Dtest_ob[fi][:] = np.load(fp)\\n fp.close()\\n Ytest[fi] = f[1]\\n\\n fp = gzip.open(os.path.join(fv_root,'%s%s'%(f[0][:-4],\\n fv_suffix)),\\\"rb\\\")\\n Dtest_fv[fi][:] = np.load(fp)\\n fp.close()\\n\\n \\\"\\\"\\\"\\n Early fusion\\n Dtrain = np.hstack((Dtrain_ob, Dtrain_fv))\\n Dtest = np.hstack((Dtest_ob, Dtest_fv))\\n\\n clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\\n acc = clf.fit(Dtrain, Ytrain).score(Dtest, Ytest)\\n \\\"\\\"\\\"\\n fv_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\\n\\n ob_clf = OneVsRestClassifier(estimator=SVC(C=10,\\n cache_size=1000,\\n kernel='linear',\\n probability=True),\\n n_jobs=-1)\\n\\n # Get probabilities for late fusion\\n Dtrain_fv = fv_clf.fit(Dtrain_fv, Ytrain).decision_function(Dtrain_fv)\\n Dtrain_ob = ob_clf.fit(Dtrain_ob, Ytrain).decision_function(Dtrain_ob)\\n Dtest_fv = fv_clf.decision_function(Dtest_fv)\\n Dtest_ob = ob_clf.decision_function(Dtest_ob)\\n\\n # Scale decision values b/w 0 and 1\\n Dtrain_fv = preprocessing.normalize(Dtrain_fv)\\n Dtrain_ob = preprocessing.normalize(Dtrain_ob)\\n Dtest_fv = preprocessing.normalize(Dtest_fv)\\n Dtest_ob = preprocessing.normalize(Dtest_ob)\\n\\n # Late fusion\\n scores_train = (Dtrain_fv * weight) + (Dtrain_ob * (1 - weight))\\n latefusion_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=-1)\\n latefusion_clf.fit(scores_train, Ytrain)\\n\\n scores_test = (Dtest_fv * weight) + (Dtest_ob * (1 - weight))\\n acc = latefusion_clf.score(scores_test, Ytest)\\n print 'Fold', splitnum, 'late fusion acc', acc\\n print \\\"Train & testing time %.3f\\\" % (time.time() - ts)\\n accs[splitnum-1] = acc\\n acc_to_weights[weight] = accs\\n\\n print \\\"Mean accuracy: %.3f\\\" % accs.mean()\\n with open(\\\"hmdb51_weight_gridsearch.txt\\\", \\\"w\\\") as f:\\n for weight, accs in acc_to_weights.items():\\n f.write(str(weight) + str(accs) + '\\\\n')\\n return acc_to_weights\\n\\n \\\"\\\"\\\"\\n with open('fv_hmdb51_accs.txt', 'w') as f:\\n f.write(\\\"%s\\\\nMean:%.3f\\\" % (str(accs), np.mean(accs)))\\n \\\"\\\"\\\"\",\n \"def mrr(self):\\n _test = self.drop_bad_ratings()\\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\\n ['user', 'item', 'rating_x', 'rating_y']]\\n nott = np.vectorize(lambda x: not x)\\n mrrs = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\\n true_ratings = frame.rating_x.values\\n positions = np.where(nott(np.isnan(true_ratings)))[0]\\n if len(positions) > 0:\\n mrrs.append(1 / (positions[0] + 1))\\n else:\\n mrrs.append(0)\\n\\n return sum(mrrs) / len(mrrs)\",\n \"def feature_processing(array2d):\\n new_array2d = np.zeros([array2d.shape[0], 29])\\n # items/ orders\\n new_array2d[:, 0] = array2d[:, 4] / array2d[:, 3]\\n # cancels / orders\\n new_array2d[:, 1] = array2d[:, 5] / array2d[:, 3]\\n # returns / items\\n new_array2d[:, 2] = array2d[:, 6] / array2d[:, 4]\\n # voucher / orders\\n new_array2d[:, 3] = array2d[:, 10] / array2d[:, 3]\\n # female_items / female_items + male_items\\n new_array2d[:, 4] = array2d[:, 15] / ([1 if x == 0 else x for x in (array2d[:, 15] + array2d[:, 16])])\\n # male_items / female_items + male_items\\n new_array2d[:, 5] = array2d[:, 16] / ([1 if x == 0 else x for x in (array2d[:, 15] + array2d[:, 16])])\\n # unisex_items / items\\n new_array2d[:, 6] = array2d[:, 17] / array2d[:, 4]\\n # wapp_items / items\\n new_array2d[:, 7] = array2d[:, 18] / array2d[:, 4]\\n # wftw_items / items\\n new_array2d[:, 8] = array2d[:, 19] / array2d[:, 4]\\n # mapp_items / items\\n new_array2d[:, 9] = array2d[:, 20] / array2d[:, 4]\\n # wacc_items / items\\n new_array2d[:, 10] = array2d[:, 21] / array2d[:, 4]\\n # macc_items / items\\n new_array2d[:, 11] = array2d[:, 22] / array2d[:, 4]\\n # mftw_items / items\\n new_array2d[:, 12] = array2d[:, 23] / array2d[:, 4]\\n # wspt_items / items\\n new_array2d[:, 13] = array2d[:, 24] / array2d[:, 4]\\n # mspt_items / items\\n new_array2d[:, 14] = array2d[:, 25] / array2d[:, 4]\\n # curvy_items / items\\n # Curvy item has a strong correlation with gender, however they are very right-skewed use np.power(1/6) to smooth it\\n new_array2d[:, 15] = np.power(array2d[:, 26] / array2d[:, 4], 1 / 6)\\n # sacc_items / items\\n new_array2d[:, 16] = array2d[:, 27] / array2d[:, 4]\\n # msite_orders / orders\\n new_array2d[:, 17] = array2d[:, 28] / array2d[:, 3]\\n # desktop_orders / orders\\n new_array2d[:, 18] = array2d[:, 29] / array2d[:, 3]\\n # android_orders / orders\\n new_array2d[:, 19] = array2d[:, 30] / array2d[:, 3]\\n # ios_orders / orders\\n new_array2d[:, 20] = array2d[:, 31] / array2d[:, 3]\\n # other_device_orders / orders\\n new_array2d[:, 21] = array2d[:, 32] / array2d[:, 3]\\n # work_orders / orders\\n new_array2d[:, 22] = array2d[:, 33] / array2d[:, 3]\\n # home_orders / orders\\n new_array2d[:, 23] = array2d[:, 34] / array2d[:, 3]\\n # parcelpoint_orders / orders\\n new_array2d[:, 24] = array2d[:, 35] / array2d[:, 3]\\n # other_collection_orders / orders\\n new_array2d[:, 25] = array2d[:, 36] / array2d[:, 3]\\n # average_discount_onoffer\\n new_array2d[:, 26] = array2d[:, 39]\\n # average_discount_used\\n new_array2d[:, 27] = array2d[:, 40]\\n # revenue / order\\n new_array2d[:, 28] = array2d[:, 41] / array2d[:, 3]\\n\\n # normalize by each feature\\n new_array2d = normalize(new_array2d, axis=0, norm='max')\\n return new_array2d\",\n \"def __init__(\\n self,\\n n_users,\\n n_products,\\n n_factors=20,\\n optimizer=torch.optim.SGD,\\n lr=0.001,\\n l2=0,\\n momentum=0,\\n loss_fn=nn.BCEWithLogitsLoss,\\n activation=nn.Sigmoid,\\n ):\\n super(NNMatrixFactorization, self).__init__()\\n\\n self.l2 = l2\\n self.lr = lr\\n self.momentum = momentum\\n self.user_factors = ScaledEmbedding(n_users, n_factors)\\n self.product_factors = ScaledEmbedding(n_products, n_factors)\\n self.user_bias = ZeroEmbedding(n_users, 1)\\n self.product_bias = ZeroEmbedding(n_products, 1)\\n\\n self.activation = activation()\\n self.loss_fn = loss_fn()\\n self.optimizer = optimizer(\\n self.parameters(), lr=self.lr, weight_decay=self.l2, momentum=self.momentum\\n )\",\n \"def get_scores(self):\\n hist = self.confusion_matrix\\n # hist = [TN,FP;FN,TP]\\n acc = np.diag(hist).sum() / hist.sum()\\n acc_cls = np.diag(hist) / hist.sum(axis=1)\\n acc_cls = np.nanmean(acc_cls)\\n iu = np.diag(hist) / (hist.sum(axis=1) + hist.sum(axis=0) - np.diag(hist))\\n # iou = iu.sum() / self.n_classes\\n mean_iou = np.nanmean(iu) # if classes = 2: iou = miou\\n freq = hist.sum(axis=1) / hist.sum()\\n fwavacc = (freq[freq > 0] * iu[freq > 0]).sum()\\n cls_iou = dict(zip(range(self.n_classes), iu))\\n\\n ##############################################\\n tn = hist[0, 0]\\n tp = np.diag(hist).sum() - tn\\n fp = np.triu(hist, 1).sum()\\n fn = np.tril(hist, -1).sum()\\n precision = tp / (tp + fp)\\n recall = tp / (tp + fn)\\n f1 = 2 * precision * recall / (precision + recall)\\n\\n # for medical img, img_seg \\\\in [0,1]\\n dice = 2 * tp / (tp + tp + fn + fp)\\n # dice = f1-score\\n dsc = 2 * tp / (tp + fn + fp)\\n # dsc = jaccard\\n # voe = 2 * abs(fp + fn) / (tp + tp + fn + fp)\\n # voe = 1 - dsc\\n\\n k2 = {\\n # \\\"Overall Acc: \\\\t\\\": acc,\\n 'Mean Acc': float(judge_nan(acc_cls)),\\n # \\\"FreqW Acc : \\\\t\\\": fwavacc,\\n 'Mean IoU': float(judge_nan(mean_iou)),\\n 'F1-score': float(judge_nan(f1)),\\n 'DSC': float(judge_nan(dsc)),\\n 'Precision': float(judge_nan(precision)),\\n 'Recall': float(judge_nan(recall)),\\n }\\n\\n return k2\",\n \"def predict(user_id, item_id, ratings):\\n\\n # convert long to wide\\n ratings_wide = ratings.pivot(index='user', columns='movie', values='rating')\\n\\n # compute user similarities\\n similarities = compute_similarities(user_id, ratings_wide)\\n \\n prediction = predict_rating(item_id, ratings_wide, similarities, N=N_NEIGHBORS)\\n \\n return prediction\",\n \"def __factor_matrix(self, R, K, alpha, steps, beta, error_limit):\\n # Transform regular array to numpy array\\n R = numpy.array(R)\\n\\n # Generate P - N x K\\n # Use random values to start. Best performance\\n N = len(R)\\n M = len(R[0])\\n P = numpy.random.rand(N, K)\\n\\n # Generate Q - M x K\\n # Use random values to start. Best performance\\n Q = numpy.random.rand(M, K)\\n Q = Q.T\\n\\n error = 0\\n\\n # iterate through max # of steps\\n for step in xrange(steps):\\n\\n # iterate each cell in r\\n for i in xrange(len(R)):\\n for j in xrange(len(R[i])):\\n if R[i][j] > 0:\\n\\n # get the eij (error) side of the equation\\n eij = R[i][j] - numpy.dot(P[i, :], Q[:, j])\\n\\n for k in xrange(K):\\n # (*update_rule) update pik_hat\\n P[i][k] = P[i][k] + alpha * (2 * eij * Q[k][j] - beta * P[i][k])\\n\\n # (*update_rule) update qkj_hat\\n Q[k][j] = Q[k][j] + alpha * ( 2 * eij * P[i][k] - beta * Q[k][j] )\\n\\n # Measure error\\n error = self.__error(R, P, Q, K, beta)\\n\\n # Terminate when we converge\\n if error < error_limit:\\n break\\n\\n # track Q, P (learned params)\\n # Q = Products x feature strength\\n # P = Users x feature strength\\n self.Q = Q.T\\n self.P = P\\n\\n self.__print_fit_stats(error, N, M)\",\n \"def recommend(self, user_id, N=10):\\n scores = self.user_factors[user_id] @ self.product_factors.T\\n best = np.argpartition(scores, -N)[-N:]\\n return sorted(zip(best, scores[best]), key=lambda x: -x[1])\",\n \"def weighted_majority_vote(c_pred,m_pred,f_pred,acc_c,acc_m,acc_f, dataset):\\n c,m,f = np.argmax(c_pred),np.argmax(m_pred),np.argmax(f_pred)\\n coarse = np.zeros(2)\\n middle = np.zeros(4)\\n fine = np.zeros(10)\\n\\n if dataset == 'cifar10':\\n middle = np.zeros(5)\\n coarse[c] = 1\\n middle[m] = 1\\n fine[f] = 1\\n res = np.zeros(10)\\n w1 = np.log(acc_c/(1.-acc_c))\\n w2 = np.log(acc_m/(1.-acc_m))\\n w3 = np.log(acc_f/(1.-acc_f))\\n if dataset == 'cifar10':\\n for i in range(10):\\n if i <2:\\n res[i] = w1*coarse[0] + w2*middle[0] + w3*fine[i]\\n elif 2<=i <4:\\n res[i] = w1*coarse[0] + w2*middle[1] + w3*fine[i]\\n elif 4 <=i<6:\\n res[i] = w1*coarse[1] + w2*middle[2] + w3*fine[i]\\n elif 6<=i<8:\\n res[i] = w1*coarse[1] + w2*middle[3] + w3*fine[i]\\n else:\\n res[i] = w1*coarse[1] + w2*middle[4] + w3*fine[i]\\n else :\\n for i in range(10):\\n if i <3:\\n res[i] = w1*coarse[0] + w2*middle[0] + w3*fine[i]\\n elif 3<=i <5:\\n res[i] = w1*coarse[0] + w2*middle[1] + w3*fine[i]\\n elif 5 <=i<8:\\n res[i] = w1*coarse[1] + w2*middle[2] + w3*fine[i]\\n else:\\n res[i] = w1*coarse[1] + w2*middle[3] + w3*fine[i]\\n index = np.argmax(res)\\n return(index)\",\n \"def _compute_mu_factor2(*input_mols):\\n mu_factor = 1\\n for mol in input_mols:\\n mu_factor *= np.prod(fact(mol))\\n return mu_factor\",\n \"def update_model(self):\\n temp_uservisits = self._uservisits\\n unique_users = temp_uservisits['userid'].unique()\\n for itemidx, itemid in self._allitems.iterrows():\\n self.__itemid2idx[str(itemid['itemid'])] = itemidx\\n self.__itemidx2id[itemidx] = str(itemid['itemid'])\\n for useridx, userid in enumerate(unique_users):\\n self.__userid2idx[str(userid)] = useridx\\n self.__useridx2id[useridx] = str(userid)\\n useritem = set(temp_uservisits[temp_uservisits['userid'] == userid]['itemid'].astype('str').values)\\n allitem = set(self.__itemid2idx.keys())\\n itemsnotinuser = allitem - useritem\\n self.__useridx2nvitems[useridx] = list(itemsnotinuser)\\n temp = pandas.DataFrame([{\\\"userid\\\": userid, \\\"itemid\\\": t, \\\"rating\\\": 0, \\\"timestamp\\\": \\\"NA\\\"} for t in itemsnotinuser])\\n temp_uservisits = pandas.concat([temp_uservisits, temp])\\n userid = temp_uservisits['userid'].values\\n itemid = temp_uservisits['itemid'].values\\n rating = temp_uservisits['rating'].values\\n useridx = [self.__userid2idx[str(int(uid))] for uid in userid]\\n itemidx = [self.__itemid2idx[str(int(iid))] for iid in itemid]\\n model = self.__get_model(num_users=len(temp_uservisits['userid'].unique()), num_items=len(self._allitems),\\n mf_dim=self.__numtopics)\\n if self.__learner.lower() == \\\"adagrad\\\":\\n model.compile(optimizer=Adagrad(lr=self.__learningrate), loss='binary_crossentropy')\\n elif self.__learner.lower() == \\\"rmsprop\\\":\\n model.compile(optimizer=RMSprop(lr=self.__learningrate), loss='binary_crossentropy')\\n elif self.__learner.lower() == \\\"adam\\\":\\n model.compile(optimizer=Adam(lr=self.__learningrate), loss='binary_crossentropy')\\n else:\\n model.compile(optimizer=SGD(lr=self.__learningrate), loss='binary_crossentropy')\\n\\n for epoch in range(self.__numiterations):\\n t1 = time.time()\\n hist = model.fit([numpy.array(useridx), numpy.array(itemidx)], numpy.array(rating),\\n batch_size=self.__batchsize, nb_epoch=1, verbose=0, shuffle=True)\\n t2 = time.time()\\n self.__recommender1 = model\\n rating = list(map(numpy.double, rating))\\n self.__itemuser = csr_matrix((rating, (useridx, itemidx)), shape=(len(set(useridx)), len(set(itemidx))))\\n self.__recommender2 = implicit.als.AlternatingLeastSquares(factors=self.__numtopics)\\n self.__recommender2.fit(self.__itemuser)\",\n \"def create_matrix(ratings_df, jokes_df):\\r\\n \\\"\\\"\\\" note: empty entries are populated with zeros \\\"\\\"\\\"\\r\\n\\r\\n matrix_handler = matrix_object()\\r\\n\\r\\n num_joke_features = 5\\r\\n\\r\\n ''' add all joke features '''\\r\\n for row_idx in range(0, jokes_df.shape[0]):\\r\\n joke_idx = int(jokes_df.iloc[row_idx][\\\"Idx\\\"])\\r\\n isAggressive = jokes_df.iloc[row_idx][\\\"isAggressive\\\"]\\r\\n isIncongruence = jokes_df.iloc[row_idx][\\\"isIncongruence\\\"]\\r\\n generation = jokes_df.iloc[row_idx][\\\"Generation\\\"]\\r\\n isMillenial = (generation == \\\"Millenial\\\")\\r\\n isGenX = (generation == \\\"Gen X\\\")\\r\\n isGenZ = (generation == \\\"Gen Z\\\")\\r\\n\\r\\n if(int(isMillenial) == 1.0 and int(isGenX) == 1.0):\\r\\n raise Valueerror()\\r\\n\\r\\n matrix_handler.add_value(joke_idx - 1, 0, int(isAggressive))\\r\\n matrix_handler.add_value(joke_idx - 1, 1, int(isIncongruence))\\r\\n matrix_handler.add_value(joke_idx - 1, 2, int(isMillenial))\\r\\n matrix_handler.add_value(joke_idx - 1, 3, int(isGenX))\\r\\n matrix_handler.add_value(joke_idx - 1, 4, int(isGenZ))\\r\\n\\r\\n ''' add all ratings '''\\r\\n for row_idx in range(0, ratings_df.shape[0]):\\r\\n for joke_idx in range(1, 122):\\r\\n col_name = \\\"joke\\\" + str(joke_idx)\\r\\n matrix_handler.add_value(joke_idx - 1, row_idx + num_joke_features, ratings_df.iloc[row_idx][col_name])\\r\\n\\r\\n matrix = matrix_handler.compile_matrix()\\r\\n new_df = matrix_handler.to_df(matrix)\\r\\n\\r\\n return matrix, new_df\",\n \"def feature_selection_classifier_3(array2d):\\n newArray2d = np.zeros([array2d.shape[0], 18])\\n # female_items / female_items + male_items\\n newArray2d[:, 0] = array2d[:, 4]\\n # male_items / female_items + male_items\\n newArray2d[:, 1] = array2d[:, 5]\\n # wapp_items / items\\n newArray2d[:, 2] = array2d[:, 7]\\n # wftw_items / items\\n newArray2d[:, 3] = array2d[:, 8]\\n # mapp_items / items\\n newArray2d[:, 4] = array2d[:, 9]\\n # wacc_items / items\\n newArray2d[:, 5] = array2d[:, 10]\\n # macc_items / items\\n newArray2d[:, 6] = array2d[:, 11]\\n # mftw_items / items\\n newArray2d[:, 7] = array2d[:, 12]\\n # curvy_items / items\\n newArray2d[:, 8] = array2d[:, 15]\\n # msite_orders / orders\\n newArray2d[:, 9] = array2d[:, 17]\\n # desktop_orders / orders\\n newArray2d[:, 10] = array2d[:, 18]\\n # android_orders / orders\\n newArray2d[:, 11] = array2d[:, 19]\\n # ios_orders / orders\\n newArray2d[:, 12] = array2d[:, 20]\\n # other_device_orders / orders\\n newArray2d[:, 13] = array2d[:, 21]\\n # home_orders / orders\\n newArray2d[:, 14] = array2d[:, 23]\\n # other_collection_orders / orders\\n newArray2d[:, 15] = array2d[:, 25]\\n # average_discount_onoffer\\n newArray2d[:, 16] = array2d[:, 26]\\n # average_discount_used\\n newArray2d[:, 17] = array2d[:, 27]\\n return newArray2d\",\n \"def fit(self):\\n\\n rmse_old = .0\\n for epoch in range(self.epochs):\\n error_final = .0\\n\\n for user, item, feedback in self.feedback_triples:\\n pu = self.p[user] + self.y_sum_rows(user)\\n\\n # Calculate error\\n eui = feedback - self._predict_svd_plus_plus_score(user, item, pu, False)\\n error_final += (eui ** 2.0)\\n\\n # update bu and bi\\n self.bu[user] += self.bias_learn_rate * (eui - self.delta_bias * self.bu[user])\\n self.bi[item] += self.bias_learn_rate * (eui - self.delta_bias * self.bi[item])\\n\\n # Adjust the factors\\n norm_eui = eui / self.n_u[user]\\n\\n i_f = self.q[item]\\n\\n # Compute factor updates\\n delta_u = np.subtract(np.multiply(eui, i_f), np.multiply(self.delta, self.p[user]))\\n self.p[user] += np.multiply(self.learn_rate, delta_u)\\n\\n delta_i = np.subtract(np.multiply(eui, pu), np.multiply(self.delta, i_f))\\n self.q[item] += np.multiply(self.learn_rate, delta_i)\\n\\n # update y (implicit factor)\\n common_update = norm_eui * i_f\\n\\n for j in self.items_id_seen_by_user[user]:\\n delta_y = np.subtract(common_update, self.delta * self.y[j])\\n self.y[j] += self.learn_rate * delta_y\\n\\n rmse_new = np.sqrt(error_final / self.train_set[\\\"number_interactions\\\"])\\n\\n if np.fabs(rmse_new - rmse_old) <= self.stop_criteria:\\n break\\n else:\\n rmse_old = rmse_new\",\n \"def ndpm(self):\\n\\n merged = pd.merge(left=self.test, right=self.predict, on=['user', 'item'], how='inner')[\\n ['user', 'rating_x', 'rating_y']]\\n ndpms = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user]\\n if frame.shape[0] <= 1:\\n continue\\n C_plus = self.num_of_ordered_positive(frame, 'rating_x', 'rating_y')\\n C_minus = self.num_of_ordered_negative(frame, 'rating_x', 'rating_y')\\n C_u = self.num_of_ordered(frame, 'rating_x')\\n if C_u == 0:\\n continue\\n C_s = self.num_of_ordered(frame, 'rating_y')\\n C_u0 = C_u - (C_plus + C_minus)\\n ndpms.append(1 - (C_minus + 0.5 * C_u0) / C_u)\\n\\n return sum(ndpms) / len(ndpms)\",\n \"def gen_W(users, items, ratings):\\n\\n # initiate graph\\n user = users.tolist()\\n item = items.tolist()\\n rating = ratings.tolist()\\n B = nx.Graph()\\n B.add_nodes_from(user, bipartite=0)\\n B.add_nodes_from(item, bipartite=1)\\n\\n # create edges\\n for i in range(len(user)):\\n B.add_edges_from([(user[i], item[i])])\\n B[user[i]][item[i]]['weight'] = rating[i]\\n\\n users_unique = users.unique() \\n items_unique = items.unique()\\n\\n # BiAdjacency matrix - for bipartite network\\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\\n\\n # sparce form of Biadjacency matrix\\n W = spa.csr_matrix(W)\\n print('Shape of W: '+str(W.shape))\\n\\n return W, users_unique, items_unique\",\n \"def alternate_ls (u_num, Y, P, C, reg):\\n\\n\\t# get # of items/users and # of latent factors\\n\\t[i_num, f_num] = Y.shape\\n\\n\\t# output buffer\\n\\tX = np.zeros((u_num, f_num))\\n\\n\\t# precalculate YtY to improve the performance\\n\\tYtY = Y.T * Y\\n\\n\\t# iterate over each user/item\\n\\tfor u in range(u_num):\\n\\n\\t\\t# store the diagonal elements of the matrix Cu discussed in the paper in a vector\\n\\t\\tCu = C[u,:]\\n\\n\\t\\t# store the coresponding row/column of the preference matrix\\n\\t\\tPu = P[u,:]\\n\\n\\t\\t# compute Cu-I\\n\\t\\tCu_I = Cu - 1\\n\\n\\t\\t# calculate Yt(Cu-I)Y\\n\\t\\tYtCu_IY = np.zeros((f_num, f_num))\\n\\t\\tCuIY = np.multiply(Y, Cu_I.T) # weight each row of Y with Cu-I\\n\\t\\tfor row in range(f_num):\\n\\t\\t\\tfor col in range(f_num):\\n\\t\\t\\t\\tYtCu_IY[row,col] = Y[:,row].T * CuIY[:,col]\\n\\t\\t\\n\\t\\t# left term : ((YtCuY + regI)^(-1)) = (YtY + Yt(Cu-I)Y + regI)^(-1)\\n\\t\\tleft_inv = YtY + YtCu_IY + reg*np.eye(f_num)\\n\\t\\tleft = np.linalg.inv(left_inv)\\n\\n\\t\\t# right term : YtCuPu\\n\\t\\tright = Y.T * np.multiply(Cu.T, Pu.T)\\n\\n\\t\\t# compute the latent factor of the user/item\\n\\t\\tx = left * right\\n\\t\\t\\n\\t\\t# store it in a matrix\\n\\t\\tX[u,:] = x.T\\n\\n\\t# return an MxF or NxF matrix\\n\\treturn np.matrix(X)\",\n \"def calc_score(self, user_id, item_id): \\n p = np.dot(self.U[user_id], self.V[item_id])\\n if self.trunc_score_rule==None:pass\\n else: p=self.trunc_score_rule(p)\\n \\n return p\",\n \"def evaluate_ucf50_fusion():\\n accs = np.zeros(3)\\n ob_suffix = '-max.feat.npy.gz'\\n fv_suffix = '_fv.npy.gz'\\n ob_root = '/home/syq/research_final/data/features/ob_ucf50_pooled_python/'\\n fv_root = '/home/syq/research_final/data/features/fv_ucf50_python/'\\n fv_groups, full, sets = utility.split_data(fv_root,\\n suffix=fv_suffix,\\n useLooCV=False)\\n\\n ob_groups, _, _ = utility.split_data(ob_root,\\n suffix=ob_suffix,\\n useLooCV=False)\\n weights = [i / 20.0 for i in range(8, 13)]\\n acc_to_weights = {}\\n\\n for weight in weights:\\n print \\\"Weight: %.2f\\\" % weight\\n accs = np.zeros(2)\\n for i in xrange(2):\\n ts = time.time()\\n Dtrain_fv, Dtest_fv, Ytrain, Ytest = utility.load_groups(\\n fv_groups, np.setdiff1d(full, sets[i]),\\n sets[i], scale=False, verbose=False)\\n\\n Dtrain_ob, Dtest_ob, Ytrain, Ytest = utility.load_groups(\\n ob_groups, np.setdiff1d(full, sets[i]),\\n sets[i], scale=False, verbose=False)\\n\\n fv_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=8)\\n\\n ob_clf = OneVsRestClassifier(estimator=SVC(C=10,\\n cache_size=1000,\\n kernel='linear',\\n probability=True),\\n n_jobs=-1)\\n\\n # Get probabilities for late fusion\\n Dtrain_fv = fv_clf.fit(Dtrain_fv, Ytrain).decision_function(Dtrain_fv)\\n Dtrain_ob = ob_clf.fit(Dtrain_ob, Ytrain).decision_function(Dtrain_ob)\\n Dtest_fv = fv_clf.decision_function(Dtest_fv)\\n Dtest_ob = ob_clf.decision_function(Dtest_ob)\\n\\n # Scale decision values b/w 0 and 1\\n Dtrain_fv = preprocessing.normalize(Dtrain_fv)\\n Dtrain_ob = preprocessing.normalize(Dtrain_ob)\\n Dtest_fv = preprocessing.normalize(Dtest_fv)\\n Dtest_ob = preprocessing.normalize(Dtest_ob)\\n\\n # weighted averaging\\n scores_train = (Dtrain_fv * weight) + (Dtrain_ob * (1 - weight))\\n latefusion_clf = OneVsRestClassifier(estimator=LinearSVC(C=100), n_jobs=-1)\\n latefusion_clf.fit(scores_train, Ytrain)\\n\\n scores_test = (Dtest_fv * weight) + (Dtest_ob * (1 - weight))\\n latefusion_acc = latefusion_clf.score(scores_test, Ytest)\\n print 'Fold', i, 'late fusion acc', latefusion_acc\\n print \\\"Train & testing time %.3f\\\" % (time.time() - ts)\\n accs[i] = latefusion_acc\\n\\n print \\\"Mean accuracy: %.3f\\\" % accs.mean()\\n with open(\\\"fv_ucf50_accs_5fold_gridsearch.txt\\\", \\\"w\\\") as f:\\n for weight, accs in acc_to_weights.items():\\n f.write(str(weight) + str(accs) + '\\\\n')\\n return acc_to_weights\",\n \"def _predict_user_item(self, user, item):\\n if not isinstance(user, int):\\n user = self._user_to_ndx[user]\\n if not isinstance(item, int):\\n item = self._item_to_ndx[item]\\n\\n try:\\n rating_mean = self._averages[user]\\n except AttributeError:\\n raise RuntimeError('Must fit before predicting')\\n\\n other_users = [other for other in self._users if other != user and\\n np.isfinite(self._votes[other][item])]\\n weights = np.array([self._weight(user, other)\\n for other in other_users])\\n deviations = np.array([self._votes[other][item] - self._averages[other]\\n for other in other_users])\\n\\n weight_sum = np.sum(np.absolute(weights))\\n if weight_sum < _EPSILON:\\n return rating_mean # No similar users, so guess their avg rating\\n\\n norm_const = 1 / weight_sum\\n\\n weighted_avg = np.sum(weights * deviations)\\n return rating_mean + norm_const * weighted_avg\",\n \"def construct_classifier_for_user(user_indexed_reviews, restaurant_indexed_reviews):\\t\\n # compute all_reviews\\n all_reviews = []\\n for restaurant in restaurant_indexed_reviews:\\n reviews_content = ''\\n for user in restaurant_indexed_reviews[restaurant]:\\n reviews = restaurant_indexed_reviews[restaurant][user]\\n for review in reviews:\\n reviews_content += review['text'][0:len(review['text'])-1]\\n all_reviews.append(reviews_content)\\n\\n print 'extract feature...'\\n # construct classifier\\n X_total, y_total, restaurant_feature = extracttfidf_user(user_indexed_reviews, all_reviews, restaurant_indexed_reviews)\\n\\n print 'construct classifier...'\\n i = 0\\n for user in user_indexed_reviews:\\n print i\\n i += 1\\n classifier = MultinomialNB(alpha=.01)\\n X_train = X_total[user]\\n y_train = y_total[user]\\n if X_train != None:\\n try:\\n classifier.fit(X_train, y_train)\\n update_rating(user, restaurant_feature, classifier, user_indexed_reviews, restaurant_indexed_reviews)\\n except:\\n continue\",\n \"def model_frequency(ref, alt, bases_all_reads, f_vector, error_rates):\\n # model Mx: NO alt allele\\n if ref == alt:\\n return np.array([error_rates[ref][eb] for eb in \\\"ACGT-\\\"])\\n # model Mxy: two alleles\\n mat = np.zeros((K, 5))\\n for b, base in enumerate(\\\"ACGT-\\\"):\\n for i, observed_base in enumerate(bases_all_reads):\\n mat[i][b] = error_rates[base][observed_base]\\n\\n m2 = (mat * f_vector)[:, [bases_index[alt], bases_index[ref]]]\\n alt_ref_f_vector = (m2 / m2.sum(axis=1)[:, np.newaxis]).sum(axis=0) / K\\n\\n l = [alt_ref_f_vector[0], ]*5\\n l[bases_index[ref]] = alt_ref_f_vector[1]\\n updated_f_vector = np.array(l)\\n\\n return updated_f_vector\",\n \"def __init__(self, customer_vendor_full, valid_rating_mean):\\r\\n super(User_CF, self).__init__()\\r\\n self.customer_vendor_full = customer_vendor_full\\r\\n self.customer_vendor_ratings = self.select_features()\\r\\n self.customer_vendor_matrix = self.customer_vendor_ratings.pivot(\\r\\n index='customer_id', columns='vendor_id', values='mean_rating') # (26779, 100)\\r\\n self.rating_matrix = self.customer_vendor_matrix.fillna(0).values.astype(np.float32)\\r\\n self.valid_rating_mean = valid_rating_mean\\r\\n self.vendor2rating = self.get_vendors_mean()\\r\\n self.customer_similarity, = self.get_similarity()\",\n \"def __init__(self, dim=20, nIter=5, lamb=0.05, alph=40,\\n user_features=[\\\"user\\\"], item_features=[\\\"item\\\"]):\\n self.setParams(dim,nIter, lamb, alph)\\n self.user_features = {}\\n self.item_features = {}\\n self.factors = {}\\n\\n self.user_column_names = user_features\\n self.item_column_names = item_features\",\n \"def evaluate_model(test_user_item_matrix, user_mat, portfolio_mat):\\r\\n n = np.count_nonzero(~np.isnan(test_user_item_matrix))\\r\\n\\r\\n # keep track of the sum of squares\\r\\n sse = 0\\r\\n\\r\\n for user_id in test_user_item_matrix.index:\\r\\n for offer_id in test_user_item_matrix.columns.values:\\r\\n if ~np.isnan(test_user_item_matrix.loc[user_id, offer_id]):\\r\\n pred = predict(test_user_item_matrix, user_mat, portfolio_mat, user_id, offer_id)\\r\\n if pred:\\r\\n diff = test_user_item_matrix.loc[user_id, offer_id] - pred\\r\\n sse += diff ** 2\\r\\n return sse / n\",\n \"def make_predictions(movies, ratings_train, ratings_test):\\n ###TODO\\n \\n user_result = [] \\n \\n for index,row in ratings_test.iterrows():\\n userid_test = row['userId']\\n #print(\\\"userid_test::\\\",userid_test) \\n movieid_test = row['movieId'] \\n #print(\\\"movieid_test::\\\",movieid_test) \\n x = list(movies[movies.movieId==movieid_test]['features'])[0]\\n #print(\\\"CSR_GOTT+X::\\\",x)\\n #print(\\\"TYPE of CSR_GOTT_X::\\\",type(x))\\n subset_train = ratings_train[ratings_train.userId == userid_test]\\n #print(\\\"SUB MOVIE SET::\\\",subset_train)\\n #print(\\\"TYPE of SUB MOVIE SET::\\\",type(x))\\n total_if_zero=0\\n rating_if_zero=0\\n sum_main_result=0\\n sum_cosine=0 \\n for index1,row1 in subset_train.iterrows():\\n userid_train = row1['userId']\\n #print(\\\"userid_train::\\\",userid_train) \\n if(userid_test == userid_train ):\\n #print(\\\"HII IN IFFF:::\\\")\\n movieid_train = row1['movieId']\\n #print(\\\"movieid_train::\\\",movieid_train)\\n rating_train = row1['rating']\\n #print(\\\"rating_train::\\\",rating_train)\\n total_if_zero = total_if_zero + 1 \\n rating_if_zero = rating_if_zero + rating_train\\n y = list(movies[movies.movieId==movieid_train]['features'])[0]\\n #print(\\\"CSR_GOTT_Y::\\\",y)\\n #print(\\\"TYPE of CSR_GOTT_Y::\\\",type(y))\\n result_cos = cosine_sim(x,y)\\n sum_main_result += result_cos * rating_train\\n sum_cosine += result_cos \\n \\n if(sum_main_result != 0):\\n user_result.append(sum_main_result/sum_cosine)\\n #print(\\\"user_result::\\\",user_result) \\n else:\\n user_result.append(rating_if_zero / total_if_zero)\\n #print(\\\"user_result::\\\",user_result) \\n \\n return_result_arr = np.array(user_result) \\n \\n return return_result_arr\\n \\n pass\",\n \"def predict(self, user_id, item_id):\\n # DONEreturn prediction for given pair\\n return self._user_factors[user_id, : ].dot(self._item_factors[item_id, :])\",\n \"def get_user_vector(self, user_id):\\r\\n if user_id in self.df_ratmat.index:\\r\\n # user from base dataset\\r\\n return np.array([self.df_ratmat.loc[user_id]])\\r\\n # construct a vector out of app user rating data\\r\\n movies_rated = self.get_valid_user_ratings(user_id)\\r\\n movie_size = self.df_ratmat.shape[1]\\r\\n cols = [str(i) for i in range(1, movie_size + 1)]\\r\\n df = pd.DataFrame(columns=cols)\\r\\n new_row = {}\\r\\n for i, r in movies_rated[['item_id', 'rating']].iterrows():\\r\\n new_row[str(int(r['item_id']))] = int(r['rating'])\\r\\n df = df.append(new_row, ignore_index=True)\\r\\n # mark 0 (=not rated) if not rated by the user\\r\\n return df.fillna(0)\",\n \"def _factorsX(self, inputs):\\n return tensor.dot(inputs[0], self.wxf)\",\n \"def print_maxes(mat):\\r\\n u_to_likes = load_or_create(\\\"/Matrix/UserIdToLikes.matrix\\\", create_matrix_user_likes)\\r\\n dict_names = load_or_create('/DICT/MovieIdToName.dict', create_dict_names)\\r\\n dict_ecc = load_or_create('/DICT/MovieIdToItemEccentricity.dict', create_dict_ecc)\\r\\n user_to_ecc = load_or_create('/DICT/UserIdToUserEccentricity.dict',createDictUserIdToUserEccentricity)\\r\\n dict_userid_to_moviesliked = load_or_create('/DICT/UserIdToLikedMovies.dict', create_dict_user_id_to_liked_items)\\r\\n\\r\\n dict_userid_to_recommends = dict()\\r\\n print(\\\"STARTING ECC CALC\\\")\\r\\n recommends = []\\r\\n for i in range(int(mat.shape[0]*0.5)):\\r\\n row = mat.getrow(i)\\r\\n if len(row.nonzero()[0]) != 0:\\r\\n # print(u_to_likes.getrow(i).nonzero()[1])\\r\\n if len(u_to_likes.getrow(i).nonzero()[1])<10 and user_to_ecc[i+1]>0:\\r\\n # print(\\\"Amount of recommends:\\\",len(row.nonzero()[0]))\\r\\n row = row.toarray()[0].tolist()\\r\\n max_val = max(val for val in row if str(row.index(val) + 1) not in dict_userid_to_moviesliked[i+1])\\r\\n print('SUM is:',sum(val for val in row if str(row.index(val) + 1) not in dict_userid_to_moviesliked[i+1]))\\r\\n print('SUM with all is:',sum(val for val in row))\\r\\n\\r\\n index_max=row.index(max_val) + 1\\r\\n\\r\\n recommends.append(\\r\\n [max_val, row.index(max_val) + 1, i + 1, [i + 1 for i in u_to_likes.getrow(i).nonzero()[1]],\\r\\n [row.index(max_val) + 1],user_to_ecc[i+1]])\\r\\n\\r\\n recommends = sorted(recommends, key=itemgetter(0))\\r\\n\\r\\n for i in recommends[-100:]:\\r\\n print(\\\"MAX id:\\\", i[1])\\r\\n print(\\\"MAX val:\\\", i[0])\\r\\n print(\\\"Users ECC:\\\",i[5])\\r\\n print(\\\"for user:\\\", i[2])\\r\\n print(\\\"MOVIES HE ALREADY LIKED\\\", 50 * \\\"=\\\")\\r\\n item_names_print(i[3], dict_names, dict_ecc)\\r\\n print(\\\"Movie Well recommend:\\\" + 50 * '*')\\r\\n item_names_print(i[4], dict_names, dict_ecc)\\r\\n print(50 * \\\"#\\\")\",\n \"def test_matrix(self, tol):\\n\\n res_static = qml.QFT.compute_matrix(2)\\n res_dynamic = qml.QFT(wires=[0, 1]).matrix()\\n res_reordered = qml.QFT(wires=[0, 1]).matrix([1, 0])\\n\\n expected = np.array(\\n [\\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\\n [0.5 + 0.0j, 0.0 + 0.5j, -0.5 + 0.0j, -0.0 - 0.5j],\\n [0.5 + 0.0j, -0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j],\\n [0.5 + 0.0j, -0.0 - 0.5j, -0.5 + 0.0j, 0.0 + 0.5j],\\n ]\\n )\\n\\n assert np.allclose(res_static, expected, atol=tol, rtol=0)\\n assert np.allclose(res_dynamic, expected, atol=tol, rtol=0)\\n\\n expected_permuted = [\\n [0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j, 0.5 + 0.0j],\\n [0.5 + 0.0j, 0.5 - 0.0j, -0.5 + 0.0j, -0.5 + 0.0j],\\n [0.5 + 0.0j, -0.5 + 0.0j, 0.0 + 0.5j, -0.0 - 0.5j],\\n [0.5 + 0.0j, -0.5 + 0.0j, -0.0 - 0.5j, 0.0 + 0.5j],\\n ]\\n assert np.allclose(res_reordered, expected_permuted, atol=tol, rtol=0)\",\n \"def calculate_total(self, calcu_user_n=20, user_n=20, item_n=10, seed=1):\\n self._split_data(seed=seed)\\n self._set_top(user_n=user_n, item_n=item_n)\\n test_user_list = list(set(self.test['userId'].unique()))\\n user_list = [test_user_list[random.randint(0, len(test_user_list)) - 1]\\n for i in range(calcu_user_n)]\\n hit = 0 # Hit score\\n all_recom = 0 # num of all recommendations, calculate the accuracy rate\\n like_item = 0 # num of the item the user likes in the test set, calculate the recall rate\\n all_recom_set = set()\\n all_item = set(self.train['movieId'].unique())\\n item_popular = Counter(self.train['movieId'].values)\\n ret = 0\\n n = 0\\n print('\\\\nCalculate all evaluation indicators...')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user, )\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n like_item += len(user_item)\\n all_recom += len(recom_item)\\n all_recom_set.update(recom_item)\\n for rec in set([data[0] for data in recom_data]):\\n ret += math.log(1 + item_popular.get(rec))\\n n += 1\\n print('\\\\nCalculate over')\\n print('Precision is: ', hit / (all_recom * 1.0))\\n print('Recall is: ', hit / (like_item * 1.0))\\n print('Coverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\\n print('Popularity is:', (ret / n * 1.0))\",\n \"def prediction(prediction_file_name, clusters_list, svd_use_flag):\\n \\n coords = misc_functions.getWindowCoords()\\n \\n test_users = range(coords[0], coords[2] + 1) \\n test_items = range(coords[1], coords[3] + 1)\\n \\n #print \\\"len(test_users) = \\\", len(test_users)\\n #print \\\"len(test_items) = \\\", len(test_items)\\n #print \\\"test_items = \\\", test_items\\n \\n # this matrix to be written as result finally\\n #misc_functions.step()\\n prediction_matrix = zeros((len(test_users), len(test_items)), dtype = float)\\n \\n training_matrix = scipy.io.mmio.mmread(\\\"history.mtx\\\").tocsr()\\n \\n item_X_meta_matrix = scipy.io.mmio.mmread(\\\"../../../well_done/items-metas_global.mtx\\\").toarray()\\n \\n # getting meta matrices for corresponding using metas\\n meta_ctr = 0\\n meta_matrices = []\\n for meta in METAS_TO_USE:\\n if svd_use_flag:\\n meta_matrice_file_name = \\\"users-\\\" + METAS_TO_USE[meta] + \\\".svd.mtx\\\"\\n else:\\n meta_matrice_file_name = \\\"users-\\\" + METAS_TO_USE[meta] + \\\".mtx\\\"\\n exec(\\\"meta_matrices.append(scipy.io.mmio.mmread(\\\\\\\"\\\" + meta_matrice_file_name + \\\"\\\\\\\").toarray())\\\")\\n\\n #user_counter = 0\\n #for user in test_users:\\n for cur_cluster in clusters_list:\\n \\n #print \\\"cur_cluster[0] = \\\", cur_cluster[0]\\n user = int (cur_cluster[0].split(\\\"\\\\t\\\")[1])\\n #print \\\"user #\\\", user\\n \\n #user_metas = {} - changed to list because of problem with dimension\\n user_metas = []\\n \\n values = zeros((len(METAS_TO_USE), len(test_items)), dtype = float)\\n meta_ctr = 0\\n for meta in METAS_TO_USE:\\n \\n #print \\\" meta_matrices = \\\", meta_matrices\\n #print \\\" meta_matrices[meta_ctr] = \\\", meta_matrices[meta_ctr]\\n user_vector = meta_matrices[meta_ctr][user]\\n #print \\\" user_vector = \\\", user_vector\\n #print \\\" len(user_metas) = \\\", len(user_metas)\\n #print \\\" meta_ctr = \\\", meta_ctr\\n #print \\\"meta = \\\", meta\\n #misc_functions.step()\\n \\n # normalizing counts of visited metas to use them as weights later\\n if max(user_vector) != 0:\\n user_metas.append(1.0 * user_vector / max(user_vector))\\n else:\\n user_metas.append(zeros((len(user_vector), ), dtype = float))\\n #print \\\" user_metas[meta_ctr] = \\\", user_metas[meta_ctr]\\n #print \\\" user_metas[meta_ctr].shape = \\\", user_metas[meta_ctr].shape\\n \\n #for item in test_items:\\n for cluster in cur_cluster[1 : ]:\\n start_cluster_item = int(cluster.split(\\\"\\\\t\\\")[0])\\n stop_cluster_item = int(cluster.split(\\\"\\\\t\\\")[2])\\n \\n cluster_items = range(start_cluster_item, stop_cluster_item + 1)\\n \\n for item in cluster_items:\\n meta_value = item_X_meta_matrix[item, meta]\\n \\n # PRICE\\n if meta == 8:\\n meta_value = priceToPriceCat(meta_value)\\n \\n # CITY HEURISTIC\\n if meta == 11:\\n if user_metas[meta_ctr][meta_value - 1] < CITY_TRESHOLD:\\n values[:, item - coords[1]] *= CITY_COEF\\n \\\"\\\"\\\"\\n # DAYTIME\\n if meta == 17:\\n meta_value = dayTime(meta_value)\\n \\\"\\\"\\\"\\n \\n #print \\\" meta_value = \\\", meta_value\\n #print \\\" item = \\\", item\\n #step()\\n values[meta_ctr][item - coords[1]] = (user_metas[meta_ctr])[meta_value - 1]\\n \\n \\\"\\\"\\\"HEURISTICS \\\"\\\"\\\"\\n \\n \\n \\n \\n \\n \\\"\\\"\\\"\\\\\\\\ HEURISTICS \\\"\\\"\\\"\\n\\n meta_ctr += 1\\n #print \\\"values[:, 0:10] = \\\", values[:, 0:10]\\n prediction_vector = numpy.sum(META_WEIGHTS * values, axis = 0)\\n #print \\\"prediction_vector[0:10] = \\\", prediction_vector[0:10]\\n #print \\\"sum(prediction_vector) = \\\", sum(prediction_vector)\\n prediction_matrix[user - coords[0]] = prediction_vector\\n \\n #step()\\n \\n# ===== END OF MAIN CYCLE ===== \\n\\n result_matrix = scipy.sparse.csr_matrix(prediction_matrix)\\n scipy.io.mmio.mmwrite(prediction_file_name, result_matrix, field = 'real', precision = 5)\",\n \"def test_init_ratings():\\n env = FixedRating(num_users=50,\\n num_items=50,\\n rating_frequency=1.0,\\n num_init_ratings=100)\\n env.seed(0)\\n _, _, ratings = env.reset()\\n assert len(ratings) == 100\\n for (user_id, item_id), (rating, context) in ratings.items():\\n assert context.shape == (0,)\\n assert user_id < 50\\n assert item_id < 50\\n if rating == 5.0:\\n assert item_id >= 25\\n else:\\n assert item_id < 25\",\n \"def proba_fm(m_pred,f_pred, dataset):\\n p = np.zeros(10)\\n if dataset == 'cifar10':\\n for i in range(10):\\n if i <4:\\n if i <2:\\n p[i] = (m_pred[0])*(f_pred[i]/np.sum(f_pred[0:2]))\\n else:\\n p[i] = (m_pred[1])*(f_pred[i]/np.sum(f_pred[2:4]))\\n else:\\n if i <6:\\n p[i] = (m_pred[2])*(f_pred[i]/np.sum(f_pred[4:6]))\\n elif i <8:\\n p[i] = (m_pred[3])*(f_pred[i]/np.sum(f_pred[6:8]))\\n else:\\n p[i] = (m_pred[4])*(f_pred[i]/np.sum(f_pred[8:]))\\n else :\\n for i in range(10):\\n if i <5:\\n if i <3:\\n p[i] = (m_pred[0])*(f_pred[i]/np.sum(f_pred[0:3]))\\n else:\\n p[i] = (m_pred[1])*(f_pred[i]/np.sum(f_pred[3:5]))\\n else:\\n if i <8:\\n p[i] = (m_pred[2])*(f_pred[i]/np.sum(f_pred[5:8]))\\n else:\\n p[i] = (m_pred[3])*(f_pred[i]/np.sum(f_pred[8:]))\\n return(p)\",\n \"def _create_sparse_train_and_test(ratings, n_users, n_items):\\n \\n # pick a random set of data as testing data, sorted ascending\\n test_set_size = len(ratings) / TEST_SET_RATIO\\n test_set_idx = np.random.choice(xrange(len(ratings)), size=test_set_size, replace=False)\\n test_set_idx = sorted(test_set_idx)\\n \\n # use the remaining data to create a training set\\n ts_ratings = ratings[test_set_idx]\\n tr_ratings = np.delete(ratings, test_set_idx, axis=0)\\n \\n # create training and test matrices as coo_matrix\\n u_tr, i_tr, r_tr = zip(*tr_ratings)\\n tr_sparse = coo_matrix((r_tr, (u_tr, i_tr)), shape=(n_users, n_items))\\n u_ts, i_ts, r_ts = zip(*ts_ratings)\\n test_sparse = coo_matrix((r_ts, (u_ts, i_ts)), shape=(n_users, n_items))\\n \\n return tr_sparse, test_sparse\",\n \"def prediction(uid, pair, rating_bd, sim_bd, item_bd):\\n iid, real_rating = pair[0], pair[1]\\n if iid not in sim_bd.value.keys():\\n return ()\\n iid_neighbors = [\\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\\n average_iid_rating = item_bd.value[iid][0]\\n sim_rating = []\\n for info in iid_neighbors:\\n niid, nsim, ratings = info\\n sim_rating += [\\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\\n for rating in ratings if uid in rating[0]]\\n if len(sim_rating) != 0:\\n sim_ratings = [\\n (line[1] * line[2], abs(line[1]), line[3])\\n for line in sim_rating]\\n predicted_rating_no_decay = average_iid_rating + sum(\\n map(lambda line: line[0], sim_ratings)) / sum(\\n map(lambda line: line[1], sim_ratings))\\n predicted_rating_decay = \\\\\\n average_iid_rating + add_decay(sim_ratings)\\n else:\\n predicted_rating_no_decay = average_iid_rating\\n predicted_rating_decay = average_iid_rating\\n return iid, real_rating, \\\\\\n self.bound_rating(predicted_rating_no_decay), \\\\\\n self.bound_rating(predicted_rating_decay)\",\n \"def select_next(X, U, mu,\\n scoremethod='lowhigh',\\n missingmethod='none',\\n feature_weights=[],\\n oldscores=[], oldreproj=[]):\\n\\n print(\\\"------------ SELECTING --------------\\\")\\n if len(U) == 0:\\n printt(\\\"Empty DEMUD model: selecting item number %d from data set\\\" % \\\\\\n (opts['iitem']))\\n return opts['iitem'], [], []\\n\\n if X.shape[1] < 1 or len(U) == 0 or len(mu) == 0:\\n printt(\\\"Error: No data in X and/or U and/or mu.\\\")\\n return None, [], []\\n\\n if X.shape[0] != U.shape[0] or X.shape[0] != mu.shape[0]:\\n printt(\\\"Mismatch in dimensions; must have X mxn, U mxk, mu mx1.\\\")\\n return None, [], []\\n\\n # If oldscores is empty, compute the score for each item\\n if len(oldscores) == 0:\\n (scores, reproj) = score_items(X, U, mu, scoremethod, missingmethod)\\n elif len(oldreproj) == 0:\\n printt(\\\"Error: oldscores provided, but not oldreproj.\\\")\\n return None, [], []\\n else: # both are valid, so use them here\\n (scores, reproj) = (oldscores, oldreproj)\\n\\n # Select and return index of item with max reconstruction error,\\n # plus the updated scores and reproj\\n m = scores.argmax()\\n #print('mu:',mu)\\n #print('selected:', X[:,m])\\n #print('selected-mu:', (X-mu)[:,m])\\n #print('reproj:', reproj[:,m])\\n #print('reproj-mu:', (reproj-mu)[:,m])\\n #input()\\n\\n return m, scores, reproj\",\n \"def test_conversion():\\r\\n f1 = factor([0,1],[2,2],scipy.rand(4))\\r\\n f2 = factor([1,2],[2,2],scipy.rand(4))\\r\\n f3 = factor([3],[2],scipy.rand(2))\\r\\n\\r\\n F = FactorList([f1,f2,f3])\\r\\n theta = factors2ExpFam(F)\\r\\n F2 = expfam2Factors(theta)\\r\\n ratio = F2.JointDistn().val/ (F.JointDistn().val)\\r\\n ratio = ratio/ratio[0]\\r\\n print scipy.allclose(ratio,1)\",\n \"def get5x5matrix(self): #modified from nxvasc get3x3matrix()\\n try:\\n i = na.identity(3)\\n \\n self.d124 = i.copy()\\n self.ds124 = na.zeros(124,na.float64)\\n \\n for k in range(1,124):\\n self.d124 = na.concatenate((self.d124,i))\\n# print len(self.d124)\\n count = 0\\n a = []\\n for k in range(-2,3):\\n for j in range(-2,3):\\n for i in range(-2,3):\\n if( i != 0 or j != 0 or k != 0 ):\\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\\n count += 1\\n a.append(i)\\n a.append(j)\\n a.append(k)\\n# print len(a)\\n a = na.reshape(na.array(a),(372,1))\\n# print len(self.d124)\\n self.d124 = na.concatenate((self.d124,a),axis=1)\\n except Exception as error:\\n print(\\\"failed in get5x5matrix(): \\\", error)\",\n \"def fit(self, user_x_product, latent_features_guess=2, learning_rate=0.0002, steps=5000, regularization_penalty=0.02, convergeance_threshold=0.001):\\n print 'training model...'\\n return self.__factor_matrix(user_x_product, latent_features_guess, learning_rate, steps, regularization_penalty, convergeance_threshold)\",\n \"def update_factors(self,u,i,j,update_u=True,update_i=True):\\n #print(\\\"session run\\\")\\n loss_v = self.sess.run(self.train_step , feed_dict={\\n self.u: u,\\n self.i: i,\\n self.j: j})\\n\\n returnText = \\\"\\\"\\n\\n if self.alg_type == \\\"TFL\\\" or self.alg_type == \\\"TFLWM\\\":\\n sum_lambda = 0\\n for k in self.sim_matrix_names:\\n sum_lambda += abs(self.sim_lambda[k].eval())\\n #print(sum_lambda,self.sim_lambda)\\n for k in self.sim_matrix_names:\\n if math.isnan(sum_lambda):\\n print(\\\"sim_lambda overflow\\\")\\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\\n returnText = \\\"sim_lambda overflow\\\"\\n else:\\n tf.assign(self.sim_lambda[k], self.sim_lambda[k].eval()/sum_lambda).eval()\\n else:\\n for k in self.sim_matrix_names:\\n val = self.sim_lambda[k].eval()\\n if math.isnan(val[0]):\\n print(\\\"sim_lambda overflow\\\")\\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\\n returnText = \\\"sim_lambda overflow\\\"\\n if val[0] <= 0.0:\\n tf.assign(self.sim_lambda[k], [self.delta], validate_shape=False).eval()\\n elif val[0] >= 1.0:\\n tf.assign(self.sim_lambda[k], [self.one - self.delta], validate_shape=False).eval()\\n\\n return returnText\",\n \"def calc_adv_U(self):\\n num_U = 0\\n adv_U = numpy.zeros((3,3), float)\\n\\n for atm in self:\\n ## use the atom's U matrix if it exists, otherwise use the\\n ## temperature factor\\n\\n if atm.U is not None:\\n adv_U += atm.U\\n num_U += 1\\n\\n return adv_U / num_U\",\n \"def calculate_user_similarity_profile(self, ratings_vector):\\r\\n num_users, num_movies = self.ratings_matrix.get_shape()\\r\\n\\r\\n user_similarities = sp.dok_matrix((1, num_users))\\r\\n for i in range(num_users):\\r\\n\\r\\n user_similarities[0, i] = self.calculate_pairwise_user_similarity(self.ratings_matrix.getrow(i), ratings_vector)\\r\\n\\r\\n return user_similarities.tocsr()\",\n \"def calc_metrics(metric_scores_list):\\n\\n N_split, N_miss, N_add, Q_P, Q_R, Q_F, N_gt, N_pred = [], [], [], [], [], [], [], []\\n Q_rand, Q_jaccard, Q_aggregated_jaccard, Q_ctc, Q_piou = [], [], [], [], []\\n tp, fp, fn = [], [], []\\n\\n for score in metric_scores_list:\\n N_split.append(score['N_split']), N_miss.append(score['N_miss']), N_add.append(score['N_add'])\\n Q_P.append(score['Q_P']), Q_R.append(score['Q_R']), Q_F.append(score['Q_F'])\\n Q_rand.append(score['Q_rand']), Q_jaccard.append(score['Q_jaccard'])\\n Q_aggregated_jaccard.append(score['Q_aggregated_jaccard'])\\n if \\\"Q_ctc\\\" in score:\\n Q_ctc.append(score['Q_ctc']), \\n Q_piou.append(score['Q_piou'])\\n N_gt.append(score['N_gt']), N_pred.append(score['N_pred'])\\n tp.append(score['tp']), fp.append(score['fp']), fn.append(score['fn'])\\n\\n N_split, N_miss, N_add = np.array(N_split), np.array(N_miss), np.array(N_add)\\n N_gt, N_pred = np.array(N_gt), np.array(N_pred)\\n tp, fp, fn = np.array(tp), np.array(fp), np.array(fn)\\n Q_P_macro, Q_R_macro, Q_F_macro = np.mean(np.array(Q_P)), np.mean(np.array(Q_R)), np.mean(np.array(Q_F))\\n Q_P_micro = np.sum(tp) / (np.sum(tp) + np.sum(fp)) if (np.sum(tp) + np.sum(fp)) > 0 else 0\\n Q_R_micro = np.sum(tp) / (np.sum(tp) + np.sum(fn)) if (np.sum(tp) + np.sum(fn)) > 0 else 0\\n Q_rand_macro, Q_jaccard_macro = np.mean(np.array(Q_rand)), np.mean(np.array(Q_jaccard))\\n Q_aggregated_jaccard_macro = np.mean(np.array(Q_aggregated_jaccard))\\n Q_ctc_macro, Q_piou_macro = np.mean(np.array(Q_ctc)), np.mean(np.array(Q_piou))\\n\\n metrics = {\\n 'Q_split_micro': float(np.sum(N_split) / np.sum(N_gt)),\\n 'Q_split_macro': float(np.mean(N_split / N_gt)),\\n 'Q_miss_micro': float(np.sum(N_miss) / np.sum(N_gt)),\\n 'Q_miss_macro': float(np.mean(N_miss / N_gt)),\\n 'Q_add_micro': float(np.sum(N_add) / np.sum(N_gt)),\\n 'Q_add_macro': float(np.mean(N_add / N_gt)),\\n 'N_gt': int(np.sum(N_gt)),\\n 'N_pred': int(np.sum(N_pred)),\\n 'Q_rand_macro': float(Q_rand_macro),\\n 'Q_jaccard_macro': float(Q_jaccard_macro),\\n 'Q_aggregated_jaccard_macro': float(Q_aggregated_jaccard_macro),\\n 'Q_ctc_macro': float(Q_ctc_macro),\\n 'Q_piou_macro': float(Q_piou_macro),\\n 'Q_P_micro': float(Q_P_micro),\\n 'Q_P_macro': float(Q_P_macro),\\n 'Q_R_micro': float(Q_R_micro),\\n 'Q_R_macro': float(Q_R_macro),\\n 'Q_F_macro': float(Q_F_macro),\\n 'Q_F_micro': float(2 * Q_P_micro * Q_R_micro / (Q_P_micro + Q_R_micro)) if (Q_P_micro + Q_R_micro) > 0 else 0\\n }\\n return metrics\",\n \"def multiply_fisher_factor(self, vector: jnp.ndarray) -> jnp.ndarray:\\n return utils.scalar_mul(\\n self.multiply_fisher_factor_unweighted(vector), jnp.sqrt(self.weight))\",\n \"def predict(self, u, i, P=None, Q=None, F=None, w=None, user_bias=None, item_bias=None):\\n if P is None:\\n P = self.P\\n if Q is None:\\n Q = self.Q\\n if F is None:\\n F = self.F\\n if w is None:\\n w = self.w\\n if user_bias is None:\\n user_bias = self.user_bias\\n if item_bias is None:\\n item_bias = self.item_bias\\n\\n known_user = self._known('user', u)\\n known_item = self._known('item', i)\\n rui_hat = self.mean\\n if known_user:\\n rui_hat += user_bias[u]\\n if known_item:\\n rui_hat += item_bias[i]\\n if known_user and known_item:\\n F_sum = np.sum(F[self.Fr[u], :], axis=0)\\n #F_num = np.sqrt(self.Fr[u].shape[0]) # Try without sqrt\\n F_num = self.Fr[u].shape[0]\\n if F_num > 0:\\n F_sum /= F_num\\n rui_hat += (F_sum + w * P[u, :]).dot(Q[:, i])\\n # Apply potential non-linearity (activation) g\\n rui_hat = self.g(rui_hat)\\n return rui_hat\",\n \"def build_user_user_similarity_matrix(self, event_data):\\n self.compute_user_user_sim_base_on_common_items()\\n self.standardize_sim_values()\",\n \"def test_lu_factor():\\n\\t#[A, b] = lu_read('test1.txt')\\n\\t# it is poor form to read an external file into a test function, as above\\n\\tA = np.array([\\n\\t\\t[ 2., 3., -4., 2.],\\n\\t\\t[-4., -5., 6., -3.],\\n\\t\\t[ 2., 2., 1., 0.],\\n\\t\\t[-6., -7., 14., -4.]])\\t\\n\\tLU,p = lu_factor(A, pivot=False)\\n\\tLU_soln = np.array([\\n\\t\\t[ 2, 3,-4, 2],\\n\\t\\t[-2, 1,-2, 1],\\n\\t\\t[ 1,-1, 3,-1],\\n\\t\\t[-3, 2, 2, 2]])\\t\\n\\tassert norm(LU - LU_soln) < 1.e-10\\t\\n\\n\\n\\t# test 2\\n\\t[A2, b2] = lu_read('test2.txt')\\t\\t\\t\\t\\t\\t# read a matrix and RHS vector\\n\\tLU2,p2 = lu_factor(A2) \\t\\t\\t\\t\\t\\t\\t\\t# change display to False when LU_FACTOR working\\n\\tLU_soln2 = np.array([\\n\\t\\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\\n\\t\\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\\n\\t\\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\\n\\t\\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\\n\\t\\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\\n\\t\\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\\n\\t\\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\\n\\tassert norm(LU2 - LU_soln2) < 1.e-10\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6282623","0.62621325","0.60587424","0.6045789","0.6040702","0.6002245","0.5951851","0.59179777","0.59059614","0.58943605","0.589419","0.587945","0.5858747","0.58264637","0.5798391","0.57919794","0.574544","0.5737683","0.5693354","0.5668427","0.56560904","0.565145","0.5631024","0.5595122","0.55878645","0.5560108","0.55080867","0.5492173","0.5471623","0.54714626","0.5467762","0.54663336","0.5445127","0.5433413","0.5393641","0.53686476","0.53676146","0.53589565","0.53349036","0.53346205","0.53162575","0.52985704","0.52616876","0.5258938","0.5252249","0.52483475","0.52311176","0.52225137","0.5220475","0.52171636","0.5198918","0.51938695","0.5181593","0.51795137","0.517728","0.51635116","0.5155167","0.5149963","0.51439816","0.51246136","0.5115969","0.5105796","0.5086189","0.50842553","0.5078923","0.5075725","0.5066789","0.5055791","0.505126","0.5040315","0.50370866","0.5033983","0.5028434","0.5021411","0.5020064","0.5016048","0.4992419","0.49900427","0.49797973","0.49795952","0.49742973","0.49736246","0.49720296","0.49668035","0.49609035","0.49598455","0.49560553","0.49484748","0.4937664","0.49338803","0.4931834","0.4930841","0.49298579","0.49219868","0.4919247","0.49165457","0.49121004","0.49035972","0.49034655","0.49016014"],"string":"[\n \"0.6282623\",\n \"0.62621325\",\n \"0.60587424\",\n \"0.6045789\",\n \"0.6040702\",\n \"0.6002245\",\n \"0.5951851\",\n \"0.59179777\",\n \"0.59059614\",\n \"0.58943605\",\n \"0.589419\",\n \"0.587945\",\n \"0.5858747\",\n \"0.58264637\",\n \"0.5798391\",\n \"0.57919794\",\n \"0.574544\",\n \"0.5737683\",\n \"0.5693354\",\n \"0.5668427\",\n \"0.56560904\",\n \"0.565145\",\n \"0.5631024\",\n \"0.5595122\",\n \"0.55878645\",\n \"0.5560108\",\n \"0.55080867\",\n \"0.5492173\",\n \"0.5471623\",\n \"0.54714626\",\n \"0.5467762\",\n \"0.54663336\",\n \"0.5445127\",\n \"0.5433413\",\n \"0.5393641\",\n \"0.53686476\",\n \"0.53676146\",\n \"0.53589565\",\n \"0.53349036\",\n \"0.53346205\",\n \"0.53162575\",\n \"0.52985704\",\n \"0.52616876\",\n \"0.5258938\",\n \"0.5252249\",\n \"0.52483475\",\n \"0.52311176\",\n \"0.52225137\",\n \"0.5220475\",\n \"0.52171636\",\n \"0.5198918\",\n \"0.51938695\",\n \"0.5181593\",\n \"0.51795137\",\n \"0.517728\",\n \"0.51635116\",\n \"0.5155167\",\n \"0.5149963\",\n \"0.51439816\",\n \"0.51246136\",\n \"0.5115969\",\n \"0.5105796\",\n \"0.5086189\",\n \"0.50842553\",\n \"0.5078923\",\n \"0.5075725\",\n \"0.5066789\",\n \"0.5055791\",\n \"0.505126\",\n \"0.5040315\",\n \"0.50370866\",\n \"0.5033983\",\n \"0.5028434\",\n \"0.5021411\",\n \"0.5020064\",\n \"0.5016048\",\n \"0.4992419\",\n \"0.49900427\",\n \"0.49797973\",\n \"0.49795952\",\n \"0.49742973\",\n \"0.49736246\",\n \"0.49720296\",\n \"0.49668035\",\n \"0.49609035\",\n \"0.49598455\",\n \"0.49560553\",\n \"0.49484748\",\n \"0.4937664\",\n \"0.49338803\",\n \"0.4931834\",\n \"0.4930841\",\n \"0.49298579\",\n \"0.49219868\",\n \"0.4919247\",\n \"0.49165457\",\n \"0.49121004\",\n \"0.49035972\",\n \"0.49034655\",\n \"0.49016014\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72323316"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":4994,"cells":{"query":{"kind":"string","value":"calculate the confidence of each useritem pair"},"document":{"kind":"string","value":"def cal_confidence(dat):\n\n\talpha = 40.0\n\tconfidence = np.zeros(dat.shape)\n\tconfidence = 1 + alpha * dat\n\treturn np.matrix(confidence)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _predict_user_item(self, user, item):\n if not isinstance(user, int):\n user = self._user_to_ndx[user]\n if not isinstance(item, int):\n item = self._item_to_ndx[item]\n\n try:\n rating_mean = self._averages[user]\n except AttributeError:\n raise RuntimeError('Must fit before predicting')\n\n other_users = [other for other in self._users if other != user and\n np.isfinite(self._votes[other][item])]\n weights = np.array([self._weight(user, other)\n for other in other_users])\n deviations = np.array([self._votes[other][item] - self._averages[other]\n for other in other_users])\n\n weight_sum = np.sum(np.absolute(weights))\n if weight_sum < _EPSILON:\n return rating_mean # No similar users, so guess their avg rating\n\n norm_const = 1 / weight_sum\n\n weighted_avg = np.sum(weights * deviations)\n return rating_mean + norm_const * weighted_avg","def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\n active_user = actives[0][0]\n active_item = actives[0][1]\n\n # -----------------------------------\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\n\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\n return (active_user, active_item), 2.5\n\n # all user, ratings that have rated active_item\n if active_item in train_rdd_gbitem_dict:\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\n else:\n # item not found in training set\n # new item problem.\n average_of_user_list = train_rdd_gbuser_dict[active_user]\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\n return (active_user, active_item), average_of_user\n\n # user rated items - all (item, ratings) that the user has rated\n if active_user in train_rdd_gbuser_dict:\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\n else:\n # user not found in training set\n # new user problem.\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\n\n similarity_list = []\n for item, rating in active_user_rated_items:\n item_dict = dict(train_rdd_gbitem_dict[item][0])\n item_avg = train_rdd_gbitem_dict[item][1]\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\n similarity_list.append((rating, similarity))\n\n # Have obtained similarity list for active item and item from the above code.\n # Filter according to a top 'N' items and then take avg rating.\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\n # similarity_list = similarity_list[:len(similarity_list) // 4]\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\n # print(similarity_list)\n pred_rating = find_weighted_average(similarity_list, num_items)\n\n # for i in similarity_list:\n # print(i)\n # print(\"Pred-rating: \", pred_rating)\n\n return (active_user, active_item), pred_rating","def predict(self, user_id, item_id):\n # DONEreturn prediction for given pair\n return self._user_factors[user_id, : ].dot(self._item_factors[item_id, :])","def predict_rating(user_id,item_id):\n user_preference = latent_user_preferences[user_id]\n item_preference = latent_item_features[item_id]\n return user_preference.dot(item_preference)","def predict_rating(self, user_id, item_id):\n user_preference = self.latent_user_preferences[user_id]\n item_feature = self.latent_item_features[item_id]\n return user_preference.dot(item_feature)","def calc_score(self, user_id, item_id): \n p = np.dot(self.U[user_id], self.V[item_id])\n if self.trunc_score_rule==None:pass\n else: p=self.trunc_score_rule(p)\n \n return p","def compute_user_user_sim_base_on_common_items(self):\n self.sim_matrix = {}\n for item in self.items.values():\n # convert to list of tuples for indexing\n users = list(item.covered_users.items())\n item_popularity = len(users)\n # iter through all user pairs\n for i in range(len(users)-1):\n for j in range(i+1, len(users)):\n user_A_info, user_B_info = users[i], users[j]\n # remember to update pair wise!\n self.update_user_user_sim(user_A_info, user_B_info,\n item_popularity)\n self.update_user_user_sim(user_B_info, user_A_info,\n item_popularity)","def getConfidence(self,LeftTup,RightTup):\n\n tup=LeftTup+RightTup\n _intersection=self.getSupport(tup)\n _LHS=self.getSupport(LeftTup)\n _confidence=_intersection/_LHS\n return (_confidence)","def precision(self, user_list):\n hit = 0\n all_recom = 0\n print('Calculate precision: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n all_recom += len(recom_item)\n print('\\nprecision is: ', hit / (all_recom * 1.0))\n return hit / (all_recom * 1.0)","def inner_product(user_profiles, item_attributes, normalize_users=True, normalize_items=False):\n if normalize_users:\n # this is purely an optimization that prevents numpy from having\n # to multiply huge numbers\n user_profiles = normalize_matrix(user_profiles, axis=1)\n if normalize_items:\n item_attributes = normalize_matrix(item_attributes.T, axis=1).T\n assert user_profiles.shape[1] == item_attributes.shape[0]\n scores = np.dot(user_profiles, item_attributes)\n return scores","def prediction(uid, pair, rating_bd, sim_bd, item_bd):\n iid, real_rating = pair[0], pair[1]\n if iid not in sim_bd.value.keys():\n return ()\n iid_neighbors = [\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\n average_iid_rating = item_bd.value[iid][0]\n sim_rating = []\n for info in iid_neighbors:\n niid, nsim, ratings = info\n sim_rating += [\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\n for rating in ratings if uid in rating[0]]\n if len(sim_rating) != 0:\n sim_ratings = [\n (line[1] * line[2], abs(line[1]), line[3])\n for line in sim_rating]\n predicted_rating_no_decay = average_iid_rating + sum(\n map(lambda line: line[0], sim_ratings)) / sum(\n map(lambda line: line[1], sim_ratings))\n predicted_rating_decay = \\\n average_iid_rating + add_decay(sim_ratings)\n else:\n predicted_rating_no_decay = average_iid_rating\n predicted_rating_decay = average_iid_rating\n return iid, real_rating, \\\n self.bound_rating(predicted_rating_no_decay), \\\n self.bound_rating(predicted_rating_decay)","def predict(self, users, items):\n users_t = torch.tensor(users, dtype=torch.int64, device=self.device)\n items_t = torch.tensor(items, dtype=torch.int64, device=self.device)\n with torch.no_grad():\n scores = torch.mul(\n torch.cat(\n (self.user_encode(users_t)[0], self.user_emb(users_t)), dim=1\n ),\n torch.cat(\n (self.item_encode(items_t)[0], self.item_emb(items_t)), dim=1\n ),\n ).sum(dim=1)\n return scores","def estimate(self, u, i):\n\n if u not in self.user_means:\n return(np.mean([self.global_mean,\n self.item_means[i]]))\n\n if i not in self.item_means:\n return(np.mean([self.global_mean,\n self.user_means[u]]))\n\n return(np.mean([self.global_mean,\n self.user_means[u],\n self.item_means[i]]))","def confidence(self) -> float:\n return float(self.class_scores[self.class_num])","def cal_hit_gbratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\n score = 0.0\n # golden items hit in the top_K items\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\n\n #print(np.mean(score_ratio))\n #print(score_1)\n #score = score_1 + score_2\n return np.mean(score_ratio)","def _weight(self, user_a, user_i):\n a_votes = self._votes[user_a]\n i_votes = self._votes[user_i]\n\n a_mean = self._averages[user_a]\n i_mean = self._averages[user_i]\n\n item_ndx = np.logical_and(np.isfinite(a_votes),\n np.isfinite(i_votes))\n\n a_deviations = a_mean - a_votes[item_ndx]\n i_deviations = i_mean - i_votes[item_ndx]\n\n numerator = np.sum(a_deviations * i_deviations)\n denominator = (np.sum(np.power(a_deviations, 2)) *\n np.sum(np.power(i_deviations, 2)))\n\n if denominator < _EPSILON:\n return 0\n return numerator / np.sqrt(denominator)","def coverage(self, user_list):\n all_recom_set = set()\n all_item = set(self.train['movieId'].values)\n print('\\nCalculated coverage: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n all_recom_set.update(recom_item)\n print('\\nCoverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\n return len(all_recom_set) / (len(all_item) * 1.0)","def pred_for_user(self,u):\r\n ids=np.where(self.Y_data_n[:,0]==u)[0]\r\n items_rated_by_u=Y_data_n[ids,1].tolist()\r\n pred_ratings=[]\r\n for i in range(self.n_items):\r\n if i not in items_rated_by_u:\r\n pred_ratings.append(self.pred(u,i))\r\n return pred_ratings","def prediction(self, user, item):\n return self._prob_to_class(self(user, item))","def score(self, user_idx, item_idx=None):\n if item_idx is None:\n if self.train_set.is_unk_user(user_idx):\n raise ScoreException(\n \"Can't make score prediction for (user_id=%d)\" % user_idx\n )\n\n known_item_scores = self.V.dot(self.U[user_idx, :])\n return known_item_scores\n else:\n if self.train_set.is_unk_user(user_idx) or self.train_set.is_unk_item(\n item_idx\n ):\n raise ScoreException(\n \"Can't make score prediction for (user_id=%d, item_id=%d)\"\n % (user_idx, item_idx)\n )\n\n user_pred = self.V[item_idx, :].dot(self.U[user_idx, :])\n\n user_pred = sigmoid(user_pred)\n if self.train_set.min_rating == self.train_set.max_rating:\n user_pred = scale(user_pred, 0.0, self.train_set.max_rating, 0.0, 1.0)\n else:\n user_pred = scale(\n user_pred,\n self.train_set.min_rating,\n self.train_set.max_rating,\n 0.0,\n 1.0,\n )\n\n return user_pred","def calc_rmse(self, data):\n res= data.score- data[['userid','itemid']].apply(lambda row:self.calc_score(row[0], row[1]),axis=1)\n res=[el**2 for el in np.array(res)]\n return np.sqrt(np.sum(res)/data.shape[0])","def calc_confidence(itemsets, support_counts, N, separator=-1):\n X = ' & '.join(sorted(itemsets[ : separator]))\n X_and_Y = ' & '.join(sorted(itemsets))\n\n if X_and_Y in support_counts.keys():\n supp_X_to_Y = support_counts[X_and_Y] / N\n conf_X_to_Y = support_counts[X_and_Y] / support_counts[X] # supports[X] is present if supports[key] is\n return (supp_X_to_Y, conf_X_to_Y)\n\n return None","def cal_hit_ratio(self):\n full, top_k = self._subjects, self._top_k\n top_k = full[full['rank']<=top_k]\n score = 0.0\n # golden items hit in the top_K items\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\n score = score_1 - score_2\n return score/full['user'].nunique()","def estimate(self, u, j):\n if not (self.trainset.knows_user(u) and self.trainset.knows_item(j)):\n raise PredictionImpossible('User and/or item is unknown.')\n\n u_ratings = self.trainset.ur[u]\n\n if self.weighting == 'linear':\n weight = sum(self.freqs[i, j, self.to_index(r)] for i, r in u_ratings)\n score = sum(self.sums[i, j, self.to_index(r)] for i, r in u_ratings)\n return score / weight\n\n # self.weighting == 'log' or None\n weights = [self.freqs[i, j, self.to_index(r)] for i, r in u_ratings]\n reciprocals = [1 / w if w else 0 for w in weights]\n scores = [self.sums[i, j, self.to_index(r)] for i, r in u_ratings]\n scores = [s * w for s, w in zip(scores, reciprocals)]\n\n if self.weighting is None:\n return np.mean(scores)\n # self.weighting == 'log'\n logs = [np.log(w + 1) if w >= 1 else 0 for w in weights]\n return np.dot(scores, logs) / np.sum(logs)","def item_based_prediction(self, line, rating_bd, sim_bd, item_bd):\n def sort_by_time(pairs):\n \"\"\"For each user, sort its rating records based on its datetime.\n More specifically, if time_a > time_b,\n then: time_a <- x, time_b <- x + 1.\n \"\"\"\n pairs = sorted(pairs, key=lambda line: line[2], reverse=False)\n order = 0\n out = []\n for i in range(len(pairs)):\n if i != 0 and pairs[i][2] == pairs[i - 1][2]:\n out += [(pairs[i][0], pairs[i][1], order)]\n else:\n order += 1\n out += [(pairs[i][0], pairs[i][1], order)]\n return out\n\n def f_decay(cur, t_ui):\n return np.exp(- self.alpha * (cur - t_ui))\n\n def add_decay(pairs):\n \"\"\"add decay rate to the pairs.\n Args:\n pairs: sim * rating, sim, time\n \"\"\"\n new_pairs = sort_by_time(pairs)\n current_time = max(map(lambda line: line[2], new_pairs)) + 1\n final_pairs = [\n (pair[0] * f_decay(current_time, pair[2]),\n pair[1] * f_decay(current_time, pair[2]))\n for pair in new_pairs]\n return sum(map(lambda line: line[0], final_pairs)) / sum(\n map(lambda line: line[1], final_pairs))\n\n def prediction(uid, pair, rating_bd, sim_bd, item_bd):\n \"\"\"do the prediction. It can either add decay rate or not,\n which is decided by `method`.\n \"\"\"\n iid, real_rating = pair[0], pair[1]\n if iid not in sim_bd.value.keys():\n return ()\n iid_neighbors = [\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\n average_iid_rating = item_bd.value[iid][0]\n sim_rating = []\n for info in iid_neighbors:\n niid, nsim, ratings = info\n sim_rating += [\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\n for rating in ratings if uid in rating[0]]\n if len(sim_rating) != 0:\n sim_ratings = [\n (line[1] * line[2], abs(line[1]), line[3])\n for line in sim_rating]\n predicted_rating_no_decay = average_iid_rating + sum(\n map(lambda line: line[0], sim_ratings)) / sum(\n map(lambda line: line[1], sim_ratings))\n predicted_rating_decay = \\\n average_iid_rating + add_decay(sim_ratings)\n else:\n predicted_rating_no_decay = average_iid_rating\n predicted_rating_decay = average_iid_rating\n return iid, real_rating, \\\n self.bound_rating(predicted_rating_no_decay), \\\n self.bound_rating(predicted_rating_decay)\n\n uid, pairs = line\n return uid, [\n prediction(uid, pair, rating_bd, sim_bd, item_bd)\n for pair in pairs]","def prediction(pair, uid_allneighbor_info, user_bd, uid):\n iid, real_rating, time = pair\n average_uid_rating = user_bd.value[uid][0]\n sim_rating = []\n for info in uid_allneighbor_info:\n uid, sim, ratings = info\n sim_rating += [\n (rating[0], sim, rating[1] - average_uid_rating)\n for rating in ratings if iid in rating[0]]\n\n if len(sim_rating) != 0:\n sim_rating = [\n (line[0], line[1] * line[2], abs(line[1]))\n for line in sim_rating]\n predicted_rating = average_uid_rating + sum(\n map(lambda line: line[1], sim_rating)) / sum(\n map(lambda line: line[2], sim_rating))\n else:\n predicted_rating = average_uid_rating\n return iid, real_rating, self.bound_rating(predicted_rating)","def score(self, user_idx, item_idx=None):\n if self.variant == 'c2pf' or self.variant == 'tc2pf':\n if item_idx is None:\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n else:\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n elif self.variant == 'rc2pf':\n if item_idx is None:\n user_pred = self.Xi * self.Theta[user_idx, :].T\n else:\n user_pred = self.Xi[item_idx,] * self.Theta[user_idx, :].T\n else:\n if item_idx is None:\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n else:\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n # transform user_pred to a flatten array,\n user_pred = np.array(user_pred, dtype='float64').flatten()\n\n return user_pred","def classify(user, itemName, itemVector):\n # first find nearest neighbor\n nearest = computeNearestNeighbor(itemName, itemVector, items)[0][1]\n rating = users[user][nearest]\n return rating","def getSupport(item):\n return float(freqSet[item]) / len(transactionList)","def prediction_item(item_id):\r\n # Data preprosessing\r\n reader = Reader(rating_scale=(0, 5))\r\n load_df = Dataset.load_from_df(ratings_df, reader)\r\n a_train = load_df.build_full_trainset()\r\n\r\n predictions = []\r\n for ui in a_train.all_users():\r\n predictions.append(model.predict(iid=item_id, uid=ui, verbose=False))\r\n return predictions","def AUC(points):\n\tauc = 0.0\n\tfor point2, point1 in zip(points[1:], points[:-1]):\n\t\t#print(point2, point1)\n\t\tbase = (point2[0] - point1[0]) / 100.0\n\t\theight = ( (point2[1] - point1[1])/2.0 + point1[1] ) / 100.0\n\t\tauc += (base*height)\n\treturn auc","def predict(self, users, items):\n self.eval()\n users_t = torch.tensor(users, dtype=torch.int64, device=self.device)\n items_t = torch.tensor(items, dtype=torch.int64, device=self.device)\n\n with torch.no_grad():\n # scores = torch.mul(\n # self.user_embedding(users_t), self.item_embedding(items_t)\n # ).sum(dim=1)\n ua_embeddings, ia_embeddings = self.forward(self.norm_adj)\n u_g_embeddings = ua_embeddings[users_t]\n i_g_embeddings = ia_embeddings[items_t]\n scores = self.f(torch.mul(u_g_embeddings, i_g_embeddings).sum(dim=1))\n return scores","def create_user_item_array(self):\n user_em = self.user_factors.weight.detach()\n item_em = self.product_factors.weight.detach()\n user_b = self.user_bias.weight.detach()\n item_b = self.product_bias.weight.detach()\n\n user_item_array = (item_em + item_b) @ (user_em + user_b).transpose(0, 1)\n preds = self._prob_to_class(user_item_array).numpy()\n\n return preds","def predict(self, user, item):\n return self.user_vectors[user, :].dot(self.item_vectors[item, :].T)","def calculate_item_relevance_scores(self, user_similarity_profile):\r\n scores = user_similarity_profile.dot(self.ratings_matrix.matrix)\r\n return self.ratings_matrix.normalize_score_vector(scores)","def _get_recommend(self, user):\n return self.user_cf.calculate(target_user_id=user, user_n=self.user_n,\n item_n=self.item_n, type=2)","def calc_bpr_loss(\n self, user_emd, item_emd, user_list, pos_item_list, neg_item_list\n ):\n u_e = user_emd[user_list]\n pi_e = item_emd[pos_item_list]\n ni_e = item_emd[neg_item_list]\n p_scores = torch.mul(u_e, pi_e).sum(dim=1)\n n_scores = torch.mul(u_e, ni_e).sum(dim=1)\n\n l1 = torch.sum(-F.logsigmoid(p_scores - n_scores))\n\n u_e_p = self.user_embedding(user_list)\n pi_e_p = self.item_embedding(pos_item_list)\n ni_e_p = self.item_embedding(neg_item_list)\n\n l2 = self.reg_loss(u_e_p, pi_e_p, ni_e_p)\n\n return l1 + l2 * self.reg_weight","def compute_kappa_score(self, scorer1, scorer2, items, matrix_weights):\r\n #matrice nb items\r\n df_n_items = pd.DataFrame(data=0, index=items, columns=items)\r\n for score1, score2 in zip(scorer1, scorer2):\r\n df_n_items[score1][score2] = df_n_items[score1][score2] + 1\r\n #nb items * total number of scoring items\r\n df_proba = df_n_items / len(scorer1)\r\n #df_proba with weights\r\n df_proba_w = df_proba * matrix_weights\r\n #relative observed agreement among raters\r\n p_a = df_proba_w.sum().sum()\r\n #hypothetical probability of chance agreement\r\n p_e = 0\r\n for lig in df_proba.index:\r\n for col in df_proba.columns:\r\n p_e = p_e + df_proba.loc[lig, :].sum() * \\\r\n df_proba.loc[:, col].sum() * matrix_weights.loc[lig, col]\r\n #kappa score\r\n kappa = 1 - (1 - p_a) / (1 - p_e)\r\n return kappa","def compute_error(data, user_features, item_features, nz):\n sum_err = 0\n for d, n in nz:\n err = data[d,n] - np.dot(item_features[d,:],user_features[:,n])\n sum_err += err**2\n rmse = 0.5*sum_err/len(nz)\n return rmse","def estimate(self, item):\n return self.A[item] if item in self.A.keys() else 0","def predict(self, user, item):\n pred = self.global_bias + self.user_bias[user] + self.item_bias[item]\n pred += self.U[user, :].dot(self.I[:, item])\n return pred","def test_recommendation_evaluation_3(model, interactions_ds):\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=1,\n novelty=False) == \\\n {'HitRatio@2': 0.02, 'NDCG@2': 0.0179, 'Precision@2': 0.01, 'Recall@2': 0.02}","def calculate_pairwise_user_similarity(self, user1_preferences, user2_preferences):\r\n\r\n shared_items = set(user1_preferences.indices) & set(user2_preferences.indices)\r\n\r\n all_items = set(user1_preferences.indices) | set(user2_preferences.indices)\r\n\r\n num_agreements = sum(1 for x in shared_items if abs(user1_preferences[0, x] - user2_preferences[0, x]) <= 2)\r\n\r\n return (num_agreements / len(all_items) if len(all_items) > 0 else 0)","def calculate_total(self, calcu_user_n=20, user_n=20, item_n=10, seed=1):\n self._split_data(seed=seed)\n self._set_top(user_n=user_n, item_n=item_n)\n test_user_list = list(set(self.test['userId'].unique()))\n user_list = [test_user_list[random.randint(0, len(test_user_list)) - 1]\n for i in range(calcu_user_n)]\n hit = 0 # Hit score\n all_recom = 0 # num of all recommendations, calculate the accuracy rate\n like_item = 0 # num of the item the user likes in the test set, calculate the recall rate\n all_recom_set = set()\n all_item = set(self.train['movieId'].unique())\n item_popular = Counter(self.train['movieId'].values)\n ret = 0\n n = 0\n print('\\nCalculate all evaluation indicators...')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user, )\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n like_item += len(user_item)\n all_recom += len(recom_item)\n all_recom_set.update(recom_item)\n for rec in set([data[0] for data in recom_data]):\n ret += math.log(1 + item_popular.get(rec))\n n += 1\n print('\\nCalculate over')\n print('Precision is: ', hit / (all_recom * 1.0))\n print('Recall is: ', hit / (like_item * 1.0))\n print('Coverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\n print('Popularity is:', (ret / n * 1.0))","def conf(self, success, total):\n try:\n sp = success / total\n conf = binom_conf_interval(success, total, interval='jeffreys')\n uperr = conf[1] - sp # 1 sigma confidence above mean\n loerr = sp - conf[0] # 1 sigma confidence below mean\n return sp, uperr, loerr, 0.5*(uperr+loerr)\n except ValueError as e:\n return 0, 0, 0, 0","def getSupport(item):\n # return float(freqSet[item])/len(transactionList)\n return float(freqSet[item]) / len(dateStampSet)","def robbins_confidence(counts, alpha=0.05):\n s = singles(counts)\n n = counts.sum()\n k = sqrt((n+1)/alpha)\n return (s-k)/(n+1), (s+k)/(n+1)","def calc_ssl_loss(\n self, user_list, pos_item_list, user_sub1, user_sub2, item_sub1, item_sub2\n ):\n\n u_emd1 = F.normalize(user_sub1[user_list], dim=1)\n u_emd2 = F.normalize(user_sub2[user_list], dim=1)\n all_user2 = F.normalize(user_sub2, dim=1)\n v1 = torch.sum(u_emd1 * u_emd2, dim=1)\n v2 = u_emd1.matmul(all_user2.T)\n v1 = torch.exp(v1 / self.ssl_tau)\n v2 = torch.sum(torch.exp(v2 / self.ssl_tau), dim=1)\n ssl_user = -torch.sum(torch.log(v1 / v2))\n\n i_emd1 = F.normalize(item_sub1[pos_item_list], dim=1)\n i_emd2 = F.normalize(item_sub2[pos_item_list], dim=1)\n all_item2 = F.normalize(item_sub2, dim=1)\n v3 = torch.sum(i_emd1 * i_emd2, dim=1)\n v4 = i_emd1.matmul(all_item2.T)\n v3 = torch.exp(v3 / self.ssl_tau)\n v4 = torch.sum(torch.exp(v4 / self.ssl_tau), dim=1)\n ssl_item = -torch.sum(torch.log(v3 / v4))\n\n return (ssl_item + ssl_user) * self.ssl_weight","def mrr(self):\n _test = self.drop_bad_ratings()\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\n ['user', 'item', 'rating_x', 'rating_y']]\n nott = np.vectorize(lambda x: not x)\n mrrs = []\n for user in merged.user.unique():\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\n true_ratings = frame.rating_x.values\n positions = np.where(nott(np.isnan(true_ratings)))[0]\n if len(positions) > 0:\n mrrs.append(1 / (positions[0] + 1))\n else:\n mrrs.append(0)\n\n return sum(mrrs) / len(mrrs)","def predict(self, X):\n \n n_samples = X.shape[0]\n y_pred = self.mean_rating_*np.ones(n_samples)\n for i in np.arange(n_samples):\n if X[i,0] < self.num_user and X[i,1] < self.num_item:\n y_pred[i] += np.dot(self.U[X[i,0],:],self.V[X[i,1],:])\n y_pred[i] = np.clip(y_pred[i],self.min_rating_,\n self.max_rating_)\n \n return y_pred","def itembase(user_id):\n frame1 = pd.concat([pd.DataFrame(REVIEWS[x]) for x in REVIEWS])\n filtered_data = recommender.filtering_not_city()\n businesses = pd.DataFrame(filtered_data).set_index('business_id')\n frame2 = frame1.drop_duplicates(subset=[\"user_id\", \"business_id\"], keep='last', inplace=False)\n\n utility_matrix = pivot_reviews(frame2)\n\n similarity = create_similarity_matrix_euclid(utility_matrix)\n\n for business in businesses.index:\n neighborhood = select_neighborhood(similarity, utility_matrix, user_id, business)\n prediction = weighted_mean(neighborhood, utility_matrix, user_id)\n businesses.ix[business, 'predicted rating'] = prediction\n\n sorted_prediction = businesses.sort_values(by=['predicted rating'], ascending=False)\n sorted_prediction2 = sorted_prediction.drop(columns=['predicted rating'])\n sorted_prediction2 = sorted_prediction2.reset_index()\n sorted_prediction3 = sorted_prediction.reset_index()\n return sorted_prediction2.to_dict(orient='records'), sorted_prediction3.to_dict(orient='records')","def single_user_recommendation_vector(self, user_ratings):\r\n\r\n ratings_vector = self.ratings_matrix.get_ratings_vector(user_ratings)\r\n\r\n user_similarity_profile = self.calculate_user_similarity_profile(ratings_vector)\r\n\r\n return self.calculate_item_relevance_scores(user_similarity_profile)","def compute_user_local_sensitivity(sc, dataset, user_id, num_iters_ls):\n\n res = defaultdict(lambda: 0.0)\n\n original_recs, original_qii = compute_recommendations_and_qii(sc, dataset,\n user_id)\n original_recs = recommendations_to_dd(original_recs)\n\n res[\"recommendee_user_id\"] = user_id\n res[\"recommendee_recs_l1_norm\"] = l1_norm(original_recs)\n res[\"recommendee_qii_l1_norm\"] = l1_norm(original_qii)\n res[\"recommendee_recs_l0_norm\"] = len(original_recs)\n res[\"recommendee_qii_l0_norm\"] = len(original_qii)\n res[\"perturbations\"] = []\n\n all_users = get_user_list(dataset)\n for x in xrange(num_iters_ls):\n if perturb_specific_user:\n other_user_id = perturb_specific_user\n else:\n other_user_id = random.choice(list(set(all_users) - {user_id}))\n print \"Perturbing user\", other_user_id, \"(\", x+1, \"out of\",\\\n num_iters_ls, \")\"\n perturbed_dataset = perturb_user_ratings(sc, dataset, other_user_id)\n start = time.time()\n recs, qii = compute_recommendations_and_qii(sc, perturbed_dataset, user_id)\n stop = time.time()\n recs = recommendations_to_dd(recs)\n rec_ls = calculate_l1_distance(original_recs, recs)\n qii_ls = calculate_l1_distance(original_qii, qii)\n\n report = {}\n report[\"perturbed_user_id\"] = other_user_id\n report[\"perturbed_recs_l1_norm\"] = l1_norm(recs)\n report[\"perturbed_qii_l1_norm\"] = l1_norm(qii)\n report[\"perturbed_recs_l0_norm\"] = len(recs)\n report[\"perturbed_qii_l0_norm\"] = len(qii)\n report[\"recs_ls\"] = rec_ls\n report[\"qii_ls\"] = qii_ls\n report[\"recs_ls_norm\"] = rec_ls/float((len(recs)*4))\n report[\"qii_ls_norm\"] = qii_ls/float((len(qii)*4))\n print \"Local sensitivity of recs: \", rec_ls/float((len(recs)*4))\n print \"Local sensitivity of QII: \", qii_ls/float((len(qii)*4))\n report[\"computation_time\"] = stop - start\n\n\n res[\"perturbations\"].append(report)\n\n for per in res[\"perturbations\"]:\n res[\"avg_recs_ls\"] += float(per[\"recs_ls\"])/len(res[\"perturbations\"])\n res[\"max_recs_ls\"] = max(res[\"max_recs_ls\"], per[\"recs_ls\"])\n res[\"avg_recs_ls_norm\"] +=\\\n float(per[\"recs_ls_norm\"])/len(res[\"perturbations\"])\n res[\"max_recs_ls_norm\"] = max(res[\"max_recs_ls_norm\"],\n per[\"recs_ls_norm\"])\n res[\"avg_qii_ls\"] += float(per[\"qii_ls\"])/len(res[\"perturbations\"])\n res[\"max_qii_ls\"] = max(res[\"max_qii_ls\"], per[\"qii_ls\"])\n res[\"avg_qii_ls_norm\"] +=\\\n float(per[\"qii_ls_norm\"])/len(res[\"perturbations\"])\n res[\"max_qii_ls_norm\"] = max(res[\"max_recs_qii_norm\"],\n per[\"qii_ls_norm\"])\n return dict(res)","def _calculate_tp_confidences(images, test_class):\n confidences = []\n for (response_json, class_name) in predict(images, desc=f\"[{test_class}] inference\"):\n if response_json[\"status\"] != \"ok\":\n raise Exception(f\"Not OK response in {class_name}\")\n if class_name == test_class and response_json[\"response\"] == class_name:\n confidences.append(response_json[\"confidence\"])\n return confidences","def _calculate_fp_confidences(images, test_classes):\n confidences = []\n for (response_json, class_name) in predict(images, desc=f\"[{BACKGROUND}] inference\"):\n if response_json[\"status\"] != \"ok\":\n raise Exception(f\"Not OK response in {class_name}\")\n if response_json[\"response\"] in test_classes:\n confidences.append(response_json[\"confidence\"])\n return confidences","def calculate_error_rates(point_to_weight, classifier_to_misclassified):\n ans = {}\n for c in classifier_to_misclassified:\n misclassified = classifier_to_misclassified[c]\n ans[c] = 0\n for p in misclassified:\n ans[c] += point_to_weight[p]\n return ans","def stdConfidenceTrades(predictions, buy_confidence=1.5, sell_confidence=1.1):\n smooth_preds = pd.Series(predictions).rolling(5).mean()\n buy_thresh = np.mean(smooth_preds) + buy_confidence * np.std(smooth_preds)\n sell_thresh = np.mean(smooth_preds) - sell_confidence * np.std(smooth_preds)\n buy_positions = np.where(predictions > buy_thresh)[0]\n sell_positions = np.where(predictions < sell_thresh)[0]\n \n buys = buy_positions\n sells = []\n curSell = 0\n for curBuy in buys:\n arr = np.where(sell_positions > curBuy)[0]\n if len(arr):\n sells.append(sell_positions[arr[0]])\n tradePairs = list(zip(buys, sells))\n return tradePairs","def cre_confidence1(df):\r\n func = lambda x: 1 - np.abs(x.mean())\r\n return df.groupby('creline')['ffb_c'].transform(func)","def obscurity(user):\n reader = open(\"similarities.txt\", \"r\")\n lines = reader.readlines()\n obscurity = 0.0\n count = 0\n for line in lines:\n a, b, sim = line.split(\"\\t\")\n if user == a:\n count += 1\n obscurity += float(sim)\n\n obscurity /= count\n return obscurity","def probability(self, item):\n count = self.counter.get(item, 0)\n if self.smoothing_dict:\n smooth_count = self.smoothing_dict.get(count, count)\n assert smooth_count > 0\n return smooth_count / self.smooth_total\n else:\n return count / self.total","def weighted_average(items, weights):\n assert len(items) > 0\n assert len(items) == len(weights)\n # declare total as the return value which is a decimal\n total = 0.0\n # for all pairs from two lists\n for i in range(len(items)):\n \t# we increment the total for the product of both value\n \ttotal += items[i] * weights[i]\n # we return the total divided by sum of weights\n return total / sum(weights)","def recall(self, user_list):\n hit = 0\n like_item = 0\n print('\\nCalculate recall: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n like_item += len(user_item)\n print('\\nrecall is: ', hit / (like_item * 1.0))\n return hit / (like_item * 1.0)","def decision_function(self, user_id=0):\n if user_id != 0:\n cls_scores, class_ids = self.__decision_function\n try:\n index = np.where(class_ids == user_id)\n return cls_scores[index]\n except:\n return -self.__decision_nr_samples\n else:\n return self.__decision_function","def score_method(pairs_true, pairs_test):\n \n set_true = {tuple(e) for e in pairs_true}\n set_test = {tuple(e) for e in pairs_test}\n true_pos, false_pos, false_neg = confusion_stats(set_true, set_test)\n \n total = true_pos + false_pos + false_neg\n true_pos_rate = true_pos / total\n false_pos_rate = false_pos / total\n false_neg_rate = false_neg / total\n \n return true_pos_rate, false_pos_rate, false_neg_rate","def user_interaction_score(uv, recommended_News, ranked=True):\n\n iv = recommended_News[\"topical_vector\"]\n\n product = simple_doct_product(uv, iv)\n\n epsilon = 10e-5\n\n if (product + epsilon) > 1.0:\n vui = 0.99\n else:\n vui = beta_distribution(product)\n\n # Awared preference\n ita = beta_distribution(0.98)\n pui = vui * ita\n\n return pui","def user_based_prediction(self, line, rating_bd, sim_bd, user_bd):\n def prediction(pair, uid_allneighbor_info, user_bd, uid):\n \"\"\"do the prediction. It can either add decay rate or not,\n which is decided by `method`.\n Args:\n pair: (iid, rating, time)\n uid_allneighbor_info: (uid, sim, rating_record)*\n average_uid: average rating of current uid.\n \"\"\"\n iid, real_rating, time = pair\n average_uid_rating = user_bd.value[uid][0]\n sim_rating = []\n for info in uid_allneighbor_info:\n uid, sim, ratings = info\n sim_rating += [\n (rating[0], sim, rating[1] - average_uid_rating)\n for rating in ratings if iid in rating[0]]\n\n if len(sim_rating) != 0:\n sim_rating = [\n (line[0], line[1] * line[2], abs(line[1]))\n for line in sim_rating]\n predicted_rating = average_uid_rating + sum(\n map(lambda line: line[1], sim_rating)) / sum(\n map(lambda line: line[2], sim_rating))\n else:\n predicted_rating = average_uid_rating\n return iid, real_rating, self.bound_rating(predicted_rating)\n\n uid, pairs = line\n uid_allneighbor_info = [\n (u[0], u[1], rating_bd.value[u[0]]) for u in sim_bd.value[uid]]\n return uid, [prediction(\n pair, uid_allneighbor_info, user_bd, uid) for pair in pairs]","def estimate_user_biases(self):\n self.user_biases = {}\n for user in self.user_ratings:\n # b_u = sum(r_ui - mu - b_i) / len(R(u))\n user_bias = [rating - self.global_mean - self.movie_biases[movie]\n for movie, rating in self.user_ratings[user].items()]\n user_bias = sum(user_bias) / len(user_bias)\n self.user_biases[user] = user_bias","def ndpm(self):\n\n merged = pd.merge(left=self.test, right=self.predict, on=['user', 'item'], how='inner')[\n ['user', 'rating_x', 'rating_y']]\n ndpms = []\n for user in merged.user.unique():\n frame = merged[merged.user == user]\n if frame.shape[0] <= 1:\n continue\n C_plus = self.num_of_ordered_positive(frame, 'rating_x', 'rating_y')\n C_minus = self.num_of_ordered_negative(frame, 'rating_x', 'rating_y')\n C_u = self.num_of_ordered(frame, 'rating_x')\n if C_u == 0:\n continue\n C_s = self.num_of_ordered(frame, 'rating_y')\n C_u0 = C_u - (C_plus + C_minus)\n ndpms.append(1 - (C_minus + 0.5 * C_u0) / C_u)\n\n return sum(ndpms) / len(ndpms)","def evaluate(topk_matches, test_user_products, num_recommendations, brand_dict):\n invalid_users = []\n # Compute metrics\n precisions, recalls, ndcgs, hits, fairness = [], [], [], [], []\n test_user_idxs = list(test_user_products.keys())\n for uid in test_user_idxs:\n if uid not in topk_matches or len(topk_matches[uid]) < num_recommendations:\n invalid_users.append(uid)\n continue\n pred_list, rel_set = topk_matches[uid][::-1], test_user_products[uid]\n if len(pred_list) == 0:\n continue\n\n dcg = 0.0\n hit_num = 0.0\n for i in range(len(pred_list)):\n if pred_list[i] in rel_set:\n dcg += 1. / (log(i + 2) / log(2))\n hit_num += 1\n # idcg\n idcg = 0.0\n for i in range(min(len(rel_set), len(pred_list))):\n idcg += 1. / (log(i + 2) / log(2))\n ndcg = dcg / idcg\n recall = hit_num / len(rel_set)\n precision = hit_num / len(pred_list)\n hit = 1.0 if hit_num > 0.0 else 0.0\n\n ndcgs.append(ndcg)\n recalls.append(recall)\n precisions.append(precision)\n hits.append(hit)\n fairness.append(calculate_fairness(pred_list, brand_dict))\n\n avg_precision = np.mean(precisions) * 100\n avg_recall = np.mean(recalls) * 100\n avg_ndcg = np.mean(ndcgs) * 100\n avg_hit = np.mean(hits) * 100\n avg_fairness = np.mean(fairness)\n print('NDCG={:.3f} | Recall={:.3f} | HR={:.3f} | Precision={:.3f} | Fairness={:.3f} | Invalid users={}'.format(\n avg_ndcg, avg_recall, avg_hit, avg_precision, avg_fairness, len(invalid_users)))","def confidence(self) -> float:\n return self._confidence","def get_overall_score(self, user):\n\n quizzes = ['iq', 'math', 'english']\n\n prev_scores = []\n new_scores = []\n\n for quiz in quizzes:\n quiz_obj = self.get_object(quiz)\n queryset = self.get_queryset(user, quiz_obj)\n\n try:\n new_scores.append(queryset[0].marks)\n prev_scores.append(queryset[1].marks)\n except:\n new_scores.append(queryset[0].marks)\n prev_scores.append(0)\n\n import statistics\n\n return statistics.mean(prev_scores), statistics.mean(new_scores)","def calc_confidence(raw_output, labels_list=None):\n #print(\"raw_output:\", raw_output)\n result = raw_output\n probs = []\n for dc in result:\n for key in dc:\n #print(\"dc:\", dc)\n #print(\"key:\", key)\n logits = dc[key]\n logit = logits[0]\n ps = softmax_probabilities(logit)\n max_ps = max(ps)\n index = np.argmax(ps)\n probs.append(max_ps)\n #print('max_ps:', max_ps)\n #print('index:', index)\n #if labels_list:\n # print('tag:', labels_list[index])\n return probs","def evaluate(self, dataloader):\n squared_loss = 0\n correct = 0\n total = 0\n\n self.eval()\n with torch.no_grad():\n for user, item, rating in dataloader:\n forward = self(user, item)\n predicted = self._prob_to_class(forward)\n\n squared_loss += self.loss(forward, rating).item() * len(user)\n total += predicted.numel()\n correct += (predicted == rating.view(-1)).sum().item()\n\n mean_loss = squared_loss / total\n\n return mean_loss, f\"{(100 * correct / total):.2f}\"","def ap(self, result, next_item):\n if next_item in result.index:\n rank = result.index.get_loc(next_item) + 1\n return 1.0 / rank\n else:\n return 0","def calcUserMeanRating(userRatingGroup):\n userID = userRatingGroup[0]\n ratingSum = 0.0\n ratingCnt = len(userRatingGroup[1])\n if ratingCnt == 0:\n return (userID, 0.0)\n for item in userRatingGroup[1]:\n ratingSum += item[1]\n return (userID, 1.0 * ratingSum / ratingCnt)","def make_predictions(movies, ratings_train, ratings_test):\n ###TODO\n \n user_result = [] \n \n for index,row in ratings_test.iterrows():\n userid_test = row['userId']\n #print(\"userid_test::\",userid_test) \n movieid_test = row['movieId'] \n #print(\"movieid_test::\",movieid_test) \n x = list(movies[movies.movieId==movieid_test]['features'])[0]\n #print(\"CSR_GOTT+X::\",x)\n #print(\"TYPE of CSR_GOTT_X::\",type(x))\n subset_train = ratings_train[ratings_train.userId == userid_test]\n #print(\"SUB MOVIE SET::\",subset_train)\n #print(\"TYPE of SUB MOVIE SET::\",type(x))\n total_if_zero=0\n rating_if_zero=0\n sum_main_result=0\n sum_cosine=0 \n for index1,row1 in subset_train.iterrows():\n userid_train = row1['userId']\n #print(\"userid_train::\",userid_train) \n if(userid_test == userid_train ):\n #print(\"HII IN IFFF:::\")\n movieid_train = row1['movieId']\n #print(\"movieid_train::\",movieid_train)\n rating_train = row1['rating']\n #print(\"rating_train::\",rating_train)\n total_if_zero = total_if_zero + 1 \n rating_if_zero = rating_if_zero + rating_train\n y = list(movies[movies.movieId==movieid_train]['features'])[0]\n #print(\"CSR_GOTT_Y::\",y)\n #print(\"TYPE of CSR_GOTT_Y::\",type(y))\n result_cos = cosine_sim(x,y)\n sum_main_result += result_cos * rating_train\n sum_cosine += result_cos \n \n if(sum_main_result != 0):\n user_result.append(sum_main_result/sum_cosine)\n #print(\"user_result::\",user_result) \n else:\n user_result.append(rating_if_zero / total_if_zero)\n #print(\"user_result::\",user_result) \n \n return_result_arr = np.array(user_result) \n \n return return_result_arr\n \n pass","def get_correct(self, predicted, actual):\n ret_ratios = [np.sum(predicted == actual) / len(actual)]\n for i in range(2):\n actual_ones = np.where(actual == i)[0]\n should_be_ones = np.take(predicted, actual_ones)\n actual_ones = np.take(actual, actual_ones)\n ret_ratios.append(np.sum(should_be_ones == actual_ones) / len(actual_ones))\n\n return tuple(ret_ratios)","def compute_average_user_ratings(user_ratings):\n ave_ratings = {}\n \n for user,value in user_ratings.items():\n sum = 0\n movie_num=0\n for movieId, rating in value.items():\n sum += float(rating)\n movie_num += 1\n average = sum / movie_num\n ave_ratings[user]=average\n return ave_ratings","def CF_item_predict(train_data_matrix: csr_matrix):\n logging.getLogger(__name__).info(\"Begin to calculate similarity of CF item-item based!\")\n train_data_matrix = train_data_matrix.A\n item_similarity = cosine_similarity(train_data_matrix.T)\n logging.getLogger(__name__).info(\"Begin to predict based on CF item-item!\")\n item_prediction = predict(train_data_matrix, item_similarity, type='item')\n return item_prediction","def predict_proba_confidence(clf, X, y_true):\n class_labels = clf.classes_\n y_pred_proba = clf.predict_proba(X)[:,1]\n ent = [entropy(i) for i in y_pred_proba]\n\n return sum(ent)/len(ent)","def mutual_info_score(self):\n _, _, I_CK = self._entropies()\n return I_CK / self.grand_total","def probabilities_score(model_id, test_set_id, rubric_id):\n result = {'true_average_probability': 0, 'false_average_probability': 0}\n # right answers\n answers = db.get_rubric_answers(test_set_id, rubric_id)\n # rubrication results\n rubrication_result = db.get_rubrication_probability(model_id, test_set_id, rubric_id)\n\n true_number = 0\n true_probability = 0\n false_number = 0\n false_probability = 0\n\n for key in rubrication_result:\n if answers[key]:\n true_number += 1\n true_probability += rubrication_result[key]\n else:\n false_number +=1\n false_probability += rubrication_result[key]\n\n if true_number:\n result['true_average_probability'] = true_probability / true_number\n\n if false_number:\n result['false_average_probability'] = false_probability / false_number\n\n return result","def get_similarity(user1: Rating, user2: Rating) -> float:\n shared = 0.0\n for m_id in user1:\n if m_id in user2:\n shared += user1[m_id] * user2[m_id]\n norm1 = 0.0\n for m_id in user1:\n norm1 = norm1 + user1[m_id] ** 2\n norm2 = 0.0\n for m_id in user2:\n norm2 = norm2 + user2[m_id] ** 2\n return (shared * shared) / (norm1 * norm2)","def standardize_sim_values(self):\n for user_id_A, row in self.sim_matrix.items(): # row is reference\n lA = len(self.users[user_id_A].covered_items)\n for user_id_B in row.keys():\n lB = len(self.users[user_id_B].covered_items)\n row[user_id_B] /= sqrt(lA*lB)\n assert row[user_id_B] <= 1","def _build_user_model(self, user_ids):\n res_dict = {}\n for user_id in user_ids:\n specific_user_log = self._user_log[self._user_log['user_id'] == user_id]\n log_vecs = pd.merge(specific_user_log, self._item_vector, how='left', on=['item_id'])\n assert (sum(log_vecs['vec'].notnull()) == log_vecs.shape[0]), 'Item vector sheet has null values'\n res_dict[user_id] = ContentBasedAlgo._calc_dim_average(np.array(log_vecs['vec'].values.tolist()))\n return res_dict","def user_based_recommendation(\n self, test_dataRDD,\n user_based_dict_bd, userbased_sim_pair_dict_bd, user_info_bd):\n sim_pair_dict_keys = set(userbased_sim_pair_dict_bd.value.keys())\n return test_dataRDD.filter(\n lambda line: line[0] in sim_pair_dict_keys).map(\n lambda line: self.user_based_prediction(\n line, user_based_dict_bd,\n userbased_sim_pair_dict_bd, user_info_bd))","def prec_recall_f1_score(pred_items, gold_items):\n common = Counter(gold_items) & Counter(pred_items)\n num_same = sum(common.values())\n if num_same == 0:\n return 0\n precision = 1.0 * num_same / len(pred_items)\n recall = 1.0 * num_same / len(gold_items)\n f1 = (2 * precision * recall) / (precision + recall)\n return f1","def calculate_penalty(self):\n if AT.PENALTY not in self.attributes:\n return (0, 1)\n return self.attributes[AT.PENALTY].calculate(self)","def surprisal(self, item):\n return - math.log(self.probability(item))","def prediction():\r\n\r\n\r\n\tpredictVal = []\r\n\taccuracy = 0.0\r\n\r\n\t# Calculate accuracy for each class in testData\r\n\tfor item in testData:\r\n\t\tclass0Prediction = posProb / 100\r\n\t\tclass1Prediction = negProb / 100\r\n\t\t\r\n\t\t# Multiply the prior probablities for negative and positive reviews by their feature likelihoods \r\n\t\tfor word in item[2]:\r\n\t\t\tclass0Prediction *= class0Dict[word]\r\n\t\t\tclass1Prediction *= class1Dict[word]\r\n\r\n\t\t# Give every item in testData a predicted value\r\n\t\tif(class0Prediction > class1Prediction):\r\n\t\t\tpredictVal.append('0')\r\n\t\telse:\r\n\t\t\tpredictVal.append('1')\r\n\r\n\tfor i in range(len(testData)):\r\n\t\tif(testData[i][1] == predictVal[i]):\r\n\t\t\taccuracy += 1\r\n\r\n\t\t\t\r\n\taccuracy = 100 * (accuracy / len(testData))\r\n\treturn(predictVal, accuracy)","def predictRating(toPredict, candidateList):\n\n ratingRelevantCandidates = []\n\n #Remove candidates with no rating specified\n for candidate in candidateList:\n currentCandidate = candidate[1]\n\n if float(currentCandidate['vote_avg']) > 0:\n ratingRelevantCandidates.append((float(currentCandidate['vote_avg']), candidate))\n\n #print(\"ratings::::::::\",currentCandidate['vote_avg'])\n\n #Remove outlier candidates based on rating\n ratingMean = np.mean([x[0] for x in ratingRelevantCandidates])\n print(\"ratingMean\", ratingMean)\n ratingSD = np.std([x[0] for x in ratingRelevantCandidates])\n print(\"ratingSD\", ratingSD)\n\n finalRatings = [x for x in ratingRelevantCandidates if (float(x[0]) < ratingMean + ratingSD)]#1.5 *\n finalRatings = [x for x in finalRatings if (float(x[0]) > ratingMean - ratingSD)]#.75 *\n\n finalRatingCandidatesWithWeight = []\n\n #Weight each candidate based on vote count, direct and actor popularity and matching score from part 1\n for candidate in finalRatings:\n directorPoints = compareDirectorPoints(toPredict['director'], candidate[1][1]['director'])\n actorPoints = compareActorPoints(toPredict['cast'], candidate[1][1]['cast'])\n voteCountPoints = int(candidate[1][1]['vote_count'])\n matchPoints = candidate[1][0] / np.max([float(x[1][0]) for x in finalRatings]) * 100\n candidateWeight = PREDICTION_MATCHPOINTS_WEIGHT * matchPoints \\\n + PREDICTION_ACTOR_WEIGHT * actorPoints \\\n + PREDICTION_DIRECTOR_WEIGHT * directorPoints \\\n + PREDICTION_VOTECOUNT_WEIGHT * voteCountPoints\n\n finalRatingCandidatesWithWeight.append((candidateWeight, candidate[0]))\n\n #Calculate the prediction\n sumRatingCandidateWeights = np.sum([float(x[0]) for x in finalRatingCandidatesWithWeight])\n sumRatingTimesCandidateWeight = np.sum([float(x[0]) * float(x[1]) for x in finalRatingCandidatesWithWeight])\n\n ratingPrediction = float(sumRatingTimesCandidateWeight / sumRatingCandidateWeights)\n\n return ratingPrediction","def calculate_metrics(predictions, expected):\n # type: (np.ndarray, np.ndarray) -> (float, float, float)\n clients_count = predictions.shape[0]\n products_count = predictions.shape[1]\n\n true_positive = 0.0\n true_negative = 0.0\n false_positive = 0.0\n false_negative = 0.0\n\n total = float(clients_count * products_count)\n\n for c in range(0, clients_count):\n for p in range(0, products_count):\n if predictions[c, p] == expected[c, p]:\n if predictions[c, p] == 1:\n true_positive += 1\n else:\n true_negative += 1\n else:\n if predictions[c, p] == 1:\n false_positive += 1\n else:\n false_negative += 1\n\n accuracy = float(true_positive + true_negative) / total\n if true_positive + false_positive == 0:\n precision = 0\n else:\n precision = true_positive / float(true_positive + false_positive)\n\n if true_positive + false_negative == 0:\n recall = 0\n else:\n recall = true_positive / float(true_positive + false_negative)\n\n return accuracy, precision, recall","def calc_probabilities(applications):\n sum_advantage = sum(app.get_advantage() for app in applications)\n return [app.get_advantage() / sum_advantage for app in applications]","def precision_and_recall_k(model, user_dict, item_dict, train_user_list, test_user_list, klist, batch=256):\n # get all user emd and item emd\n user_emb, item_emb, umap, imap = prepare_user_item_emd(model, user_dict, item_dict)\n user_emb = user_emb.detach().cpu()\n item_emb = item_emb.detach().cpu()\n\n # Calculate max k value\n max_k = max(klist)\n\n # Compute all pair of training and test record\n result = None\n for i in range(0, user_emb.shape[0], batch):\n # Create already observed mask\n mask = user_emb.new_ones([min([batch, user_emb.shape[0] - i]), item_emb.shape[0]])\n for j in range(batch):\n if i + j >= user_emb.shape[0]:\n break\n items_idx = train_user_list[i + j]\n if (items_idx != []):\n emd_index = [imap[i] for i in items_idx]\n mask[j].scatter_(dim=0, index=t.tensor(list(emd_index)), value=t.tensor(0.0))\n # Calculate prediction value\n\n cur_result = t.mm(user_emb[i:i + min(batch, user_emb.shape[0] - i), :], item_emb.t())\n cur_result = t.sigmoid(cur_result)\n assert not t.any(t.isnan(cur_result))\n # Make zero for already observed item\n cur_result = t.mul(mask, cur_result)\n _, cur_result = t.topk(cur_result, k=max_k, dim=1)\n result = cur_result if result is None else t.cat((result, cur_result), dim=0)\n\n result = result.cpu()\n # Sort indice and get test_pred_topk\n precisions, recalls = [], []\n for k in klist:\n precision, recall = 0, 0\n for i in range(user_emb.shape[0]):\n test = set(test_user_list[i])\n pred = set(result[i, :k].numpy().tolist())\n val = len(test & pred)\n precision += val / max([min([k, len(test)]), 1])\n recall += val / max([len(test), 1])\n precisions.append(precision / user_emb.shape[0])\n recalls.append(recall / user_emb.shape[0])\n return precisions, recalls","def runApriori(data_iter, minSupport, minConfidence):\n itemSet, transactionList = getItemSetTransactionList(data_iter)\n freqSet = defaultdict(int)\n largeSet = dict()\n# Global dictionary which stores (key=n-itemSets,value=support)\n# which satisfy minSupport\n assocRules = dict()\n# Dictionary which stores Association Rules\n oneCSet = returnItemsWithMinSupport(itemSet,\n transactionList,\n minSupport,\n freqSet)\n currentLSet = oneCSet\n k = 2\n while(currentLSet != set([])):\n largeSet[k-1] = currentLSet\n currentLSet = joinSet(currentLSet, k)\n currentCSet = returnItemsWithMinSupport(currentLSet,\n transactionList,\n minSupport,\n freqSet)\n currentLSet = currentCSet\n k = k + 1\n\n\n def getSupport(item):\n \"\"\"local function which Returns the support of an item\"\"\"\n return float(freqSet[item]) / len(transactionList)\n toRetItems = []\n for key, value in largeSet.items():\n toRetItems.extend([(tuple(item), getSupport(item))\n for item in value])\n toRetRules = []\n for key, value in largeSet.items()[1:]:\n for item in value:\n _subsets = map(frozenset, [x for x in subsets(item)])\n for element in _subsets:\n remain = item.difference(element)\n if len(remain) > 0:\n confidence = getSupport(item) / getSupport(element)\n if confidence >= minConfidence:\n toRetRules.append(((tuple(element), tuple(remain)),\n confidence))\n return toRetItems, toRetRules","def get_final_score(self, user):\n\n iq_subject_score = self.get_overall_score(user=user)\n\n try:\n speech_score = UserQuizMark.objects.filter(user=user, quiz=self.get_object('speech_training')).latest(\n 'timestamp').marks\n drawing_score = UserQuizMark.objects.filter(user=user, quiz=self.get_object('drawing')).latet(\n 'timestamp').marks\n except UserQuizMark.DoesNotExist:\n raise Http404\n\n avg_speech_drawing_score = speech_score + drawing_score\n\n return (iq_subject_score + avg_speech_drawing_score) / 2","def confidence(self):\n return self._confidence","def confidence(self):\n return self._confidence","def calculate_profit(self):","def classProbs(observation, tree, classes):\n res = classify(observation, tree) #res = results\n total = sum(res.values())\n probs = []\n for c in classes:\n if c in res.keys():\n probs.append(float(res[c])/total)\n else:\n probs.append(0)\n return probs"],"string":"[\n \"def _predict_user_item(self, user, item):\\n if not isinstance(user, int):\\n user = self._user_to_ndx[user]\\n if not isinstance(item, int):\\n item = self._item_to_ndx[item]\\n\\n try:\\n rating_mean = self._averages[user]\\n except AttributeError:\\n raise RuntimeError('Must fit before predicting')\\n\\n other_users = [other for other in self._users if other != user and\\n np.isfinite(self._votes[other][item])]\\n weights = np.array([self._weight(user, other)\\n for other in other_users])\\n deviations = np.array([self._votes[other][item] - self._averages[other]\\n for other in other_users])\\n\\n weight_sum = np.sum(np.absolute(weights))\\n if weight_sum < _EPSILON:\\n return rating_mean # No similar users, so guess their avg rating\\n\\n norm_const = 1 / weight_sum\\n\\n weighted_avg = np.sum(weights * deviations)\\n return rating_mean + norm_const * weighted_avg\",\n \"def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\\n active_user = actives[0][0]\\n active_item = actives[0][1]\\n\\n # -----------------------------------\\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\\n\\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\\n return (active_user, active_item), 2.5\\n\\n # all user, ratings that have rated active_item\\n if active_item in train_rdd_gbitem_dict:\\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\\n else:\\n # item not found in training set\\n # new item problem.\\n average_of_user_list = train_rdd_gbuser_dict[active_user]\\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\\n return (active_user, active_item), average_of_user\\n\\n # user rated items - all (item, ratings) that the user has rated\\n if active_user in train_rdd_gbuser_dict:\\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\\n else:\\n # user not found in training set\\n # new user problem.\\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\\n\\n similarity_list = []\\n for item, rating in active_user_rated_items:\\n item_dict = dict(train_rdd_gbitem_dict[item][0])\\n item_avg = train_rdd_gbitem_dict[item][1]\\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\\n similarity_list.append((rating, similarity))\\n\\n # Have obtained similarity list for active item and item from the above code.\\n # Filter according to a top 'N' items and then take avg rating.\\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\\n # similarity_list = similarity_list[:len(similarity_list) // 4]\\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\\n # print(similarity_list)\\n pred_rating = find_weighted_average(similarity_list, num_items)\\n\\n # for i in similarity_list:\\n # print(i)\\n # print(\\\"Pred-rating: \\\", pred_rating)\\n\\n return (active_user, active_item), pred_rating\",\n \"def predict(self, user_id, item_id):\\n # DONEreturn prediction for given pair\\n return self._user_factors[user_id, : ].dot(self._item_factors[item_id, :])\",\n \"def predict_rating(user_id,item_id):\\n user_preference = latent_user_preferences[user_id]\\n item_preference = latent_item_features[item_id]\\n return user_preference.dot(item_preference)\",\n \"def predict_rating(self, user_id, item_id):\\n user_preference = self.latent_user_preferences[user_id]\\n item_feature = self.latent_item_features[item_id]\\n return user_preference.dot(item_feature)\",\n \"def calc_score(self, user_id, item_id): \\n p = np.dot(self.U[user_id], self.V[item_id])\\n if self.trunc_score_rule==None:pass\\n else: p=self.trunc_score_rule(p)\\n \\n return p\",\n \"def compute_user_user_sim_base_on_common_items(self):\\n self.sim_matrix = {}\\n for item in self.items.values():\\n # convert to list of tuples for indexing\\n users = list(item.covered_users.items())\\n item_popularity = len(users)\\n # iter through all user pairs\\n for i in range(len(users)-1):\\n for j in range(i+1, len(users)):\\n user_A_info, user_B_info = users[i], users[j]\\n # remember to update pair wise!\\n self.update_user_user_sim(user_A_info, user_B_info,\\n item_popularity)\\n self.update_user_user_sim(user_B_info, user_A_info,\\n item_popularity)\",\n \"def getConfidence(self,LeftTup,RightTup):\\n\\n tup=LeftTup+RightTup\\n _intersection=self.getSupport(tup)\\n _LHS=self.getSupport(LeftTup)\\n _confidence=_intersection/_LHS\\n return (_confidence)\",\n \"def precision(self, user_list):\\n hit = 0\\n all_recom = 0\\n print('Calculate precision: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n all_recom += len(recom_item)\\n print('\\\\nprecision is: ', hit / (all_recom * 1.0))\\n return hit / (all_recom * 1.0)\",\n \"def inner_product(user_profiles, item_attributes, normalize_users=True, normalize_items=False):\\n if normalize_users:\\n # this is purely an optimization that prevents numpy from having\\n # to multiply huge numbers\\n user_profiles = normalize_matrix(user_profiles, axis=1)\\n if normalize_items:\\n item_attributes = normalize_matrix(item_attributes.T, axis=1).T\\n assert user_profiles.shape[1] == item_attributes.shape[0]\\n scores = np.dot(user_profiles, item_attributes)\\n return scores\",\n \"def prediction(uid, pair, rating_bd, sim_bd, item_bd):\\n iid, real_rating = pair[0], pair[1]\\n if iid not in sim_bd.value.keys():\\n return ()\\n iid_neighbors = [\\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\\n average_iid_rating = item_bd.value[iid][0]\\n sim_rating = []\\n for info in iid_neighbors:\\n niid, nsim, ratings = info\\n sim_rating += [\\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\\n for rating in ratings if uid in rating[0]]\\n if len(sim_rating) != 0:\\n sim_ratings = [\\n (line[1] * line[2], abs(line[1]), line[3])\\n for line in sim_rating]\\n predicted_rating_no_decay = average_iid_rating + sum(\\n map(lambda line: line[0], sim_ratings)) / sum(\\n map(lambda line: line[1], sim_ratings))\\n predicted_rating_decay = \\\\\\n average_iid_rating + add_decay(sim_ratings)\\n else:\\n predicted_rating_no_decay = average_iid_rating\\n predicted_rating_decay = average_iid_rating\\n return iid, real_rating, \\\\\\n self.bound_rating(predicted_rating_no_decay), \\\\\\n self.bound_rating(predicted_rating_decay)\",\n \"def predict(self, users, items):\\n users_t = torch.tensor(users, dtype=torch.int64, device=self.device)\\n items_t = torch.tensor(items, dtype=torch.int64, device=self.device)\\n with torch.no_grad():\\n scores = torch.mul(\\n torch.cat(\\n (self.user_encode(users_t)[0], self.user_emb(users_t)), dim=1\\n ),\\n torch.cat(\\n (self.item_encode(items_t)[0], self.item_emb(items_t)), dim=1\\n ),\\n ).sum(dim=1)\\n return scores\",\n \"def estimate(self, u, i):\\n\\n if u not in self.user_means:\\n return(np.mean([self.global_mean,\\n self.item_means[i]]))\\n\\n if i not in self.item_means:\\n return(np.mean([self.global_mean,\\n self.user_means[u]]))\\n\\n return(np.mean([self.global_mean,\\n self.user_means[u],\\n self.item_means[i]]))\",\n \"def confidence(self) -> float:\\n return float(self.class_scores[self.class_num])\",\n \"def cal_hit_gbratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n #print({d['user'].iloc[0]:d['ratings'].to_list() for i,d in top_k.groupby('user')})\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)]) for i,d in top_k.groupby('user')}\\n score_2 = {d['user'].iloc[0]:len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)]) for i,d in top_k.groupby('user')} \\n score_ratio = [(score_1[d]-score_2[d]/self._test_ratings[d]) if self._test_ratings[d]!=0 else 0 for d in self._test_ratings.keys()]\\n\\n #print(np.mean(score_ratio))\\n #print(score_1)\\n #score = score_1 + score_2\\n return np.mean(score_ratio)\",\n \"def _weight(self, user_a, user_i):\\n a_votes = self._votes[user_a]\\n i_votes = self._votes[user_i]\\n\\n a_mean = self._averages[user_a]\\n i_mean = self._averages[user_i]\\n\\n item_ndx = np.logical_and(np.isfinite(a_votes),\\n np.isfinite(i_votes))\\n\\n a_deviations = a_mean - a_votes[item_ndx]\\n i_deviations = i_mean - i_votes[item_ndx]\\n\\n numerator = np.sum(a_deviations * i_deviations)\\n denominator = (np.sum(np.power(a_deviations, 2)) *\\n np.sum(np.power(i_deviations, 2)))\\n\\n if denominator < _EPSILON:\\n return 0\\n return numerator / np.sqrt(denominator)\",\n \"def coverage(self, user_list):\\n all_recom_set = set()\\n all_item = set(self.train['movieId'].values)\\n print('\\\\nCalculated coverage: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n all_recom_set.update(recom_item)\\n print('\\\\nCoverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\\n return len(all_recom_set) / (len(all_item) * 1.0)\",\n \"def pred_for_user(self,u):\\r\\n ids=np.where(self.Y_data_n[:,0]==u)[0]\\r\\n items_rated_by_u=Y_data_n[ids,1].tolist()\\r\\n pred_ratings=[]\\r\\n for i in range(self.n_items):\\r\\n if i not in items_rated_by_u:\\r\\n pred_ratings.append(self.pred(u,i))\\r\\n return pred_ratings\",\n \"def prediction(self, user, item):\\n return self._prob_to_class(self(user, item))\",\n \"def score(self, user_idx, item_idx=None):\\n if item_idx is None:\\n if self.train_set.is_unk_user(user_idx):\\n raise ScoreException(\\n \\\"Can't make score prediction for (user_id=%d)\\\" % user_idx\\n )\\n\\n known_item_scores = self.V.dot(self.U[user_idx, :])\\n return known_item_scores\\n else:\\n if self.train_set.is_unk_user(user_idx) or self.train_set.is_unk_item(\\n item_idx\\n ):\\n raise ScoreException(\\n \\\"Can't make score prediction for (user_id=%d, item_id=%d)\\\"\\n % (user_idx, item_idx)\\n )\\n\\n user_pred = self.V[item_idx, :].dot(self.U[user_idx, :])\\n\\n user_pred = sigmoid(user_pred)\\n if self.train_set.min_rating == self.train_set.max_rating:\\n user_pred = scale(user_pred, 0.0, self.train_set.max_rating, 0.0, 1.0)\\n else:\\n user_pred = scale(\\n user_pred,\\n self.train_set.min_rating,\\n self.train_set.max_rating,\\n 0.0,\\n 1.0,\\n )\\n\\n return user_pred\",\n \"def calc_rmse(self, data):\\n res= data.score- data[['userid','itemid']].apply(lambda row:self.calc_score(row[0], row[1]),axis=1)\\n res=[el**2 for el in np.array(res)]\\n return np.sqrt(np.sum(res)/data.shape[0])\",\n \"def calc_confidence(itemsets, support_counts, N, separator=-1):\\n X = ' & '.join(sorted(itemsets[ : separator]))\\n X_and_Y = ' & '.join(sorted(itemsets))\\n\\n if X_and_Y in support_counts.keys():\\n supp_X_to_Y = support_counts[X_and_Y] / N\\n conf_X_to_Y = support_counts[X_and_Y] / support_counts[X] # supports[X] is present if supports[key] is\\n return (supp_X_to_Y, conf_X_to_Y)\\n\\n return None\",\n \"def cal_hit_ratio(self):\\n full, top_k = self._subjects, self._top_k\\n top_k = full[full['rank']<=top_k]\\n score = 0.0\\n # golden items hit in the top_K items\\n score_1 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==1.0)])) for i,d in top_k.groupby('user')])\\n score_2 = sum([(len(d[(d['item'].isin(self._test_items[d['user'].iloc[0]]))& (d['ratings']==0.0)])) for i,d in top_k.groupby('user')])\\n score = score_1 - score_2\\n return score/full['user'].nunique()\",\n \"def estimate(self, u, j):\\n if not (self.trainset.knows_user(u) and self.trainset.knows_item(j)):\\n raise PredictionImpossible('User and/or item is unknown.')\\n\\n u_ratings = self.trainset.ur[u]\\n\\n if self.weighting == 'linear':\\n weight = sum(self.freqs[i, j, self.to_index(r)] for i, r in u_ratings)\\n score = sum(self.sums[i, j, self.to_index(r)] for i, r in u_ratings)\\n return score / weight\\n\\n # self.weighting == 'log' or None\\n weights = [self.freqs[i, j, self.to_index(r)] for i, r in u_ratings]\\n reciprocals = [1 / w if w else 0 for w in weights]\\n scores = [self.sums[i, j, self.to_index(r)] for i, r in u_ratings]\\n scores = [s * w for s, w in zip(scores, reciprocals)]\\n\\n if self.weighting is None:\\n return np.mean(scores)\\n # self.weighting == 'log'\\n logs = [np.log(w + 1) if w >= 1 else 0 for w in weights]\\n return np.dot(scores, logs) / np.sum(logs)\",\n \"def item_based_prediction(self, line, rating_bd, sim_bd, item_bd):\\n def sort_by_time(pairs):\\n \\\"\\\"\\\"For each user, sort its rating records based on its datetime.\\n More specifically, if time_a > time_b,\\n then: time_a <- x, time_b <- x + 1.\\n \\\"\\\"\\\"\\n pairs = sorted(pairs, key=lambda line: line[2], reverse=False)\\n order = 0\\n out = []\\n for i in range(len(pairs)):\\n if i != 0 and pairs[i][2] == pairs[i - 1][2]:\\n out += [(pairs[i][0], pairs[i][1], order)]\\n else:\\n order += 1\\n out += [(pairs[i][0], pairs[i][1], order)]\\n return out\\n\\n def f_decay(cur, t_ui):\\n return np.exp(- self.alpha * (cur - t_ui))\\n\\n def add_decay(pairs):\\n \\\"\\\"\\\"add decay rate to the pairs.\\n Args:\\n pairs: sim * rating, sim, time\\n \\\"\\\"\\\"\\n new_pairs = sort_by_time(pairs)\\n current_time = max(map(lambda line: line[2], new_pairs)) + 1\\n final_pairs = [\\n (pair[0] * f_decay(current_time, pair[2]),\\n pair[1] * f_decay(current_time, pair[2]))\\n for pair in new_pairs]\\n return sum(map(lambda line: line[0], final_pairs)) / sum(\\n map(lambda line: line[1], final_pairs))\\n\\n def prediction(uid, pair, rating_bd, sim_bd, item_bd):\\n \\\"\\\"\\\"do the prediction. It can either add decay rate or not,\\n which is decided by `method`.\\n \\\"\\\"\\\"\\n iid, real_rating = pair[0], pair[1]\\n if iid not in sim_bd.value.keys():\\n return ()\\n iid_neighbors = [\\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\\n average_iid_rating = item_bd.value[iid][0]\\n sim_rating = []\\n for info in iid_neighbors:\\n niid, nsim, ratings = info\\n sim_rating += [\\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\\n for rating in ratings if uid in rating[0]]\\n if len(sim_rating) != 0:\\n sim_ratings = [\\n (line[1] * line[2], abs(line[1]), line[3])\\n for line in sim_rating]\\n predicted_rating_no_decay = average_iid_rating + sum(\\n map(lambda line: line[0], sim_ratings)) / sum(\\n map(lambda line: line[1], sim_ratings))\\n predicted_rating_decay = \\\\\\n average_iid_rating + add_decay(sim_ratings)\\n else:\\n predicted_rating_no_decay = average_iid_rating\\n predicted_rating_decay = average_iid_rating\\n return iid, real_rating, \\\\\\n self.bound_rating(predicted_rating_no_decay), \\\\\\n self.bound_rating(predicted_rating_decay)\\n\\n uid, pairs = line\\n return uid, [\\n prediction(uid, pair, rating_bd, sim_bd, item_bd)\\n for pair in pairs]\",\n \"def prediction(pair, uid_allneighbor_info, user_bd, uid):\\n iid, real_rating, time = pair\\n average_uid_rating = user_bd.value[uid][0]\\n sim_rating = []\\n for info in uid_allneighbor_info:\\n uid, sim, ratings = info\\n sim_rating += [\\n (rating[0], sim, rating[1] - average_uid_rating)\\n for rating in ratings if iid in rating[0]]\\n\\n if len(sim_rating) != 0:\\n sim_rating = [\\n (line[0], line[1] * line[2], abs(line[1]))\\n for line in sim_rating]\\n predicted_rating = average_uid_rating + sum(\\n map(lambda line: line[1], sim_rating)) / sum(\\n map(lambda line: line[2], sim_rating))\\n else:\\n predicted_rating = average_uid_rating\\n return iid, real_rating, self.bound_rating(predicted_rating)\",\n \"def score(self, user_idx, item_idx=None):\\n if self.variant == 'c2pf' or self.variant == 'tc2pf':\\n if item_idx is None:\\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n else:\\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n elif self.variant == 'rc2pf':\\n if item_idx is None:\\n user_pred = self.Xi * self.Theta[user_idx, :].T\\n else:\\n user_pred = self.Xi[item_idx,] * self.Theta[user_idx, :].T\\n else:\\n if item_idx is None:\\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n else:\\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n # transform user_pred to a flatten array,\\n user_pred = np.array(user_pred, dtype='float64').flatten()\\n\\n return user_pred\",\n \"def classify(user, itemName, itemVector):\\n # first find nearest neighbor\\n nearest = computeNearestNeighbor(itemName, itemVector, items)[0][1]\\n rating = users[user][nearest]\\n return rating\",\n \"def getSupport(item):\\n return float(freqSet[item]) / len(transactionList)\",\n \"def prediction_item(item_id):\\r\\n # Data preprosessing\\r\\n reader = Reader(rating_scale=(0, 5))\\r\\n load_df = Dataset.load_from_df(ratings_df, reader)\\r\\n a_train = load_df.build_full_trainset()\\r\\n\\r\\n predictions = []\\r\\n for ui in a_train.all_users():\\r\\n predictions.append(model.predict(iid=item_id, uid=ui, verbose=False))\\r\\n return predictions\",\n \"def AUC(points):\\n\\tauc = 0.0\\n\\tfor point2, point1 in zip(points[1:], points[:-1]):\\n\\t\\t#print(point2, point1)\\n\\t\\tbase = (point2[0] - point1[0]) / 100.0\\n\\t\\theight = ( (point2[1] - point1[1])/2.0 + point1[1] ) / 100.0\\n\\t\\tauc += (base*height)\\n\\treturn auc\",\n \"def predict(self, users, items):\\n self.eval()\\n users_t = torch.tensor(users, dtype=torch.int64, device=self.device)\\n items_t = torch.tensor(items, dtype=torch.int64, device=self.device)\\n\\n with torch.no_grad():\\n # scores = torch.mul(\\n # self.user_embedding(users_t), self.item_embedding(items_t)\\n # ).sum(dim=1)\\n ua_embeddings, ia_embeddings = self.forward(self.norm_adj)\\n u_g_embeddings = ua_embeddings[users_t]\\n i_g_embeddings = ia_embeddings[items_t]\\n scores = self.f(torch.mul(u_g_embeddings, i_g_embeddings).sum(dim=1))\\n return scores\",\n \"def create_user_item_array(self):\\n user_em = self.user_factors.weight.detach()\\n item_em = self.product_factors.weight.detach()\\n user_b = self.user_bias.weight.detach()\\n item_b = self.product_bias.weight.detach()\\n\\n user_item_array = (item_em + item_b) @ (user_em + user_b).transpose(0, 1)\\n preds = self._prob_to_class(user_item_array).numpy()\\n\\n return preds\",\n \"def predict(self, user, item):\\n return self.user_vectors[user, :].dot(self.item_vectors[item, :].T)\",\n \"def calculate_item_relevance_scores(self, user_similarity_profile):\\r\\n scores = user_similarity_profile.dot(self.ratings_matrix.matrix)\\r\\n return self.ratings_matrix.normalize_score_vector(scores)\",\n \"def _get_recommend(self, user):\\n return self.user_cf.calculate(target_user_id=user, user_n=self.user_n,\\n item_n=self.item_n, type=2)\",\n \"def calc_bpr_loss(\\n self, user_emd, item_emd, user_list, pos_item_list, neg_item_list\\n ):\\n u_e = user_emd[user_list]\\n pi_e = item_emd[pos_item_list]\\n ni_e = item_emd[neg_item_list]\\n p_scores = torch.mul(u_e, pi_e).sum(dim=1)\\n n_scores = torch.mul(u_e, ni_e).sum(dim=1)\\n\\n l1 = torch.sum(-F.logsigmoid(p_scores - n_scores))\\n\\n u_e_p = self.user_embedding(user_list)\\n pi_e_p = self.item_embedding(pos_item_list)\\n ni_e_p = self.item_embedding(neg_item_list)\\n\\n l2 = self.reg_loss(u_e_p, pi_e_p, ni_e_p)\\n\\n return l1 + l2 * self.reg_weight\",\n \"def compute_kappa_score(self, scorer1, scorer2, items, matrix_weights):\\r\\n #matrice nb items\\r\\n df_n_items = pd.DataFrame(data=0, index=items, columns=items)\\r\\n for score1, score2 in zip(scorer1, scorer2):\\r\\n df_n_items[score1][score2] = df_n_items[score1][score2] + 1\\r\\n #nb items * total number of scoring items\\r\\n df_proba = df_n_items / len(scorer1)\\r\\n #df_proba with weights\\r\\n df_proba_w = df_proba * matrix_weights\\r\\n #relative observed agreement among raters\\r\\n p_a = df_proba_w.sum().sum()\\r\\n #hypothetical probability of chance agreement\\r\\n p_e = 0\\r\\n for lig in df_proba.index:\\r\\n for col in df_proba.columns:\\r\\n p_e = p_e + df_proba.loc[lig, :].sum() * \\\\\\r\\n df_proba.loc[:, col].sum() * matrix_weights.loc[lig, col]\\r\\n #kappa score\\r\\n kappa = 1 - (1 - p_a) / (1 - p_e)\\r\\n return kappa\",\n \"def compute_error(data, user_features, item_features, nz):\\n sum_err = 0\\n for d, n in nz:\\n err = data[d,n] - np.dot(item_features[d,:],user_features[:,n])\\n sum_err += err**2\\n rmse = 0.5*sum_err/len(nz)\\n return rmse\",\n \"def estimate(self, item):\\n return self.A[item] if item in self.A.keys() else 0\",\n \"def predict(self, user, item):\\n pred = self.global_bias + self.user_bias[user] + self.item_bias[item]\\n pred += self.U[user, :].dot(self.I[:, item])\\n return pred\",\n \"def test_recommendation_evaluation_3(model, interactions_ds):\\n assert recommendation_evaluation(model, interactions_ds[1], cn_test_users=None, k=2, n_pos_interactions=1,\\n novelty=False) == \\\\\\n {'HitRatio@2': 0.02, 'NDCG@2': 0.0179, 'Precision@2': 0.01, 'Recall@2': 0.02}\",\n \"def calculate_pairwise_user_similarity(self, user1_preferences, user2_preferences):\\r\\n\\r\\n shared_items = set(user1_preferences.indices) & set(user2_preferences.indices)\\r\\n\\r\\n all_items = set(user1_preferences.indices) | set(user2_preferences.indices)\\r\\n\\r\\n num_agreements = sum(1 for x in shared_items if abs(user1_preferences[0, x] - user2_preferences[0, x]) <= 2)\\r\\n\\r\\n return (num_agreements / len(all_items) if len(all_items) > 0 else 0)\",\n \"def calculate_total(self, calcu_user_n=20, user_n=20, item_n=10, seed=1):\\n self._split_data(seed=seed)\\n self._set_top(user_n=user_n, item_n=item_n)\\n test_user_list = list(set(self.test['userId'].unique()))\\n user_list = [test_user_list[random.randint(0, len(test_user_list)) - 1]\\n for i in range(calcu_user_n)]\\n hit = 0 # Hit score\\n all_recom = 0 # num of all recommendations, calculate the accuracy rate\\n like_item = 0 # num of the item the user likes in the test set, calculate the recall rate\\n all_recom_set = set()\\n all_item = set(self.train['movieId'].unique())\\n item_popular = Counter(self.train['movieId'].values)\\n ret = 0\\n n = 0\\n print('\\\\nCalculate all evaluation indicators...')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user, )\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n like_item += len(user_item)\\n all_recom += len(recom_item)\\n all_recom_set.update(recom_item)\\n for rec in set([data[0] for data in recom_data]):\\n ret += math.log(1 + item_popular.get(rec))\\n n += 1\\n print('\\\\nCalculate over')\\n print('Precision is: ', hit / (all_recom * 1.0))\\n print('Recall is: ', hit / (like_item * 1.0))\\n print('Coverage is: ', len(all_recom_set) / (len(all_item) * 1.0))\\n print('Popularity is:', (ret / n * 1.0))\",\n \"def conf(self, success, total):\\n try:\\n sp = success / total\\n conf = binom_conf_interval(success, total, interval='jeffreys')\\n uperr = conf[1] - sp # 1 sigma confidence above mean\\n loerr = sp - conf[0] # 1 sigma confidence below mean\\n return sp, uperr, loerr, 0.5*(uperr+loerr)\\n except ValueError as e:\\n return 0, 0, 0, 0\",\n \"def getSupport(item):\\n # return float(freqSet[item])/len(transactionList)\\n return float(freqSet[item]) / len(dateStampSet)\",\n \"def robbins_confidence(counts, alpha=0.05):\\n s = singles(counts)\\n n = counts.sum()\\n k = sqrt((n+1)/alpha)\\n return (s-k)/(n+1), (s+k)/(n+1)\",\n \"def calc_ssl_loss(\\n self, user_list, pos_item_list, user_sub1, user_sub2, item_sub1, item_sub2\\n ):\\n\\n u_emd1 = F.normalize(user_sub1[user_list], dim=1)\\n u_emd2 = F.normalize(user_sub2[user_list], dim=1)\\n all_user2 = F.normalize(user_sub2, dim=1)\\n v1 = torch.sum(u_emd1 * u_emd2, dim=1)\\n v2 = u_emd1.matmul(all_user2.T)\\n v1 = torch.exp(v1 / self.ssl_tau)\\n v2 = torch.sum(torch.exp(v2 / self.ssl_tau), dim=1)\\n ssl_user = -torch.sum(torch.log(v1 / v2))\\n\\n i_emd1 = F.normalize(item_sub1[pos_item_list], dim=1)\\n i_emd2 = F.normalize(item_sub2[pos_item_list], dim=1)\\n all_item2 = F.normalize(item_sub2, dim=1)\\n v3 = torch.sum(i_emd1 * i_emd2, dim=1)\\n v4 = i_emd1.matmul(all_item2.T)\\n v3 = torch.exp(v3 / self.ssl_tau)\\n v4 = torch.sum(torch.exp(v4 / self.ssl_tau), dim=1)\\n ssl_item = -torch.sum(torch.log(v3 / v4))\\n\\n return (ssl_item + ssl_user) * self.ssl_weight\",\n \"def mrr(self):\\n _test = self.drop_bad_ratings()\\n merged = pd.merge(left=_test, right=self.predict, on=['user', 'item'], how='right')[\\n ['user', 'item', 'rating_x', 'rating_y']]\\n nott = np.vectorize(lambda x: not x)\\n mrrs = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user].sort_values(by='rating_y', ascending=False)\\n true_ratings = frame.rating_x.values\\n positions = np.where(nott(np.isnan(true_ratings)))[0]\\n if len(positions) > 0:\\n mrrs.append(1 / (positions[0] + 1))\\n else:\\n mrrs.append(0)\\n\\n return sum(mrrs) / len(mrrs)\",\n \"def predict(self, X):\\n \\n n_samples = X.shape[0]\\n y_pred = self.mean_rating_*np.ones(n_samples)\\n for i in np.arange(n_samples):\\n if X[i,0] < self.num_user and X[i,1] < self.num_item:\\n y_pred[i] += np.dot(self.U[X[i,0],:],self.V[X[i,1],:])\\n y_pred[i] = np.clip(y_pred[i],self.min_rating_,\\n self.max_rating_)\\n \\n return y_pred\",\n \"def itembase(user_id):\\n frame1 = pd.concat([pd.DataFrame(REVIEWS[x]) for x in REVIEWS])\\n filtered_data = recommender.filtering_not_city()\\n businesses = pd.DataFrame(filtered_data).set_index('business_id')\\n frame2 = frame1.drop_duplicates(subset=[\\\"user_id\\\", \\\"business_id\\\"], keep='last', inplace=False)\\n\\n utility_matrix = pivot_reviews(frame2)\\n\\n similarity = create_similarity_matrix_euclid(utility_matrix)\\n\\n for business in businesses.index:\\n neighborhood = select_neighborhood(similarity, utility_matrix, user_id, business)\\n prediction = weighted_mean(neighborhood, utility_matrix, user_id)\\n businesses.ix[business, 'predicted rating'] = prediction\\n\\n sorted_prediction = businesses.sort_values(by=['predicted rating'], ascending=False)\\n sorted_prediction2 = sorted_prediction.drop(columns=['predicted rating'])\\n sorted_prediction2 = sorted_prediction2.reset_index()\\n sorted_prediction3 = sorted_prediction.reset_index()\\n return sorted_prediction2.to_dict(orient='records'), sorted_prediction3.to_dict(orient='records')\",\n \"def single_user_recommendation_vector(self, user_ratings):\\r\\n\\r\\n ratings_vector = self.ratings_matrix.get_ratings_vector(user_ratings)\\r\\n\\r\\n user_similarity_profile = self.calculate_user_similarity_profile(ratings_vector)\\r\\n\\r\\n return self.calculate_item_relevance_scores(user_similarity_profile)\",\n \"def compute_user_local_sensitivity(sc, dataset, user_id, num_iters_ls):\\n\\n res = defaultdict(lambda: 0.0)\\n\\n original_recs, original_qii = compute_recommendations_and_qii(sc, dataset,\\n user_id)\\n original_recs = recommendations_to_dd(original_recs)\\n\\n res[\\\"recommendee_user_id\\\"] = user_id\\n res[\\\"recommendee_recs_l1_norm\\\"] = l1_norm(original_recs)\\n res[\\\"recommendee_qii_l1_norm\\\"] = l1_norm(original_qii)\\n res[\\\"recommendee_recs_l0_norm\\\"] = len(original_recs)\\n res[\\\"recommendee_qii_l0_norm\\\"] = len(original_qii)\\n res[\\\"perturbations\\\"] = []\\n\\n all_users = get_user_list(dataset)\\n for x in xrange(num_iters_ls):\\n if perturb_specific_user:\\n other_user_id = perturb_specific_user\\n else:\\n other_user_id = random.choice(list(set(all_users) - {user_id}))\\n print \\\"Perturbing user\\\", other_user_id, \\\"(\\\", x+1, \\\"out of\\\",\\\\\\n num_iters_ls, \\\")\\\"\\n perturbed_dataset = perturb_user_ratings(sc, dataset, other_user_id)\\n start = time.time()\\n recs, qii = compute_recommendations_and_qii(sc, perturbed_dataset, user_id)\\n stop = time.time()\\n recs = recommendations_to_dd(recs)\\n rec_ls = calculate_l1_distance(original_recs, recs)\\n qii_ls = calculate_l1_distance(original_qii, qii)\\n\\n report = {}\\n report[\\\"perturbed_user_id\\\"] = other_user_id\\n report[\\\"perturbed_recs_l1_norm\\\"] = l1_norm(recs)\\n report[\\\"perturbed_qii_l1_norm\\\"] = l1_norm(qii)\\n report[\\\"perturbed_recs_l0_norm\\\"] = len(recs)\\n report[\\\"perturbed_qii_l0_norm\\\"] = len(qii)\\n report[\\\"recs_ls\\\"] = rec_ls\\n report[\\\"qii_ls\\\"] = qii_ls\\n report[\\\"recs_ls_norm\\\"] = rec_ls/float((len(recs)*4))\\n report[\\\"qii_ls_norm\\\"] = qii_ls/float((len(qii)*4))\\n print \\\"Local sensitivity of recs: \\\", rec_ls/float((len(recs)*4))\\n print \\\"Local sensitivity of QII: \\\", qii_ls/float((len(qii)*4))\\n report[\\\"computation_time\\\"] = stop - start\\n\\n\\n res[\\\"perturbations\\\"].append(report)\\n\\n for per in res[\\\"perturbations\\\"]:\\n res[\\\"avg_recs_ls\\\"] += float(per[\\\"recs_ls\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_recs_ls\\\"] = max(res[\\\"max_recs_ls\\\"], per[\\\"recs_ls\\\"])\\n res[\\\"avg_recs_ls_norm\\\"] +=\\\\\\n float(per[\\\"recs_ls_norm\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_recs_ls_norm\\\"] = max(res[\\\"max_recs_ls_norm\\\"],\\n per[\\\"recs_ls_norm\\\"])\\n res[\\\"avg_qii_ls\\\"] += float(per[\\\"qii_ls\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_qii_ls\\\"] = max(res[\\\"max_qii_ls\\\"], per[\\\"qii_ls\\\"])\\n res[\\\"avg_qii_ls_norm\\\"] +=\\\\\\n float(per[\\\"qii_ls_norm\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_qii_ls_norm\\\"] = max(res[\\\"max_recs_qii_norm\\\"],\\n per[\\\"qii_ls_norm\\\"])\\n return dict(res)\",\n \"def _calculate_tp_confidences(images, test_class):\\n confidences = []\\n for (response_json, class_name) in predict(images, desc=f\\\"[{test_class}] inference\\\"):\\n if response_json[\\\"status\\\"] != \\\"ok\\\":\\n raise Exception(f\\\"Not OK response in {class_name}\\\")\\n if class_name == test_class and response_json[\\\"response\\\"] == class_name:\\n confidences.append(response_json[\\\"confidence\\\"])\\n return confidences\",\n \"def _calculate_fp_confidences(images, test_classes):\\n confidences = []\\n for (response_json, class_name) in predict(images, desc=f\\\"[{BACKGROUND}] inference\\\"):\\n if response_json[\\\"status\\\"] != \\\"ok\\\":\\n raise Exception(f\\\"Not OK response in {class_name}\\\")\\n if response_json[\\\"response\\\"] in test_classes:\\n confidences.append(response_json[\\\"confidence\\\"])\\n return confidences\",\n \"def calculate_error_rates(point_to_weight, classifier_to_misclassified):\\n ans = {}\\n for c in classifier_to_misclassified:\\n misclassified = classifier_to_misclassified[c]\\n ans[c] = 0\\n for p in misclassified:\\n ans[c] += point_to_weight[p]\\n return ans\",\n \"def stdConfidenceTrades(predictions, buy_confidence=1.5, sell_confidence=1.1):\\n smooth_preds = pd.Series(predictions).rolling(5).mean()\\n buy_thresh = np.mean(smooth_preds) + buy_confidence * np.std(smooth_preds)\\n sell_thresh = np.mean(smooth_preds) - sell_confidence * np.std(smooth_preds)\\n buy_positions = np.where(predictions > buy_thresh)[0]\\n sell_positions = np.where(predictions < sell_thresh)[0]\\n \\n buys = buy_positions\\n sells = []\\n curSell = 0\\n for curBuy in buys:\\n arr = np.where(sell_positions > curBuy)[0]\\n if len(arr):\\n sells.append(sell_positions[arr[0]])\\n tradePairs = list(zip(buys, sells))\\n return tradePairs\",\n \"def cre_confidence1(df):\\r\\n func = lambda x: 1 - np.abs(x.mean())\\r\\n return df.groupby('creline')['ffb_c'].transform(func)\",\n \"def obscurity(user):\\n reader = open(\\\"similarities.txt\\\", \\\"r\\\")\\n lines = reader.readlines()\\n obscurity = 0.0\\n count = 0\\n for line in lines:\\n a, b, sim = line.split(\\\"\\\\t\\\")\\n if user == a:\\n count += 1\\n obscurity += float(sim)\\n\\n obscurity /= count\\n return obscurity\",\n \"def probability(self, item):\\n count = self.counter.get(item, 0)\\n if self.smoothing_dict:\\n smooth_count = self.smoothing_dict.get(count, count)\\n assert smooth_count > 0\\n return smooth_count / self.smooth_total\\n else:\\n return count / self.total\",\n \"def weighted_average(items, weights):\\n assert len(items) > 0\\n assert len(items) == len(weights)\\n # declare total as the return value which is a decimal\\n total = 0.0\\n # for all pairs from two lists\\n for i in range(len(items)):\\n \\t# we increment the total for the product of both value\\n \\ttotal += items[i] * weights[i]\\n # we return the total divided by sum of weights\\n return total / sum(weights)\",\n \"def recall(self, user_list):\\n hit = 0\\n like_item = 0\\n print('\\\\nCalculate recall: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n like_item += len(user_item)\\n print('\\\\nrecall is: ', hit / (like_item * 1.0))\\n return hit / (like_item * 1.0)\",\n \"def decision_function(self, user_id=0):\\n if user_id != 0:\\n cls_scores, class_ids = self.__decision_function\\n try:\\n index = np.where(class_ids == user_id)\\n return cls_scores[index]\\n except:\\n return -self.__decision_nr_samples\\n else:\\n return self.__decision_function\",\n \"def score_method(pairs_true, pairs_test):\\n \\n set_true = {tuple(e) for e in pairs_true}\\n set_test = {tuple(e) for e in pairs_test}\\n true_pos, false_pos, false_neg = confusion_stats(set_true, set_test)\\n \\n total = true_pos + false_pos + false_neg\\n true_pos_rate = true_pos / total\\n false_pos_rate = false_pos / total\\n false_neg_rate = false_neg / total\\n \\n return true_pos_rate, false_pos_rate, false_neg_rate\",\n \"def user_interaction_score(uv, recommended_News, ranked=True):\\n\\n iv = recommended_News[\\\"topical_vector\\\"]\\n\\n product = simple_doct_product(uv, iv)\\n\\n epsilon = 10e-5\\n\\n if (product + epsilon) > 1.0:\\n vui = 0.99\\n else:\\n vui = beta_distribution(product)\\n\\n # Awared preference\\n ita = beta_distribution(0.98)\\n pui = vui * ita\\n\\n return pui\",\n \"def user_based_prediction(self, line, rating_bd, sim_bd, user_bd):\\n def prediction(pair, uid_allneighbor_info, user_bd, uid):\\n \\\"\\\"\\\"do the prediction. It can either add decay rate or not,\\n which is decided by `method`.\\n Args:\\n pair: (iid, rating, time)\\n uid_allneighbor_info: (uid, sim, rating_record)*\\n average_uid: average rating of current uid.\\n \\\"\\\"\\\"\\n iid, real_rating, time = pair\\n average_uid_rating = user_bd.value[uid][0]\\n sim_rating = []\\n for info in uid_allneighbor_info:\\n uid, sim, ratings = info\\n sim_rating += [\\n (rating[0], sim, rating[1] - average_uid_rating)\\n for rating in ratings if iid in rating[0]]\\n\\n if len(sim_rating) != 0:\\n sim_rating = [\\n (line[0], line[1] * line[2], abs(line[1]))\\n for line in sim_rating]\\n predicted_rating = average_uid_rating + sum(\\n map(lambda line: line[1], sim_rating)) / sum(\\n map(lambda line: line[2], sim_rating))\\n else:\\n predicted_rating = average_uid_rating\\n return iid, real_rating, self.bound_rating(predicted_rating)\\n\\n uid, pairs = line\\n uid_allneighbor_info = [\\n (u[0], u[1], rating_bd.value[u[0]]) for u in sim_bd.value[uid]]\\n return uid, [prediction(\\n pair, uid_allneighbor_info, user_bd, uid) for pair in pairs]\",\n \"def estimate_user_biases(self):\\n self.user_biases = {}\\n for user in self.user_ratings:\\n # b_u = sum(r_ui - mu - b_i) / len(R(u))\\n user_bias = [rating - self.global_mean - self.movie_biases[movie]\\n for movie, rating in self.user_ratings[user].items()]\\n user_bias = sum(user_bias) / len(user_bias)\\n self.user_biases[user] = user_bias\",\n \"def ndpm(self):\\n\\n merged = pd.merge(left=self.test, right=self.predict, on=['user', 'item'], how='inner')[\\n ['user', 'rating_x', 'rating_y']]\\n ndpms = []\\n for user in merged.user.unique():\\n frame = merged[merged.user == user]\\n if frame.shape[0] <= 1:\\n continue\\n C_plus = self.num_of_ordered_positive(frame, 'rating_x', 'rating_y')\\n C_minus = self.num_of_ordered_negative(frame, 'rating_x', 'rating_y')\\n C_u = self.num_of_ordered(frame, 'rating_x')\\n if C_u == 0:\\n continue\\n C_s = self.num_of_ordered(frame, 'rating_y')\\n C_u0 = C_u - (C_plus + C_minus)\\n ndpms.append(1 - (C_minus + 0.5 * C_u0) / C_u)\\n\\n return sum(ndpms) / len(ndpms)\",\n \"def evaluate(topk_matches, test_user_products, num_recommendations, brand_dict):\\n invalid_users = []\\n # Compute metrics\\n precisions, recalls, ndcgs, hits, fairness = [], [], [], [], []\\n test_user_idxs = list(test_user_products.keys())\\n for uid in test_user_idxs:\\n if uid not in topk_matches or len(topk_matches[uid]) < num_recommendations:\\n invalid_users.append(uid)\\n continue\\n pred_list, rel_set = topk_matches[uid][::-1], test_user_products[uid]\\n if len(pred_list) == 0:\\n continue\\n\\n dcg = 0.0\\n hit_num = 0.0\\n for i in range(len(pred_list)):\\n if pred_list[i] in rel_set:\\n dcg += 1. / (log(i + 2) / log(2))\\n hit_num += 1\\n # idcg\\n idcg = 0.0\\n for i in range(min(len(rel_set), len(pred_list))):\\n idcg += 1. / (log(i + 2) / log(2))\\n ndcg = dcg / idcg\\n recall = hit_num / len(rel_set)\\n precision = hit_num / len(pred_list)\\n hit = 1.0 if hit_num > 0.0 else 0.0\\n\\n ndcgs.append(ndcg)\\n recalls.append(recall)\\n precisions.append(precision)\\n hits.append(hit)\\n fairness.append(calculate_fairness(pred_list, brand_dict))\\n\\n avg_precision = np.mean(precisions) * 100\\n avg_recall = np.mean(recalls) * 100\\n avg_ndcg = np.mean(ndcgs) * 100\\n avg_hit = np.mean(hits) * 100\\n avg_fairness = np.mean(fairness)\\n print('NDCG={:.3f} | Recall={:.3f} | HR={:.3f} | Precision={:.3f} | Fairness={:.3f} | Invalid users={}'.format(\\n avg_ndcg, avg_recall, avg_hit, avg_precision, avg_fairness, len(invalid_users)))\",\n \"def confidence(self) -> float:\\n return self._confidence\",\n \"def get_overall_score(self, user):\\n\\n quizzes = ['iq', 'math', 'english']\\n\\n prev_scores = []\\n new_scores = []\\n\\n for quiz in quizzes:\\n quiz_obj = self.get_object(quiz)\\n queryset = self.get_queryset(user, quiz_obj)\\n\\n try:\\n new_scores.append(queryset[0].marks)\\n prev_scores.append(queryset[1].marks)\\n except:\\n new_scores.append(queryset[0].marks)\\n prev_scores.append(0)\\n\\n import statistics\\n\\n return statistics.mean(prev_scores), statistics.mean(new_scores)\",\n \"def calc_confidence(raw_output, labels_list=None):\\n #print(\\\"raw_output:\\\", raw_output)\\n result = raw_output\\n probs = []\\n for dc in result:\\n for key in dc:\\n #print(\\\"dc:\\\", dc)\\n #print(\\\"key:\\\", key)\\n logits = dc[key]\\n logit = logits[0]\\n ps = softmax_probabilities(logit)\\n max_ps = max(ps)\\n index = np.argmax(ps)\\n probs.append(max_ps)\\n #print('max_ps:', max_ps)\\n #print('index:', index)\\n #if labels_list:\\n # print('tag:', labels_list[index])\\n return probs\",\n \"def evaluate(self, dataloader):\\n squared_loss = 0\\n correct = 0\\n total = 0\\n\\n self.eval()\\n with torch.no_grad():\\n for user, item, rating in dataloader:\\n forward = self(user, item)\\n predicted = self._prob_to_class(forward)\\n\\n squared_loss += self.loss(forward, rating).item() * len(user)\\n total += predicted.numel()\\n correct += (predicted == rating.view(-1)).sum().item()\\n\\n mean_loss = squared_loss / total\\n\\n return mean_loss, f\\\"{(100 * correct / total):.2f}\\\"\",\n \"def ap(self, result, next_item):\\n if next_item in result.index:\\n rank = result.index.get_loc(next_item) + 1\\n return 1.0 / rank\\n else:\\n return 0\",\n \"def calcUserMeanRating(userRatingGroup):\\n userID = userRatingGroup[0]\\n ratingSum = 0.0\\n ratingCnt = len(userRatingGroup[1])\\n if ratingCnt == 0:\\n return (userID, 0.0)\\n for item in userRatingGroup[1]:\\n ratingSum += item[1]\\n return (userID, 1.0 * ratingSum / ratingCnt)\",\n \"def make_predictions(movies, ratings_train, ratings_test):\\n ###TODO\\n \\n user_result = [] \\n \\n for index,row in ratings_test.iterrows():\\n userid_test = row['userId']\\n #print(\\\"userid_test::\\\",userid_test) \\n movieid_test = row['movieId'] \\n #print(\\\"movieid_test::\\\",movieid_test) \\n x = list(movies[movies.movieId==movieid_test]['features'])[0]\\n #print(\\\"CSR_GOTT+X::\\\",x)\\n #print(\\\"TYPE of CSR_GOTT_X::\\\",type(x))\\n subset_train = ratings_train[ratings_train.userId == userid_test]\\n #print(\\\"SUB MOVIE SET::\\\",subset_train)\\n #print(\\\"TYPE of SUB MOVIE SET::\\\",type(x))\\n total_if_zero=0\\n rating_if_zero=0\\n sum_main_result=0\\n sum_cosine=0 \\n for index1,row1 in subset_train.iterrows():\\n userid_train = row1['userId']\\n #print(\\\"userid_train::\\\",userid_train) \\n if(userid_test == userid_train ):\\n #print(\\\"HII IN IFFF:::\\\")\\n movieid_train = row1['movieId']\\n #print(\\\"movieid_train::\\\",movieid_train)\\n rating_train = row1['rating']\\n #print(\\\"rating_train::\\\",rating_train)\\n total_if_zero = total_if_zero + 1 \\n rating_if_zero = rating_if_zero + rating_train\\n y = list(movies[movies.movieId==movieid_train]['features'])[0]\\n #print(\\\"CSR_GOTT_Y::\\\",y)\\n #print(\\\"TYPE of CSR_GOTT_Y::\\\",type(y))\\n result_cos = cosine_sim(x,y)\\n sum_main_result += result_cos * rating_train\\n sum_cosine += result_cos \\n \\n if(sum_main_result != 0):\\n user_result.append(sum_main_result/sum_cosine)\\n #print(\\\"user_result::\\\",user_result) \\n else:\\n user_result.append(rating_if_zero / total_if_zero)\\n #print(\\\"user_result::\\\",user_result) \\n \\n return_result_arr = np.array(user_result) \\n \\n return return_result_arr\\n \\n pass\",\n \"def get_correct(self, predicted, actual):\\n ret_ratios = [np.sum(predicted == actual) / len(actual)]\\n for i in range(2):\\n actual_ones = np.where(actual == i)[0]\\n should_be_ones = np.take(predicted, actual_ones)\\n actual_ones = np.take(actual, actual_ones)\\n ret_ratios.append(np.sum(should_be_ones == actual_ones) / len(actual_ones))\\n\\n return tuple(ret_ratios)\",\n \"def compute_average_user_ratings(user_ratings):\\n ave_ratings = {}\\n \\n for user,value in user_ratings.items():\\n sum = 0\\n movie_num=0\\n for movieId, rating in value.items():\\n sum += float(rating)\\n movie_num += 1\\n average = sum / movie_num\\n ave_ratings[user]=average\\n return ave_ratings\",\n \"def CF_item_predict(train_data_matrix: csr_matrix):\\n logging.getLogger(__name__).info(\\\"Begin to calculate similarity of CF item-item based!\\\")\\n train_data_matrix = train_data_matrix.A\\n item_similarity = cosine_similarity(train_data_matrix.T)\\n logging.getLogger(__name__).info(\\\"Begin to predict based on CF item-item!\\\")\\n item_prediction = predict(train_data_matrix, item_similarity, type='item')\\n return item_prediction\",\n \"def predict_proba_confidence(clf, X, y_true):\\n class_labels = clf.classes_\\n y_pred_proba = clf.predict_proba(X)[:,1]\\n ent = [entropy(i) for i in y_pred_proba]\\n\\n return sum(ent)/len(ent)\",\n \"def mutual_info_score(self):\\n _, _, I_CK = self._entropies()\\n return I_CK / self.grand_total\",\n \"def probabilities_score(model_id, test_set_id, rubric_id):\\n result = {'true_average_probability': 0, 'false_average_probability': 0}\\n # right answers\\n answers = db.get_rubric_answers(test_set_id, rubric_id)\\n # rubrication results\\n rubrication_result = db.get_rubrication_probability(model_id, test_set_id, rubric_id)\\n\\n true_number = 0\\n true_probability = 0\\n false_number = 0\\n false_probability = 0\\n\\n for key in rubrication_result:\\n if answers[key]:\\n true_number += 1\\n true_probability += rubrication_result[key]\\n else:\\n false_number +=1\\n false_probability += rubrication_result[key]\\n\\n if true_number:\\n result['true_average_probability'] = true_probability / true_number\\n\\n if false_number:\\n result['false_average_probability'] = false_probability / false_number\\n\\n return result\",\n \"def get_similarity(user1: Rating, user2: Rating) -> float:\\n shared = 0.0\\n for m_id in user1:\\n if m_id in user2:\\n shared += user1[m_id] * user2[m_id]\\n norm1 = 0.0\\n for m_id in user1:\\n norm1 = norm1 + user1[m_id] ** 2\\n norm2 = 0.0\\n for m_id in user2:\\n norm2 = norm2 + user2[m_id] ** 2\\n return (shared * shared) / (norm1 * norm2)\",\n \"def standardize_sim_values(self):\\n for user_id_A, row in self.sim_matrix.items(): # row is reference\\n lA = len(self.users[user_id_A].covered_items)\\n for user_id_B in row.keys():\\n lB = len(self.users[user_id_B].covered_items)\\n row[user_id_B] /= sqrt(lA*lB)\\n assert row[user_id_B] <= 1\",\n \"def _build_user_model(self, user_ids):\\n res_dict = {}\\n for user_id in user_ids:\\n specific_user_log = self._user_log[self._user_log['user_id'] == user_id]\\n log_vecs = pd.merge(specific_user_log, self._item_vector, how='left', on=['item_id'])\\n assert (sum(log_vecs['vec'].notnull()) == log_vecs.shape[0]), 'Item vector sheet has null values'\\n res_dict[user_id] = ContentBasedAlgo._calc_dim_average(np.array(log_vecs['vec'].values.tolist()))\\n return res_dict\",\n \"def user_based_recommendation(\\n self, test_dataRDD,\\n user_based_dict_bd, userbased_sim_pair_dict_bd, user_info_bd):\\n sim_pair_dict_keys = set(userbased_sim_pair_dict_bd.value.keys())\\n return test_dataRDD.filter(\\n lambda line: line[0] in sim_pair_dict_keys).map(\\n lambda line: self.user_based_prediction(\\n line, user_based_dict_bd,\\n userbased_sim_pair_dict_bd, user_info_bd))\",\n \"def prec_recall_f1_score(pred_items, gold_items):\\n common = Counter(gold_items) & Counter(pred_items)\\n num_same = sum(common.values())\\n if num_same == 0:\\n return 0\\n precision = 1.0 * num_same / len(pred_items)\\n recall = 1.0 * num_same / len(gold_items)\\n f1 = (2 * precision * recall) / (precision + recall)\\n return f1\",\n \"def calculate_penalty(self):\\n if AT.PENALTY not in self.attributes:\\n return (0, 1)\\n return self.attributes[AT.PENALTY].calculate(self)\",\n \"def surprisal(self, item):\\n return - math.log(self.probability(item))\",\n \"def prediction():\\r\\n\\r\\n\\r\\n\\tpredictVal = []\\r\\n\\taccuracy = 0.0\\r\\n\\r\\n\\t# Calculate accuracy for each class in testData\\r\\n\\tfor item in testData:\\r\\n\\t\\tclass0Prediction = posProb / 100\\r\\n\\t\\tclass1Prediction = negProb / 100\\r\\n\\t\\t\\r\\n\\t\\t# Multiply the prior probablities for negative and positive reviews by their feature likelihoods \\r\\n\\t\\tfor word in item[2]:\\r\\n\\t\\t\\tclass0Prediction *= class0Dict[word]\\r\\n\\t\\t\\tclass1Prediction *= class1Dict[word]\\r\\n\\r\\n\\t\\t# Give every item in testData a predicted value\\r\\n\\t\\tif(class0Prediction > class1Prediction):\\r\\n\\t\\t\\tpredictVal.append('0')\\r\\n\\t\\telse:\\r\\n\\t\\t\\tpredictVal.append('1')\\r\\n\\r\\n\\tfor i in range(len(testData)):\\r\\n\\t\\tif(testData[i][1] == predictVal[i]):\\r\\n\\t\\t\\taccuracy += 1\\r\\n\\r\\n\\t\\t\\t\\r\\n\\taccuracy = 100 * (accuracy / len(testData))\\r\\n\\treturn(predictVal, accuracy)\",\n \"def predictRating(toPredict, candidateList):\\n\\n ratingRelevantCandidates = []\\n\\n #Remove candidates with no rating specified\\n for candidate in candidateList:\\n currentCandidate = candidate[1]\\n\\n if float(currentCandidate['vote_avg']) > 0:\\n ratingRelevantCandidates.append((float(currentCandidate['vote_avg']), candidate))\\n\\n #print(\\\"ratings::::::::\\\",currentCandidate['vote_avg'])\\n\\n #Remove outlier candidates based on rating\\n ratingMean = np.mean([x[0] for x in ratingRelevantCandidates])\\n print(\\\"ratingMean\\\", ratingMean)\\n ratingSD = np.std([x[0] for x in ratingRelevantCandidates])\\n print(\\\"ratingSD\\\", ratingSD)\\n\\n finalRatings = [x for x in ratingRelevantCandidates if (float(x[0]) < ratingMean + ratingSD)]#1.5 *\\n finalRatings = [x for x in finalRatings if (float(x[0]) > ratingMean - ratingSD)]#.75 *\\n\\n finalRatingCandidatesWithWeight = []\\n\\n #Weight each candidate based on vote count, direct and actor popularity and matching score from part 1\\n for candidate in finalRatings:\\n directorPoints = compareDirectorPoints(toPredict['director'], candidate[1][1]['director'])\\n actorPoints = compareActorPoints(toPredict['cast'], candidate[1][1]['cast'])\\n voteCountPoints = int(candidate[1][1]['vote_count'])\\n matchPoints = candidate[1][0] / np.max([float(x[1][0]) for x in finalRatings]) * 100\\n candidateWeight = PREDICTION_MATCHPOINTS_WEIGHT * matchPoints \\\\\\n + PREDICTION_ACTOR_WEIGHT * actorPoints \\\\\\n + PREDICTION_DIRECTOR_WEIGHT * directorPoints \\\\\\n + PREDICTION_VOTECOUNT_WEIGHT * voteCountPoints\\n\\n finalRatingCandidatesWithWeight.append((candidateWeight, candidate[0]))\\n\\n #Calculate the prediction\\n sumRatingCandidateWeights = np.sum([float(x[0]) for x in finalRatingCandidatesWithWeight])\\n sumRatingTimesCandidateWeight = np.sum([float(x[0]) * float(x[1]) for x in finalRatingCandidatesWithWeight])\\n\\n ratingPrediction = float(sumRatingTimesCandidateWeight / sumRatingCandidateWeights)\\n\\n return ratingPrediction\",\n \"def calculate_metrics(predictions, expected):\\n # type: (np.ndarray, np.ndarray) -> (float, float, float)\\n clients_count = predictions.shape[0]\\n products_count = predictions.shape[1]\\n\\n true_positive = 0.0\\n true_negative = 0.0\\n false_positive = 0.0\\n false_negative = 0.0\\n\\n total = float(clients_count * products_count)\\n\\n for c in range(0, clients_count):\\n for p in range(0, products_count):\\n if predictions[c, p] == expected[c, p]:\\n if predictions[c, p] == 1:\\n true_positive += 1\\n else:\\n true_negative += 1\\n else:\\n if predictions[c, p] == 1:\\n false_positive += 1\\n else:\\n false_negative += 1\\n\\n accuracy = float(true_positive + true_negative) / total\\n if true_positive + false_positive == 0:\\n precision = 0\\n else:\\n precision = true_positive / float(true_positive + false_positive)\\n\\n if true_positive + false_negative == 0:\\n recall = 0\\n else:\\n recall = true_positive / float(true_positive + false_negative)\\n\\n return accuracy, precision, recall\",\n \"def calc_probabilities(applications):\\n sum_advantage = sum(app.get_advantage() for app in applications)\\n return [app.get_advantage() / sum_advantage for app in applications]\",\n \"def precision_and_recall_k(model, user_dict, item_dict, train_user_list, test_user_list, klist, batch=256):\\n # get all user emd and item emd\\n user_emb, item_emb, umap, imap = prepare_user_item_emd(model, user_dict, item_dict)\\n user_emb = user_emb.detach().cpu()\\n item_emb = item_emb.detach().cpu()\\n\\n # Calculate max k value\\n max_k = max(klist)\\n\\n # Compute all pair of training and test record\\n result = None\\n for i in range(0, user_emb.shape[0], batch):\\n # Create already observed mask\\n mask = user_emb.new_ones([min([batch, user_emb.shape[0] - i]), item_emb.shape[0]])\\n for j in range(batch):\\n if i + j >= user_emb.shape[0]:\\n break\\n items_idx = train_user_list[i + j]\\n if (items_idx != []):\\n emd_index = [imap[i] for i in items_idx]\\n mask[j].scatter_(dim=0, index=t.tensor(list(emd_index)), value=t.tensor(0.0))\\n # Calculate prediction value\\n\\n cur_result = t.mm(user_emb[i:i + min(batch, user_emb.shape[0] - i), :], item_emb.t())\\n cur_result = t.sigmoid(cur_result)\\n assert not t.any(t.isnan(cur_result))\\n # Make zero for already observed item\\n cur_result = t.mul(mask, cur_result)\\n _, cur_result = t.topk(cur_result, k=max_k, dim=1)\\n result = cur_result if result is None else t.cat((result, cur_result), dim=0)\\n\\n result = result.cpu()\\n # Sort indice and get test_pred_topk\\n precisions, recalls = [], []\\n for k in klist:\\n precision, recall = 0, 0\\n for i in range(user_emb.shape[0]):\\n test = set(test_user_list[i])\\n pred = set(result[i, :k].numpy().tolist())\\n val = len(test & pred)\\n precision += val / max([min([k, len(test)]), 1])\\n recall += val / max([len(test), 1])\\n precisions.append(precision / user_emb.shape[0])\\n recalls.append(recall / user_emb.shape[0])\\n return precisions, recalls\",\n \"def runApriori(data_iter, minSupport, minConfidence):\\n itemSet, transactionList = getItemSetTransactionList(data_iter)\\n freqSet = defaultdict(int)\\n largeSet = dict()\\n# Global dictionary which stores (key=n-itemSets,value=support)\\n# which satisfy minSupport\\n assocRules = dict()\\n# Dictionary which stores Association Rules\\n oneCSet = returnItemsWithMinSupport(itemSet,\\n transactionList,\\n minSupport,\\n freqSet)\\n currentLSet = oneCSet\\n k = 2\\n while(currentLSet != set([])):\\n largeSet[k-1] = currentLSet\\n currentLSet = joinSet(currentLSet, k)\\n currentCSet = returnItemsWithMinSupport(currentLSet,\\n transactionList,\\n minSupport,\\n freqSet)\\n currentLSet = currentCSet\\n k = k + 1\\n\\n\\n def getSupport(item):\\n \\\"\\\"\\\"local function which Returns the support of an item\\\"\\\"\\\"\\n return float(freqSet[item]) / len(transactionList)\\n toRetItems = []\\n for key, value in largeSet.items():\\n toRetItems.extend([(tuple(item), getSupport(item))\\n for item in value])\\n toRetRules = []\\n for key, value in largeSet.items()[1:]:\\n for item in value:\\n _subsets = map(frozenset, [x for x in subsets(item)])\\n for element in _subsets:\\n remain = item.difference(element)\\n if len(remain) > 0:\\n confidence = getSupport(item) / getSupport(element)\\n if confidence >= minConfidence:\\n toRetRules.append(((tuple(element), tuple(remain)),\\n confidence))\\n return toRetItems, toRetRules\",\n \"def get_final_score(self, user):\\n\\n iq_subject_score = self.get_overall_score(user=user)\\n\\n try:\\n speech_score = UserQuizMark.objects.filter(user=user, quiz=self.get_object('speech_training')).latest(\\n 'timestamp').marks\\n drawing_score = UserQuizMark.objects.filter(user=user, quiz=self.get_object('drawing')).latet(\\n 'timestamp').marks\\n except UserQuizMark.DoesNotExist:\\n raise Http404\\n\\n avg_speech_drawing_score = speech_score + drawing_score\\n\\n return (iq_subject_score + avg_speech_drawing_score) / 2\",\n \"def confidence(self):\\n return self._confidence\",\n \"def confidence(self):\\n return self._confidence\",\n \"def calculate_profit(self):\",\n \"def classProbs(observation, tree, classes):\\n res = classify(observation, tree) #res = results\\n total = sum(res.values())\\n probs = []\\n for c in classes:\\n if c in res.keys():\\n probs.append(float(res[c])/total)\\n else:\\n probs.append(0)\\n return probs\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6476335","0.6331386","0.6273888","0.62594044","0.62203914","0.6011443","0.58879673","0.58871895","0.58729005","0.58711815","0.582148","0.57926047","0.57851225","0.5779903","0.57435066","0.5729716","0.5727403","0.57262325","0.56652945","0.5631243","0.5606004","0.55863273","0.5575825","0.5567298","0.55563915","0.55298156","0.5524738","0.5513865","0.55011195","0.54940677","0.5490233","0.54680383","0.5458408","0.5444532","0.54409534","0.5428717","0.53974956","0.5388125","0.5382578","0.5376942","0.5376332","0.5352854","0.53489393","0.5326687","0.53149056","0.52835125","0.52819353","0.5281739","0.52793497","0.5235703","0.52348727","0.5217693","0.52168936","0.5207541","0.52046466","0.51921827","0.51912487","0.5190546","0.5188543","0.5187897","0.5171303","0.5166009","0.51519424","0.5151301","0.5132136","0.51312673","0.5130951","0.51308686","0.5130636","0.511869","0.51185876","0.511847","0.5110344","0.510806","0.51024896","0.5101832","0.5099396","0.509473","0.50895804","0.50865966","0.50834215","0.5083275","0.5082051","0.50801057","0.50781155","0.5077338","0.50733185","0.507178","0.5065903","0.5063173","0.50595987","0.50484115","0.50463843","0.5042974","0.50404656","0.50363314","0.503613","0.503613","0.50351405","0.50321203"],"string":"[\n \"0.6476335\",\n \"0.6331386\",\n \"0.6273888\",\n \"0.62594044\",\n \"0.62203914\",\n \"0.6011443\",\n \"0.58879673\",\n \"0.58871895\",\n \"0.58729005\",\n \"0.58711815\",\n \"0.582148\",\n \"0.57926047\",\n \"0.57851225\",\n \"0.5779903\",\n \"0.57435066\",\n \"0.5729716\",\n \"0.5727403\",\n \"0.57262325\",\n \"0.56652945\",\n \"0.5631243\",\n \"0.5606004\",\n \"0.55863273\",\n \"0.5575825\",\n \"0.5567298\",\n \"0.55563915\",\n \"0.55298156\",\n \"0.5524738\",\n \"0.5513865\",\n \"0.55011195\",\n \"0.54940677\",\n \"0.5490233\",\n \"0.54680383\",\n \"0.5458408\",\n \"0.5444532\",\n \"0.54409534\",\n \"0.5428717\",\n \"0.53974956\",\n \"0.5388125\",\n \"0.5382578\",\n \"0.5376942\",\n \"0.5376332\",\n \"0.5352854\",\n \"0.53489393\",\n \"0.5326687\",\n \"0.53149056\",\n \"0.52835125\",\n \"0.52819353\",\n \"0.5281739\",\n \"0.52793497\",\n \"0.5235703\",\n \"0.52348727\",\n \"0.5217693\",\n \"0.52168936\",\n \"0.5207541\",\n \"0.52046466\",\n \"0.51921827\",\n \"0.51912487\",\n \"0.5190546\",\n \"0.5188543\",\n \"0.5187897\",\n \"0.5171303\",\n \"0.5166009\",\n \"0.51519424\",\n \"0.5151301\",\n \"0.5132136\",\n \"0.51312673\",\n \"0.5130951\",\n \"0.51308686\",\n \"0.5130636\",\n \"0.511869\",\n \"0.51185876\",\n \"0.511847\",\n \"0.5110344\",\n \"0.510806\",\n \"0.51024896\",\n \"0.5101832\",\n \"0.5099396\",\n \"0.509473\",\n \"0.50895804\",\n \"0.50865966\",\n \"0.50834215\",\n \"0.5083275\",\n \"0.5082051\",\n \"0.50801057\",\n \"0.50781155\",\n \"0.5077338\",\n \"0.50733185\",\n \"0.507178\",\n \"0.5065903\",\n \"0.5063173\",\n \"0.50595987\",\n \"0.50484115\",\n \"0.50463843\",\n \"0.5042974\",\n \"0.50404656\",\n \"0.50363314\",\n \"0.503613\",\n \"0.503613\",\n \"0.50351405\",\n \"0.50321203\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.50412726"},"document_rank":{"kind":"string","value":"94"}}},{"rowIdx":4995,"cells":{"query":{"kind":"string","value":"calculate the preference of each useritem pair"},"document":{"kind":"string","value":"def cal_preference(dat):\n\n\tpreference = np.ones(dat.shape)\n\tpreference[dat == 0] = 0\n\treturn np.matrix(preference)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _predict_user_item(self, user, item):\n if not isinstance(user, int):\n user = self._user_to_ndx[user]\n if not isinstance(item, int):\n item = self._item_to_ndx[item]\n\n try:\n rating_mean = self._averages[user]\n except AttributeError:\n raise RuntimeError('Must fit before predicting')\n\n other_users = [other for other in self._users if other != user and\n np.isfinite(self._votes[other][item])]\n weights = np.array([self._weight(user, other)\n for other in other_users])\n deviations = np.array([self._votes[other][item] - self._averages[other]\n for other in other_users])\n\n weight_sum = np.sum(np.absolute(weights))\n if weight_sum < _EPSILON:\n return rating_mean # No similar users, so guess their avg rating\n\n norm_const = 1 / weight_sum\n\n weighted_avg = np.sum(weights * deviations)\n return rating_mean + norm_const * weighted_avg","def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\n active_user = actives[0][0]\n active_item = actives[0][1]\n\n # -----------------------------------\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\n\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\n return (active_user, active_item), 2.5\n\n # all user, ratings that have rated active_item\n if active_item in train_rdd_gbitem_dict:\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\n else:\n # item not found in training set\n # new item problem.\n average_of_user_list = train_rdd_gbuser_dict[active_user]\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\n return (active_user, active_item), average_of_user\n\n # user rated items - all (item, ratings) that the user has rated\n if active_user in train_rdd_gbuser_dict:\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\n else:\n # user not found in training set\n # new user problem.\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\n\n similarity_list = []\n for item, rating in active_user_rated_items:\n item_dict = dict(train_rdd_gbitem_dict[item][0])\n item_avg = train_rdd_gbitem_dict[item][1]\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\n similarity_list.append((rating, similarity))\n\n # Have obtained similarity list for active item and item from the above code.\n # Filter according to a top 'N' items and then take avg rating.\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\n # similarity_list = similarity_list[:len(similarity_list) // 4]\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\n # print(similarity_list)\n pred_rating = find_weighted_average(similarity_list, num_items)\n\n # for i in similarity_list:\n # print(i)\n # print(\"Pred-rating: \", pred_rating)\n\n return (active_user, active_item), pred_rating","def predict_rating(user_id,item_id):\n user_preference = latent_user_preferences[user_id]\n item_preference = latent_item_features[item_id]\n return user_preference.dot(item_preference)","def compute_user_user_sim_base_on_common_items(self):\n self.sim_matrix = {}\n for item in self.items.values():\n # convert to list of tuples for indexing\n users = list(item.covered_users.items())\n item_popularity = len(users)\n # iter through all user pairs\n for i in range(len(users)-1):\n for j in range(i+1, len(users)):\n user_A_info, user_B_info = users[i], users[j]\n # remember to update pair wise!\n self.update_user_user_sim(user_A_info, user_B_info,\n item_popularity)\n self.update_user_user_sim(user_B_info, user_A_info,\n item_popularity)","def predict_rating(self, user_id, item_id):\n user_preference = self.latent_user_preferences[user_id]\n item_feature = self.latent_item_features[item_id]\n return user_preference.dot(item_feature)","def predict(self, user_id, item_id):\n # DONEreturn prediction for given pair\n return self._user_factors[user_id, : ].dot(self._item_factors[item_id, :])","def item_based_recommend(user_id, user_item_time_dict, item2item_sim, sim_item_topk, recall_item_num, item_topk_click):\n \n # fetch the user's history clicks\n hist_items = user_item_time_dict[user_id]\n user_hist_items = []\n for (item_list, click_time) in hist_items:\n user_hist_items.extend(item_list)\n user_hist_items_ = {item_id for item_id in user_hist_items}\n \n item_rank = {}\n for item in user_hist_items:\n try:\n for another_item, wij in sorted(item2item_sim[item].items(), key=lambda x: x[1], reverse=True)[:sim_item_topk]:\n if another_item in user_hist_items_:\n continue\n\n item_rank.setdefault(another_item, 0)\n item_rank[another_item] += wij\n except:\n continue\n \n # fill the item_rank if the number of news in item_rank is less than recall_item_num\n if len(item_rank) < recall_item_num:\n for i, item in enumerate(item_topk_click):\n if item in item_rank.items():\n continue\n item_rank[item] = - i - 100 # set a random negative number\n if len(item_rank) == recall_item_num:\n break\n \n item_rank = sorted(item_rank.items(), key=lambda x: x[1], reverse=True)[:recall_item_num]\n \n return item_rank","def calculate_pairwise_user_similarity(self, user1_preferences, user2_preferences):\r\n\r\n shared_items = set(user1_preferences.indices) & set(user2_preferences.indices)\r\n\r\n all_items = set(user1_preferences.indices) | set(user2_preferences.indices)\r\n\r\n num_agreements = sum(1 for x in shared_items if abs(user1_preferences[0, x] - user2_preferences[0, x]) <= 2)\r\n\r\n return (num_agreements / len(all_items) if len(all_items) > 0 else 0)","def pair_items_mapper(self, user_id, values):\r\n\t pass #your code here\r","def _get_recommend(self, user):\n return self.user_cf.calculate(target_user_id=user, user_n=self.user_n,\n item_n=self.item_n, type=2)","def recommend(self, user_id, N=10):\n scores = self.user_factors[user_id] @ self.product_factors.T\n best = np.argpartition(scores, -N)[-N:]\n return sorted(zip(best, scores[best]), key=lambda x: -x[1])","def prediction(pair, uid_allneighbor_info, user_bd, uid):\n iid, real_rating, time = pair\n average_uid_rating = user_bd.value[uid][0]\n sim_rating = []\n for info in uid_allneighbor_info:\n uid, sim, ratings = info\n sim_rating += [\n (rating[0], sim, rating[1] - average_uid_rating)\n for rating in ratings if iid in rating[0]]\n\n if len(sim_rating) != 0:\n sim_rating = [\n (line[0], line[1] * line[2], abs(line[1]))\n for line in sim_rating]\n predicted_rating = average_uid_rating + sum(\n map(lambda line: line[1], sim_rating)) / sum(\n map(lambda line: line[2], sim_rating))\n else:\n predicted_rating = average_uid_rating\n return iid, real_rating, self.bound_rating(predicted_rating)","def ParejaRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n parejaE = user_preferences[\"tiene_pareja\"]\r\n equal_styles = list(matcher.match(\"User\", pareja = parejaE))\r\n return equal_styles","def get_user_preferences(self, user_id):\n # User training ratings\n user_ratings = self.ratings[(self.ratings['user_id'] == user_id)]\n\n # Get rating-movie information\n movies_user = pd.merge(user_ratings, self.movies, on='movie_id')\n\n # Get count of genres\n genres_sum = movies_user[self.genres].sum()\n genres_sum_mat = genres_sum.as_matrix()\n\n # Weight by average of genre within user\n mean_ratings = np.zeros(len(self.genres))\n for i, g in enumerate(genres_sum.index):\n mean_ratings[i] = movies_user[movies_user[g] == True]['rating'].mean()\n\n # Multiply and replace nans to 0\n cleared = np.nan_to_num(genres_sum_mat * mean_ratings)\n return cleared / np.sum(cleared)","def recommendation_item_based(user_id, item_id):\n try:\n user_id = int(user_id)\n item_id = int(item_id)\n return str( item_based( user_item, user_id, item_id) )\n except AssertionError as ae:\n return str(ae)\n except Exception as e:\n traceback.print_exc()\n return \"0\"","def __insertandretrieve_recommendation(self, userid=None, itemid=None):\n def recommendation2rec(recommendationsip=None):\n recs = []\n for recommendation in recommendationsip:\n recs.append(self.__itemidx2id[recommendation[0]])\n return recs\n userid = str(userid)\n itemid = str(itemid)\n if userid in list(self.__userid2idx.keys()):\n useridx = self.__userid2idx[userid]\n userarray = numpy.asarray([useridx, ] * len(self.__itemidx2id.keys()))\n itemarray = numpy.asarray(list(self.__itemidx2id.keys()))\n predicted_ratings = self.__recommender1.predict([userarray, itemarray], batch_size=10, verbose=0)\n item_rating = {}\n for item, pr in zip(itemarray, predicted_ratings):\n item_rating[item] = pr[0]\n recommendations = sorted(item_rating.items(), key=lambda value: value[1], reverse=True)[:self._num_recommendations]\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n if itemid in list(self.__itemid2idx.keys()):\n itemidx = self.__itemid2idx[itemid]\n recommendations = self.__recommender2.similar_items(itemidx, N=self._num_recommendations)\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n recommendations = list(self.__itemid2idx.keys())\n random.shuffle(recommendations)\n recommendations = recommendations[:self._num_recommendations]\n return recommendations","def rank_potential_items(self, target_user_id, top_k_users):\n items_rank = {}\n target_user = self.users[target_user_id]\n for user_id in top_k_users:\n sim_user = self.users[user_id]\n sim = self.sim_matrix[target_user_id][user_id]\n for item_id, item_time in sim_user.covered_items.items():\n if self.ensure_new and (item_id in target_user.covered_items):\n continue # skip item that already been bought\n if self.timestamp:\n # note that time context model cannot be evaluated\n # properly using offline data, this is just a demon\n # user's interest for this history item\n t_now = 1146454548\n time_elapse = Model.time_elapse(item_time, t_now)\n score = time_elapse*sim\n else:\n score = sim\n try:\n items_rank[item_id] += score\n except KeyError:\n items_rank[item_id] = score\n # assert len(items_rank) >= self.n\n return items_rank","def userSuggestions(database):\n firstname=str(input(\"who do you want to have follow suggestions for :\"))\n usr,find=getByName(database,firstname)\n if not find:\n print(\"the User could not be found\")\n return\n else:\n following=[]\n followers=[]\n for folower in usr.folowed:\n followers.append(folower)\n for folowed in usr.folow:\n following.append(folowed)\n results=[]\n print(\"On what do you want your suggestions to be based on?\\n1. Mutual Interests\\n2. Mutual Connections\\n3. Both\")\n choice=int(input(\"Your choice :\"))\n for key ,usrs in database.items():\n if key not in following: \n correspondant=0\n if choice == 1 or choice == 3:\n for interest in usr.interest:\n if interest in usrs.interest:\n correspondant+=1\n if choice == 2 or choice == 3:\n for folower in followers:\n for folows in usrs.folowed:\n if key == folows:\n correspondant+=1\n results.append([key,correspondant])\n for i in range(len(results)):\n for j in range(0, len(results)-i-1):\n if results[j][1] > results[j+1][1] :\n results[j], results[j+1] = results[j+1], results[j]\n for k in range(5):\n print(results[k][0])","def get_player_item_val(self, choice_of_item, user):\n\n for key in user.player_inventory:\n\n if choice_of_item == key:\n return user.player_inventory[key]\n\n return False","def pred_for_user(self,u):\r\n ids=np.where(self.Y_data_n[:,0]==u)[0]\r\n items_rated_by_u=Y_data_n[ids,1].tolist()\r\n pred_ratings=[]\r\n for i in range(self.n_items):\r\n if i not in items_rated_by_u:\r\n pred_ratings.append(self.pred(u,i))\r\n return pred_ratings","def profesionalRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n profesional = user_preferences[\"vida_profesional\"]\r\n equal_styles = list(matcher.match(\"User\", prof = profesional))\r\n return equal_styles","def lookup(self,user_preferences):\n res = list()\n \n fit_area = set()\n fit_price = set()\n fit_food = set()\n \n if user_preferences[0] == \"any\" or user_preferences[0] == 0:\n fit_area = set(range(len(self.area)))\n else:\n for i,a in enumerate(self.area):\n if a == user_preferences[0]:\n fit_area.add(i)\n if user_preferences[1] == \"any\" or user_preferences[1] == 0:\n fit_price = set(range(len(self.price_range)))\n else:\n for j,p in enumerate(self.price_range):\n if p == user_preferences[1]:\n fit_price.add(j)\n if user_preferences[2] == \"any\" or user_preferences[2] == 0:\n fit_food = set(range(len(self.food_types)))\n else:\n for k,f in enumerate(self.food_types):\n if f == user_preferences[2]:\n fit_food.add(k)\n option_numbers = fit_area.intersection(fit_price, fit_food)\n if option_numbers:\n for i in option_numbers:\n res.append(self.restaurant_names[i])\n \n return res","def popularity(self,train = None,test = None,k = 8,nitem = 10):\n train = train or self.traindata\n test = test or self.testdata\n item_popularity = dict()\n for user ,items in train.items():\n for item in items.keys():\n item_popularity.setdefault(item,0)\n item_popularity[item] += 1\n ret = 0\n n = 0\n for user in train.keys():\n rank = self.recommend(user, train, k = k, nitem = nitem)\n for item ,_ in rank.items():\n ret += math.log(1+item_popularity[item])\n n += 1\n return ret / (n * 1.0)","def get_recommendations(prefs, person, similarity=sim_pearson):\n totals = {}\n similarity_sums = {}\n\n for other in prefs:\n if other == person:\n continue\n\n sim = similarity(prefs, person, other)\n\n if sim <= 0:\n continue\n\n for item in prefs[other]:\n if item not in prefs[person] or prefs[person][item] == 0:\n totals.setdefault(item, 0)\n totals[item] += prefs[other][item] * sim\n similarity_sums.setdefault(item, 0)\n similarity_sums[item] += sim\n\n # Normalized list\n rankings = [(total / similarity_sums[item], item)\n for item, total in totals.items()]\n\n # Returns normalized score, not an r that would be between -1 and 1\n rankings.sort()\n rankings.reverse()\n return rankings","def recommend(self):\n\t\t\n\t\titems = self.unique_biz_id.items()\n\n\t\t# business id is essentially restaurant id, replace the naming \n\t\tfor rest1, i1 in items:\n\t\t\tfor rest2, i2 in items:\n\t\t\t\tif i1 < i2:\n\t\t\t\t\tsim, nsup = self.calculate_similarity( rest1 = rest1, rest2 = rest2 )\n\t\t\t\t\tself.database_sim[i1][i2] = sim\n\t\t\t\t\tself.database_sim[i2][i1] = sim\n\t\t\t\t\tself.database_sup[i1][i2] = nsup\n\t\t\t\t\tself.database_sup[i2][i1] = nsup\n\t\t\t\telif i1 == i2:\n\t\t\t\t\tnsup = self.df[ self.df['business_id'] == rest1 ]['user_id'].count()\n\t\t\t\t\tself.database_sim[i1][i1] = 1.0\n\t\t\t\t\tself.database_sup[i1][i1] = nsup","def calculate_item_relevance_scores(self, user_similarity_profile):\r\n scores = user_similarity_profile.dot(self.ratings_matrix.matrix)\r\n return self.ratings_matrix.normalize_score_vector(scores)","def prediction(self, user, item):\n return self._prob_to_class(self(user, item))","def __insertandretrieve_recommendation(self, userid=None, itemid=None):\n def recommendation2rec(recommendationsip=None):\n recs = []\n for recommendation in recommendationsip:\n recs.append(self.__itemidx2id[recommendation[0]])\n return recs\n userid = str(userid)\n itemid = str(itemid)\n if userid in list(self.__userid2idx.keys()):\n useridx = self.__userid2idx[userid]\n recommendations = self.__recommender.recommend(useridx, self.__useritem, N=self._num_recommendations)\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n if itemid in list(self.__itemid2idx.keys()):\n itemidx = self.__itemid2idx[itemid]\n recommendations = self.__recommender.similar_items(itemidx, N=self._num_recommendations)\n recommendations = recommendation2rec(recommendationsip=recommendations)\n else:\n recommendations = list(self.__itemid2idx.keys())\n random.shuffle(recommendations)\n recommendations = recommendations[:self._num_recommendations]\n return recommendations","def recommend(r ,username, users):\r\n # first find nearest neighbor\r\n nearest = computeNearestNeighbor(r, username, users)[0][1]\r\n recommendations = []\r\n # now find bands neighbor rated that user didn't\r\n neighborRatings = users[nearest]\r\n userRatings = users[username]\r\n for artist in neighborRatings:\r\n if not artist in userRatings:\r\n recommendations.append((artist, neighborRatings[artist]))\r\n # using the fn sorted for variety - sort is more efficient\r\n return sorted(recommendations, key=lambda artistTuple: artistTuple[1], reverse = True)","def score(self, user_idx, item_idx=None):\n if item_idx is None:\n if self.train_set.is_unk_user(user_idx):\n raise ScoreException(\n \"Can't make score prediction for (user_id=%d)\" % user_idx\n )\n\n known_item_scores = self.V.dot(self.U[user_idx, :])\n return known_item_scores\n else:\n if self.train_set.is_unk_user(user_idx) or self.train_set.is_unk_item(\n item_idx\n ):\n raise ScoreException(\n \"Can't make score prediction for (user_id=%d, item_id=%d)\"\n % (user_idx, item_idx)\n )\n\n user_pred = self.V[item_idx, :].dot(self.U[user_idx, :])\n\n user_pred = sigmoid(user_pred)\n if self.train_set.min_rating == self.train_set.max_rating:\n user_pred = scale(user_pred, 0.0, self.train_set.max_rating, 0.0, 1.0)\n else:\n user_pred = scale(\n user_pred,\n self.train_set.min_rating,\n self.train_set.max_rating,\n 0.0,\n 1.0,\n )\n\n return user_pred","def user_based_recommendation(\n self, test_dataRDD,\n user_based_dict_bd, userbased_sim_pair_dict_bd, user_info_bd):\n sim_pair_dict_keys = set(userbased_sim_pair_dict_bd.value.keys())\n return test_dataRDD.filter(\n lambda line: line[0] in sim_pair_dict_keys).map(\n lambda line: self.user_based_prediction(\n line, user_based_dict_bd,\n userbased_sim_pair_dict_bd, user_info_bd))","def popularity(self, user_list):\n item_popular = Counter(self.train['movieId'].values)\n ret = 0\n n = 0\n print('\\nCalculate popularity: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n for rec in set([data[0] for data in recom_data]):\n ret += math.log(1 + item_popular.get(rec))\n n += 1\n ret /= n * 1.0\n print('\\npopularity: ', ret)\n return ret","def prediction(uid, pair, rating_bd, sim_bd, item_bd):\n iid, real_rating = pair[0], pair[1]\n if iid not in sim_bd.value.keys():\n return ()\n iid_neighbors = [\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\n average_iid_rating = item_bd.value[iid][0]\n sim_rating = []\n for info in iid_neighbors:\n niid, nsim, ratings = info\n sim_rating += [\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\n for rating in ratings if uid in rating[0]]\n if len(sim_rating) != 0:\n sim_ratings = [\n (line[1] * line[2], abs(line[1]), line[3])\n for line in sim_rating]\n predicted_rating_no_decay = average_iid_rating + sum(\n map(lambda line: line[0], sim_ratings)) / sum(\n map(lambda line: line[1], sim_ratings))\n predicted_rating_decay = \\\n average_iid_rating + add_decay(sim_ratings)\n else:\n predicted_rating_no_decay = average_iid_rating\n predicted_rating_decay = average_iid_rating\n return iid, real_rating, \\\n self.bound_rating(predicted_rating_no_decay), \\\n self.bound_rating(predicted_rating_decay)","def part_two(rucksacks: list) -> int:\n summ = 0\n for i in range(0, len(rucksacks), 3):\n first_group = set(rucksacks[i])\n second_group = set(rucksacks[i + 1])\n third_group = set(rucksacks[i + 2])\n badge = first_group.intersection(second_group).intersection(third_group)\n badge = list(badge)[0] # extract item id from set\n summ += PRIORITY.get(badge, 0)\n return summ","def update_weight(user, user_favs, rec_user, rec_user_favs):\n counter = 0\n for photo in user_favs:\n if photo in rec_user_favs:\n counter += 1\n weight, created = Weight.objects.get_or_create(against=user, to=rec_user)\n weight.weight = float(counter)/len(rec_user_favs)\n weight.save()","def recomenadation_user_based(user_id):\n try:\n user_id = int(user_id)\n return str( user_based( rec_matrix, user_item, user_id ) )\n except AssertionError as ae:\n # if index + 1 not in df.userid.value_counts().index:\n # return {\"sort_ids\": [int(item) for item in df.item_id.value_counts().index[:3]]}\n return str(ae)\n except Exception as e:\n traceback.print_exc()\n return \"0\"","def precision(self, user_list):\n hit = 0\n all_recom = 0\n print('Calculate precision: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n all_recom += len(recom_item)\n print('\\nprecision is: ', hit / (all_recom * 1.0))\n return hit / (all_recom * 1.0)","def get_best_matching(self):\r\n from django.db.models import Q, Avg\r\n import copy\r\n import operator\r\n if self.user is None:\r\n raise User.DoesNotExist\r\n users = User.objects.all()\r\n if self.type == FRIENDS_ONLY:\r\n friends = Friends.objects.filter(Q(user_one_id=self.user) | Q(user_two_id=self.user))\r\n if len(friends) > 2:\r\n users = users.filter(Q(id=friends.values('user_one_id')) | Q(id=friends.values('user_two_id')))\r\n\r\n user_sims = {}\r\n prefs = {}\r\n for user in users:\r\n tab = {}\r\n scores = Score.objects.values('game_id', 'score').filter(user_id=user)\r\n for score in scores:\r\n tab.update({score['game_id']: score['score']})\r\n prefs.update({copy.deepcopy(user.id): copy.deepcopy(tab)})\r\n\r\n for user in users:\r\n sim = self.pearson(prefs, self.user, user.id)\r\n user_sims.update({user.id: sim})\r\n\r\n print(user_sims)\r\n del user_sims[self.user] # deletion of user for whom the analysis is beeing performed\r\n user_sims = sorted(user_sims.items(), key=operator.itemgetter(1), reverse=True) # dictionary containing user_ids and users' similarities\r\n if len(user_sims) < 3:\r\n return self.get_most_popular()\r\n\r\n games_f = Score.objects.values('game_id', 'score').filter(user_id=user_sims[0][0]).order_by('-score')[:3]\r\n games_s = Score.objects.values('game_id', 'score').filter(user_id=user_sims[1][0]).order_by('-score')[:3]\r\n\r\n recommended_games = {}\r\n grd = {}\r\n games_f_dict = dict([(g['game_id'], g['score']) for g in games_f])\r\n recommended_games.update(dict(sorted(games_f_dict.items(), key=operator.itemgetter(1), reverse=True)))\r\n\r\n games_s_dict = dict([(g['game_id'], g['score']) for g in games_s])\r\n recommended_games.update(dict(sorted(games_s_dict.items(), key=operator.itemgetter(1), reverse=True)))\r\n\r\n for game in recommended_games:\r\n scores = list(Score.objects.values('game_id').filter(game_id=game).annotate(Avg('score')))\r\n idn = scores[0]['game_id']\r\n avg = scores[0]['score__avg']\r\n grd.update({idn: avg})\r\n\r\n return grd","def _compute_unique_approval_scores(self, profile: list[set[int]]) -> list[int]:\n unique_approval_scores = np.zeros(self.m, dtype=int)\n for party in range(0, self.m):\n for ballot in profile:\n if ballot == {party}:\n unique_approval_scores[party] += 1\n return list(unique_approval_scores)","def calc_score(self, user_id, item_id): \n p = np.dot(self.U[user_id], self.V[item_id])\n if self.trunc_score_rule==None:pass\n else: p=self.trunc_score_rule(p)\n \n return p","def goalsRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n goalsE = user_preferences[\"Metas_similares\"]\r\n equal_styles = list(matcher.match(\"User\", goals = goalsE))\r\n return equal_styles","def collect_items_user_dict(self, test_data):\n items_to_fill = {}\n for row in test_data:\n user = row[0]\n item = row[1]\n if item not in items_to_fill:\n items_to_fill[item] = []\n items_to_fill[item] += [user.item()]\n\n return items_to_fill","def classify(user, itemName, itemVector):\n # first find nearest neighbor\n nearest = computeNearestNeighbor(itemName, itemVector, items)[0][1]\n rating = users[user][nearest]\n return rating","def score(self, user_idx, item_idx=None):\n if self.variant == 'c2pf' or self.variant == 'tc2pf':\n if item_idx is None:\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n else:\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n elif self.variant == 'rc2pf':\n if item_idx is None:\n user_pred = self.Xi * self.Theta[user_idx, :].T\n else:\n user_pred = self.Xi[item_idx,] * self.Theta[user_idx, :].T\n else:\n if item_idx is None:\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n else:\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\n # transform user_pred to a flatten array,\n user_pred = np.array(user_pred, dtype='float64').flatten()\n\n return user_pred","def prediction_item(item_id):\r\n # Data preprosessing\r\n reader = Reader(rating_scale=(0, 5))\r\n load_df = Dataset.load_from_df(ratings_df, reader)\r\n a_train = load_df.build_full_trainset()\r\n\r\n predictions = []\r\n for ui in a_train.all_users():\r\n predictions.append(model.predict(iid=item_id, uid=ui, verbose=False))\r\n return predictions","def _pval_pairs(self, idx0, idx1):\n pass","def likingdatingapps(user_preferences: dict, matcher: NodeMatcher):\r\n appsPreferidas = user_preferences[\"app_citas\"]\r\n equal_styles = list(matcher.match(\"User\", apps = appsPreferidas))\r\n return equal_styles","def seen(user, item):\n print(\"---\", item.seen_by(user))\n return item.seen_by(user)","def recall(self, user_list):\n hit = 0\n like_item = 0\n print('\\nCalculate recall: ')\n for user in tqdm(user_list):\n recom_data = self._get_recommend(user)\n recom_item = set([data[0] for data in recom_data])\n user_item = set(\n self.test[self.test['userId'] == user]['movieId'].values)\n overlap = recom_item & user_item\n hit += len(overlap)\n like_item += len(user_item)\n print('\\nrecall is: ', hit / (like_item * 1.0))\n return hit / (like_item * 1.0)","def mainRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n print(\"***************************************************\\n Recomendaciones principales\\n\"\r\n \"***************************************************\")\r\n pareja = ParejaRecommendation(dict, matcher)\r\n apps = likingdatingapps(dict, matcher)\r\n dificultad = difficultydates(dict, matcher)\r\n importancia = samehobbies(dict, matcher)\r\n imp = study(dict, matcher)\r\n gusto = musictaste(dict, matcher)\r\n region = sameregion(dict, matcher)\r\n gustoDif = different(dict, matcher)\r\n Habits = habits(dict, matcher)\r\n goals = goalsRecommendation(dict, matcher)\r\n prof = profesionalRecommendation(dict, matcher)\r\n similar = similarRecommendation(dict, matcher)\r\n\r\n listaopciones = [pareja, apps, dificultad, importancia, imp, gusto, region, gustoDif, Habits, goals, prof, similar]\r\n\r\n Prospectos = {}\r\n for option in listaopciones:\r\n for element in option:\r\n if Prospectos.has_key(element[\"nombre\"]):\r\n Prospectos[element[\"nombre\"]] = 1\r\n else:\r\n Prospectos[element[\"nombre\"]] = Prospectos[element[\"nombre\"]] + 1","def item_rank(self, u, a, b, alphas, theta, transition_prob):\n no_of_states = len(alphas[u][0])\n\n # calculate distribution over the states for the user at time t+1\n p_t_plus_1 = []\n for k in range(no_of_states):\n total = 0\n for l in range(no_of_states):\n total += alphas[u][-1][k] * transition_prob[l][k]\n p_t_plus_1.append(total)\n# # print('\\np_t_plus_u1')\n # pprint(p_t_plus_1)\n\n item_rank = defaultdict(float)\n for i in range(len(theta)): # for each item\n item_rank[i] = -sum(p_t_plus_1[k] * (1 + b[k] * theta[i][k])**(-a[k]) for k in range(no_of_states))\n\n# # print(item_rank)\n items = sorted(item_rank, key=item_rank.__getitem__, reverse=True)\n\n return items","def compute_user_local_sensitivity(sc, dataset, user_id, num_iters_ls):\n\n res = defaultdict(lambda: 0.0)\n\n original_recs, original_qii = compute_recommendations_and_qii(sc, dataset,\n user_id)\n original_recs = recommendations_to_dd(original_recs)\n\n res[\"recommendee_user_id\"] = user_id\n res[\"recommendee_recs_l1_norm\"] = l1_norm(original_recs)\n res[\"recommendee_qii_l1_norm\"] = l1_norm(original_qii)\n res[\"recommendee_recs_l0_norm\"] = len(original_recs)\n res[\"recommendee_qii_l0_norm\"] = len(original_qii)\n res[\"perturbations\"] = []\n\n all_users = get_user_list(dataset)\n for x in xrange(num_iters_ls):\n if perturb_specific_user:\n other_user_id = perturb_specific_user\n else:\n other_user_id = random.choice(list(set(all_users) - {user_id}))\n print \"Perturbing user\", other_user_id, \"(\", x+1, \"out of\",\\\n num_iters_ls, \")\"\n perturbed_dataset = perturb_user_ratings(sc, dataset, other_user_id)\n start = time.time()\n recs, qii = compute_recommendations_and_qii(sc, perturbed_dataset, user_id)\n stop = time.time()\n recs = recommendations_to_dd(recs)\n rec_ls = calculate_l1_distance(original_recs, recs)\n qii_ls = calculate_l1_distance(original_qii, qii)\n\n report = {}\n report[\"perturbed_user_id\"] = other_user_id\n report[\"perturbed_recs_l1_norm\"] = l1_norm(recs)\n report[\"perturbed_qii_l1_norm\"] = l1_norm(qii)\n report[\"perturbed_recs_l0_norm\"] = len(recs)\n report[\"perturbed_qii_l0_norm\"] = len(qii)\n report[\"recs_ls\"] = rec_ls\n report[\"qii_ls\"] = qii_ls\n report[\"recs_ls_norm\"] = rec_ls/float((len(recs)*4))\n report[\"qii_ls_norm\"] = qii_ls/float((len(qii)*4))\n print \"Local sensitivity of recs: \", rec_ls/float((len(recs)*4))\n print \"Local sensitivity of QII: \", qii_ls/float((len(qii)*4))\n report[\"computation_time\"] = stop - start\n\n\n res[\"perturbations\"].append(report)\n\n for per in res[\"perturbations\"]:\n res[\"avg_recs_ls\"] += float(per[\"recs_ls\"])/len(res[\"perturbations\"])\n res[\"max_recs_ls\"] = max(res[\"max_recs_ls\"], per[\"recs_ls\"])\n res[\"avg_recs_ls_norm\"] +=\\\n float(per[\"recs_ls_norm\"])/len(res[\"perturbations\"])\n res[\"max_recs_ls_norm\"] = max(res[\"max_recs_ls_norm\"],\n per[\"recs_ls_norm\"])\n res[\"avg_qii_ls\"] += float(per[\"qii_ls\"])/len(res[\"perturbations\"])\n res[\"max_qii_ls\"] = max(res[\"max_qii_ls\"], per[\"qii_ls\"])\n res[\"avg_qii_ls_norm\"] +=\\\n float(per[\"qii_ls_norm\"])/len(res[\"perturbations\"])\n res[\"max_qii_ls_norm\"] = max(res[\"max_recs_qii_norm\"],\n per[\"qii_ls_norm\"])\n return dict(res)","def best_policy(self, U):\n pi = {}\n utility = {s:dict() for s in self.states}\n for s in self.states:\n for a in self.available(s):\n utility[s][a] = self.expected_utility(a,s,U)\n pi[s] = utility[s].keys()[utility[s].values().index(max(utility[s].values()))]\n return pi","def compute_kappa_score(self, scorer1, scorer2, items, matrix_weights):\r\n #matrice nb items\r\n df_n_items = pd.DataFrame(data=0, index=items, columns=items)\r\n for score1, score2 in zip(scorer1, scorer2):\r\n df_n_items[score1][score2] = df_n_items[score1][score2] + 1\r\n #nb items * total number of scoring items\r\n df_proba = df_n_items / len(scorer1)\r\n #df_proba with weights\r\n df_proba_w = df_proba * matrix_weights\r\n #relative observed agreement among raters\r\n p_a = df_proba_w.sum().sum()\r\n #hypothetical probability of chance agreement\r\n p_e = 0\r\n for lig in df_proba.index:\r\n for col in df_proba.columns:\r\n p_e = p_e + df_proba.loc[lig, :].sum() * \\\r\n df_proba.loc[:, col].sum() * matrix_weights.loc[lig, col]\r\n #kappa score\r\n kappa = 1 - (1 - p_a) / (1 - p_e)\r\n return kappa","def get_preferences(buyer_count=5):\n\n\n buyer_wants = np.random.randint(1, 4, buyer_count)\n seller_count = sum(buyer_wants)\n\n buyer_start = range(seller_count)\n seller_start = range(buyer_count)\n\n buyer_prefs = list()\n seller_prefs = list()\n\n for i in range(buyer_count):\n random.shuffle(buyer_start)\n buyer_prefs.append(buyer_start[:])\n\n for i in range(seller_count):\n random.shuffle(seller_start)\n seller_prefs.append(seller_start[:])\n\n return buyer_prefs, seller_prefs, buyer_wants","def get_recommendations(name, data):\r\n #sorts preferences in alphabetical order\r\n #do this to make it easier to compare\r\n for key in data:\r\n data[key] = selection_sort(data[key])\r\n most_similar_key = \"\"\r\n max_matches = 0\r\n for key in data:\r\n if not(key[-1] == \"$\" or data[key] == data[name]):\r\n \"\"\"if the person is not private or does not have the same data\"\"\"\r\n matches = num_matches(data[key], data[name])\r\n if matches > max_matches:\r\n most_similar_key = key\r\n max_matches = matches\r\n if most_similar_key == \"\":\r\n print(\"No recommendations available at this time\")\r\n return 1\r\n else:\r\n final_recommendations = []\r\n for x in data[most_similar_key]:\r\n if x not in data[name]:\r\n final_recommendations += [x]\r\n return final_recommendations","def compare_for_list_key_value(self, item_1: Tuple[keyType, valueType], item_2: Tuple[keyType, valueType]) -> int:\n # When one element is tuple and the other is another type, such as str,\n # using hash value can make the '<' operator function function normally.\n if hash(item_1[0]) != hash(item_2[0]):\n if hash(item_1[0]) < hash(item_2[0]):\n return -1\n return 1\n else:\n tmp_1 = item_1[1]\n tmp_2 = item_2[1]\n # 'values' could be list or set which don't have hash() function.\n if isinstance(item_1[1], (list, set)):\n tmp_1 = tuple(item_1[1])\n if isinstance(item_2[1], (list, set)):\n tmp_2 = tuple(item_2[1])\n if hash(tmp_1) < hash(tmp_2):\n return -1\n return 1","def item_to_ids(items, user):\r\n sizes = [\"10\", \"12\", \"14\", \"16\", \"25\", \"30\", \"35\", \"40\"]\r\n if not items:\r\n return []\r\n ids = []\r\n names_to_id_product = get_names_preconfigured(user)\r\n for item in items:\r\n for name, product_id in names_to_id_product.items():\r\n # CLEAN TO REMOVE SMALL MEDIUM LARGE, AND STRIP\r\n item = item.strip()\r\n for size in sizes:\r\n if size in item:\r\n if size == \"10\" or size == \"25\":\r\n replace = \"Small\"\r\n elif size == \"12\" or size == \"30\":\r\n replace = \"Medium\"\r\n elif size == \"14\" or size == \"35\":\r\n replace = \"Large\"\r\n elif size == \"16\" or size == \"40\":\r\n replace = \"X-Large\"\r\n item = item.replace(size + '\"', replace).replace(size + \"'\", replace)\r\n # print(item, \" | \", name, editDistanceDP(item, name, len(item), len(name)) / (len(name)))\r\n if edit_distance_dp(item, name, len(item), len(name)) / (len(name)) < .3 or edit_distance_dp(\r\n item.replace(\"Pizza\", \"\"), name.replace(\"Dipping \", \"\"), len(item.replace(\"Pizza\", \"\")),\r\n len(name.replace(\"Dipping \", \"\"))) / (len(name)) < .1:\r\n ids.append(product_id)\r\n break\r\n final_ids = []\r\n for id in ids:\r\n if \"F_\" in id:\r\n variants = ids_to_variants(user)\r\n replace = variants[id][0]\r\n if replace == \"STJUDE\":\r\n replace = \"STJUDE10\"\r\n final_ids.append(replace)\r\n else:\r\n final_ids.append(id)\r\n return final_ids\r\n # order.add_item('P12IPAZA') # add a 12-inch pan pizza\r\n # order.add_item('MARINARA') # with an extra marinara cup\r\n # order.add_item('20BCOKE') # and a 20oz bottle of coke\r\n return ['P12IPAZA', 'MARINARA', '20BCOKE']","def top_matches(self, prefs, p1):\n #print 'top_matches', prefs, p1\n #print '\\n'\n return [(p2, self.similarity(prefs[p1], prefs[p2])) for p2 in prefs if p2 != p1]","def _update_suspicion_2(self):\n\n for bucket in self.used_buckets:\n multiplier = 1 if bucket.attacked else -1\n for user in bucket.users:\n user.suspicion += (1 / len(bucket)) * multiplier","def _update_suspicion_2(self):\n\n for bucket in self.buckets:\n multiplier = 1 if bucket.attacked else -1\n for user in bucket.users:\n user.suspicion += (1 / len(bucket)) * multiplier","def predict(self, users, items):\n users_t = torch.tensor(users, dtype=torch.int64, device=self.device)\n items_t = torch.tensor(items, dtype=torch.int64, device=self.device)\n with torch.no_grad():\n scores = torch.mul(\n torch.cat(\n (self.user_encode(users_t)[0], self.user_emb(users_t)), dim=1\n ),\n torch.cat(\n (self.item_encode(items_t)[0], self.item_emb(items_t)), dim=1\n ),\n ).sum(dim=1)\n return scores","def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\n #print \"--------------------------------------------------\"\n #print \"calculate_recommendations\"\n #print \"--------------------------------------------------\"\n\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\n\n # U = np.array('users')\n # D = np.array('video_games')\n\n # R = |U| cross |D|\n\n # We want to discover K latent features\n\n # Find\n # P(a | |U| corss K matrix)\n # Q(a | |D| cross K matrix)\n # Such that their product approximates R\n # R approx= P cross transpose(Q) = hat(R)\n #\n\n # r[i][j] = transpose(p)[i] * q[j]\n # = sum( 1..k, p[i][k] * q[k][j] )\n\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\n # squared error, estimated rating can be either higher or lower than the real thing\n\n # find the gradient\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\n\n # update rules\n # alpha = settings.alpha # learning_rate\n # alpha = 0.0002 # learning_rate\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\n\n # training data\n # T = (u[i], d[j], r[i][j])\n # np.array()\n\n # iterate until convergance\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\n # - sum(1..k, p[i][k]*q[k][j]))**2\n\n # regularization\n # beta = 0.02\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\n #\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\n\n data = np.array(vote_list)\n\n encoder = OneHotEncoder()\n\n users = data[:,0]\n unique_users = list(set(users))\n for i in range(len(users)):\n users[i] = unique_users.index(users[i])\n\n video_games = data[:,1]\n unique_games = list(set(video_games))\n for i in range(len(video_games)):\n video_games[i] = unique_games.index(video_games[i])\n\n ratings = data[:,2]\n M = len(set(video_games))\n N = len(set(users))\n R = np.zeros((N,M))\n for i in range(len(users)):\n user = users[i]\n game = video_games[i]\n rating = ratings[i]\n R[user][game] = rating\n\n K = 2\n\n P = np.random.rand(N,K)\n Q = np.random.rand(M,K)\n\n nP, nQ = self.matrix_factorization(R, P, Q, K)\n nR = np.dot(nP, nQ.T)\n\n itemMatch = {}\n for i in range(N):\n user = unique_users[i]\n itemMatch[user] = []\n for j in range(M):\n if R[i][j] == 0:\n video_game = unique_games[j]\n recommendation = (video_game, nR[i][j])\n itemMatch[user].append(recommendation)\n itemMatch[None] = []\n print 'pmf recommendations', itemMatch.items()\n print '\\n'\n recommendations = itemMatch.items()\n\n # returns\n # [\n # (<user1>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # (<user2>, [\n # (\"<object_identifier1>\", <score>),\n # (\"<object_identifier2>\", <score>),\n # ]),\n # ]\n\n return recommendations","def agg_preferences(prefs_list):\n aggregated_preferences=defaultdict(lambda: 0)\n for els in prefs_list:\n if els[0]<els[1]:\n aggregated_preferences[(els[0],els[1])]+=1\n else:\n aggregated_preferences[(els[1],els[0])]-=1\n return aggregated_preferences","def update_user_user_sim(self, user_A_info, user_B_info, item_popularity):\n user_A_id, user_A_time = user_A_info\n user_B_id, user_B_time = user_B_info\n try:\n row = self.sim_matrix[user_A_id]\n except KeyError:\n row = self.sim_matrix[user_A_id] = {} # all reference\n IIF = log(1+item_popularity)\n if self.timestamp:\n time_elapse = Model.time_elapse(user_A_time, user_B_time)\n score = 1*time_elapse/IIF\n else:\n score = 1/IIF\n try:\n row[user_B_id] += score\n except KeyError:\n row[user_B_id] = score","def itembase(user_id):\n frame1 = pd.concat([pd.DataFrame(REVIEWS[x]) for x in REVIEWS])\n filtered_data = recommender.filtering_not_city()\n businesses = pd.DataFrame(filtered_data).set_index('business_id')\n frame2 = frame1.drop_duplicates(subset=[\"user_id\", \"business_id\"], keep='last', inplace=False)\n\n utility_matrix = pivot_reviews(frame2)\n\n similarity = create_similarity_matrix_euclid(utility_matrix)\n\n for business in businesses.index:\n neighborhood = select_neighborhood(similarity, utility_matrix, user_id, business)\n prediction = weighted_mean(neighborhood, utility_matrix, user_id)\n businesses.ix[business, 'predicted rating'] = prediction\n\n sorted_prediction = businesses.sort_values(by=['predicted rating'], ascending=False)\n sorted_prediction2 = sorted_prediction.drop(columns=['predicted rating'])\n sorted_prediction2 = sorted_prediction2.reset_index()\n sorted_prediction3 = sorted_prediction.reset_index()\n return sorted_prediction2.to_dict(orient='records'), sorted_prediction3.to_dict(orient='records')","def percentage(my_list, item):\n return 100.0 * frequency(my_list, item)","def get_neigh_info(self, user, item):\r\n batch_u_neigh = self.u_neigh[user]\r\n batch_i_neigh = self.i_neigh[item]\r\n return batch_u_neigh, batch_i_neigh","def common_likes(self, user):\n\n self_like_ids = set(self.likes.keys()) if self.likes else set()\n other_like_ids = set(user.fb_profile.likes.keys()) if user.fb_profile.likes else set()\n\n common_like_ids = self_like_ids.intersection(other_like_ids)\n\n return common_like_ids","def similarRecommendation(user_preferences: dict, matcher: NodeMatcher):\r\n similarE = user_preferences[\"gustos_similares\"]\r\n equal_styles = list(matcher.match(\"User\",similar = similarE))\r\n return equal_styles","def total_profit(knapsack, items, weight):\n return knapsack[items][weight]","def count_score(data: GameData) -> Tuple[int, int]:\n score_user = score_ai = 0\n\n for item in data.items:\n if not hasattr(item, \"prediction_user\"):\n return score_user, score_ai\n\n if item.prediction_user == item.ground_truth:\n score_user += 1\n\n if item.prediction_ai[0] == item.ground_truth:\n score_ai += 1\n\n return score_user, score_ai","def friend_overlap(users):\n ###TODO-- Completed\n\n #Creating a list of tuples to store the values for number of shared accounts by each of the user\n overlap_tuples = []\n\n #Trying for all the combination if user's without repetition\n for outer_idx,_ in enumerate(users):\n for inner_idx,_ in enumerate(users):\n if (inner_idx != len(users)-1) and (outer_idx < inner_idx+1):\n #Creating a SET of friends for 2 users and finding the INTERSECTION i.e. Common friends between these users\n overlap_tuples.append(tuple((users[outer_idx]['screen_name'],users[inner_idx+1]['screen_name'],\n len(list(set(users[outer_idx]['friends']) & set(users[inner_idx+1]['friends']))))))\n\n #Sort based on first KEY as N i.e. number of shared account in descending order,\n # for ties break using screen_name of user one, further on screen_name of user two\n return sorted(overlap_tuples, key=lambda x:[-x[2], x[0], x[1]])\n\n #for perm in combinations(screen_names,2):\n # overlap_tuples.append(tuple(perm[0],perm[1],len(list(set(user[perm[0]]['friends']) & set(perm[1]['friends'])))))\n #print(len(list(set(users[0]['friends']) & set(users[1]['friends']))))","def item_based_recommendation(\n self, test_dataRDD,\n item_based_dict_bd, itembased_sim_pair_dict_bd, item_info_bd):\n return test_dataRDD.map(\n lambda line: self.item_based_prediction(\n line, item_based_dict_bd,\n itembased_sim_pair_dict_bd, item_info_bd))","def create_user_item_array(self):\n user_em = self.user_factors.weight.detach()\n item_em = self.product_factors.weight.detach()\n user_b = self.user_bias.weight.detach()\n item_b = self.product_bias.weight.detach()\n\n user_item_array = (item_em + item_b) @ (user_em + user_b).transpose(0, 1)\n preds = self._prob_to_class(user_item_array).numpy()\n\n return preds","def apriori(TDB,supMin):\n \"\"\" subMin is ......... \"\"\"\n dic = dict()\n keys = set()\n for s in TDB:\n for element in s:\n keys.add(frozenset(element))\n keys = list(keys)\n\n while len(keys)>=1:\n dic.clear()\n for key in keys:\n f = getFreq(TDB,key)\n if f >= supMin:\n dic[key]=f\n printItemSet(dic)\n keys = list(dic.keys())\n newKeys = set()\n for i in range (0,len(keys)-1):\n for j in range(i+1,len(keys)):\n newKey = frozenset.union(keys[i],keys[j])\n newKeys.add(newKey)\n keys = newKeys\n return dic","def personalization(prediction, n):\n # prediction\n # n top n recommendation\n\n top_n = get_top_n(prediction, n)\n\n rec_dict = {}\n for uid, user_ratings in top_n.items():\n rec_dict[uid] = [iid for (iid, _) in user_ratings]\n\n rec_user_ls = [pred[0] for pred in prediction]\n rec_item_ls = [pred[1] for pred in prediction]\n\n unique_rec_user_ls = np.unique(rec_user_ls)\n unique_rec_item_ls = np.unique(rec_item_ls)\n\n # assign each item with index number\n unique_rec_item_dict = {item: ind for ind,\n item in enumerate(unique_rec_item_ls)}\n\n n_unique_rec_user = len(unique_rec_user_ls)\n n_unique_rec_item = len(unique_rec_item_ls)\n\n # recommended user item matrix\n rec_matrix = np.zeros(shape=(n_unique_rec_user, n_unique_rec_item))\n\n # represent recommended item for each user as binary 0/1\n for user in range(n_unique_rec_user):\n # get userid\n user_id = unique_rec_user_ls[user]\n # get rec item list\n item_ls = rec_dict[user_id]\n\n for item_id in item_ls:\n # get item index\n item = unique_rec_item_dict[item_id]\n rec_matrix[user, item] = 1\n\n # calculate cosine similarity matrix across all user recommendations\n similarity = cosine_similarity(X=rec_matrix, dense_output=False)\n # calculate average of upper triangle of cosine matrix\n upper_right = np.triu_indices(similarity.shape[0], k=1)\n # personalization is 1-average cosine similarity\n score = 1 - np.mean(similarity[upper_right])\n return score","def item_based_prediction(self, line, rating_bd, sim_bd, item_bd):\n def sort_by_time(pairs):\n \"\"\"For each user, sort its rating records based on its datetime.\n More specifically, if time_a > time_b,\n then: time_a <- x, time_b <- x + 1.\n \"\"\"\n pairs = sorted(pairs, key=lambda line: line[2], reverse=False)\n order = 0\n out = []\n for i in range(len(pairs)):\n if i != 0 and pairs[i][2] == pairs[i - 1][2]:\n out += [(pairs[i][0], pairs[i][1], order)]\n else:\n order += 1\n out += [(pairs[i][0], pairs[i][1], order)]\n return out\n\n def f_decay(cur, t_ui):\n return np.exp(- self.alpha * (cur - t_ui))\n\n def add_decay(pairs):\n \"\"\"add decay rate to the pairs.\n Args:\n pairs: sim * rating, sim, time\n \"\"\"\n new_pairs = sort_by_time(pairs)\n current_time = max(map(lambda line: line[2], new_pairs)) + 1\n final_pairs = [\n (pair[0] * f_decay(current_time, pair[2]),\n pair[1] * f_decay(current_time, pair[2]))\n for pair in new_pairs]\n return sum(map(lambda line: line[0], final_pairs)) / sum(\n map(lambda line: line[1], final_pairs))\n\n def prediction(uid, pair, rating_bd, sim_bd, item_bd):\n \"\"\"do the prediction. It can either add decay rate or not,\n which is decided by `method`.\n \"\"\"\n iid, real_rating = pair[0], pair[1]\n if iid not in sim_bd.value.keys():\n return ()\n iid_neighbors = [\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\n average_iid_rating = item_bd.value[iid][0]\n sim_rating = []\n for info in iid_neighbors:\n niid, nsim, ratings = info\n sim_rating += [\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\n for rating in ratings if uid in rating[0]]\n if len(sim_rating) != 0:\n sim_ratings = [\n (line[1] * line[2], abs(line[1]), line[3])\n for line in sim_rating]\n predicted_rating_no_decay = average_iid_rating + sum(\n map(lambda line: line[0], sim_ratings)) / sum(\n map(lambda line: line[1], sim_ratings))\n predicted_rating_decay = \\\n average_iid_rating + add_decay(sim_ratings)\n else:\n predicted_rating_no_decay = average_iid_rating\n predicted_rating_decay = average_iid_rating\n return iid, real_rating, \\\n self.bound_rating(predicted_rating_no_decay), \\\n self.bound_rating(predicted_rating_decay)\n\n uid, pairs = line\n return uid, [\n prediction(uid, pair, rating_bd, sim_bd, item_bd)\n for pair in pairs]","def ap(self, result, next_item):\n if next_item in result.index:\n rank = result.index.get_loc(next_item) + 1\n return 1.0 / rank\n else:\n return 0","def test_reasonable_auction(self):\n # I have no preferences\n bids = [Cost(ITEM1, ACTOR1, 1000),\n Cost(ITEM2, ACTOR1, 1000),\n Cost(ITEM3, ACTOR1, 1000),\n Cost(ITEM4, ACTOR1, 1000),\n Cost(ITEM5, ACTOR1, 1000),\n\n # I have linear preferences\n Cost(ITEM1, ACTOR2, 700),\n Cost(ITEM2, ACTOR2, 800),\n Cost(ITEM3, ACTOR2, 1000),\n Cost(ITEM4, ACTOR2, 1200),\n Cost(ITEM5, ACTOR2, 1300),\n\n # I have non-linear preferences\n Cost(ITEM1, ACTOR3, 400),\n Cost(ITEM2, ACTOR3, 800),\n Cost(ITEM3, ACTOR3, 1000),\n Cost(ITEM4, ACTOR3, 1200),\n Cost(ITEM5, ACTOR3, 1600),\n\n # I have arbitrary preference\n Cost(ITEM1, ACTOR4, 2435),\n Cost(ITEM2, ACTOR4, 305),\n Cost(ITEM3, ACTOR4, 310),\n Cost(ITEM4, ACTOR4, 1725),\n Cost(ITEM5, ACTOR4, 225),\n\n # I have strong preferences\n Cost(ITEM1, ACTOR5, 0),\n Cost(ITEM2, ACTOR5, 0),\n Cost(ITEM3, ACTOR5, 0),\n Cost(ITEM4, ACTOR5, 0),\n Cost(ITEM5, ACTOR5, 5000)]\n result = self.splitter.split(ITEMS[:5], ACTORS[:5], bids)\n expected = [(ITEM1, ACTOR4, None),\n (ITEM2, ACTOR1, None),\n (ITEM3, ACTOR3, None),\n (ITEM4, ACTOR2, None),\n (ITEM5, ACTOR5, None)]\n item_assignments_present(self, result, expected)","def efficientShopping(family, items, NoOfItems):\r\n cost = 0\r\n result = {}\r\n # items are sorted by price\r\n # items closer to list start are items that family wants\r\n for f in range(len(family)):\r\n member_data = chooseItems(family[f], items, NoOfItems)\r\n cost += member_data[0]\r\n result[family[f][1] + 1] = member_data[1]\r\n # get data in sorted order by family member id\r\n final_data = {}\r\n for i in range(len(family)):\r\n final_data[i+1] = result[i+1]\r\n final_data[\"total\"] = cost\r\n return final_data","def recommend_me_team(self, user_id: int, user_ids_per_group: list, n_recommendations: int):\n res_arr = np.array([self.user_similarity.loc[user_id, group_ids].mean() for group_ids in user_ids_per_group])\n res_inds = np.argsort(res_arr)[::-1][:n_recommendations]\n return res_inds, res_arr[res_inds]","def predict(self, user, item):\n return self.user_vectors[user, :].dot(self.item_vectors[item, :].T)","def get_participation_in_pairing(self):\n entries = self.c.select(pairing=1)\n\n frequency = dict()\n pairs = []\n for e in entries:\n c1, c2 = e.data['parents']\n pairs.append(tuple(sorted([c1, c2])))\n if c1 not in frequency.keys():\n frequency[c1] = 0\n frequency[c1] += 1\n if c2 not in frequency.keys():\n frequency[c2] = 0\n frequency[c2] += 1\n return (frequency, pairs)","def compare_users(userA, userB):\n reader = open(\"similarities.txt\", \"r\")\n lines = reader.readlines()\n similarity = None\n for line in lines:\n a, b, sim = line.split(\"\\t\")\n if userA == a and userB == b:\n print(sim)\n similarity = float(sim)\n\n reader2 = open(\"sorted_similarities.txt\", \"r\")\n lines = reader2.readlines()\n index = 0.0\n for line in lines:\n sim = float(line)\n if similarity == sim:\n return 1.0 - (float(index) / len(lines))\n index += 1\n\n return None\n \n \n \"\"\"\n if len(sim_dict.keys()) == 0:\n return None\n\n ranked = sorted(sim_dict.keys(), key=lambda x: sim_dict[x],\n reverse=True)\n try:\n index = ranked.index(userB)\n percentile = 1.0 - (float(index) / len(sim_dict.keys()))\n return int(100 * percentile)\n except:\n return None\n \"\"\"","def single_user_recommendation_vector(self, user_ratings):\r\n\r\n ratings_vector = self.ratings_matrix.get_ratings_vector(user_ratings)\r\n\r\n user_similarity_profile = self.calculate_user_similarity_profile(ratings_vector)\r\n\r\n return self.calculate_item_relevance_scores(user_similarity_profile)","def recommend_new(self, user_id, N=10):\n scores = self.user_factors[user_id] @ self.product_factors.T\n bought_indices = self.product_user_matrix.T[user_id].nonzero()[1]\n count = N + len(bought_indices)\n ids = np.argpartition(scores, -count)[-count:]\n best = sorted(zip(ids, scores[ids]), key=lambda x: -x[1])\n return list(itertools.islice((rec for rec in best if rec[0] not in bought_indices), N))","def step(self, user: torch.tensor, item: torch.tensor,\n rating: torch.tensor, preference: torch.tensor):\n pass","def map_user_to_ratings(reviews):\n\tuser_ratings = dict()\n\tfor review in reviews:\n\t\tuser = review[0]\n\t\tif user not in user_ratings:\n\t\t\tuser_ratings[user] = 0\n\t\telse:\n\t\t\tuser_ratings[user] = user_ratings[user] + 1\n\n\treturn user_ratings","def test_get_user_rankings(self):\n user = User(name=u'no win', email=u'generic@thingy.com')\n user.put()\n \n userone = User(name=u'one win', email=u'generic@thingy.com', total_played=1, wins=1)\n userone.put()\n \n usertwo = User(name=u'two wins', email=u'generic@thingy.com', total_played=2, wins=1)\n usertwo.put()\n \n user_rankings = users.get_user_rankings()\n self.assertEquals(len(user_rankings), 2)\n self.assertEquals(user_rankings.pop().key, usertwo.key)\n self.assertEquals(user_rankings.pop().key, userone.key)","def chosen_items(sack, items, weight):\n total = total_profit(sack, items, weight)\n chosen = []\n \n while total != 0:\n for i in range(items + 1):\n if total in sack[i]:\n chosen.append(i) \n total = total - profit[i - 1] \n break \n \n return sorted(chosen)","def _update_suspicion_1(self):\n\n for bucket in self.used_buckets:\n multiplier = 1 if bucket.attacked else 0\n for user in bucket.users:\n user.suspicion += multiplier","def _pval_pairs(self, idx0, idx1):\n return self._test_pairs(idx0=idx0, idx1=idx1)","def estimate(self, u, j):\n if not (self.trainset.knows_user(u) and self.trainset.knows_item(j)):\n raise PredictionImpossible('User and/or item is unknown.')\n\n u_ratings = self.trainset.ur[u]\n\n if self.weighting == 'linear':\n weight = sum(self.freqs[i, j, self.to_index(r)] for i, r in u_ratings)\n score = sum(self.sums[i, j, self.to_index(r)] for i, r in u_ratings)\n return score / weight\n\n # self.weighting == 'log' or None\n weights = [self.freqs[i, j, self.to_index(r)] for i, r in u_ratings]\n reciprocals = [1 / w if w else 0 for w in weights]\n scores = [self.sums[i, j, self.to_index(r)] for i, r in u_ratings]\n scores = [s * w for s, w in zip(scores, reciprocals)]\n\n if self.weighting is None:\n return np.mean(scores)\n # self.weighting == 'log'\n logs = [np.log(w + 1) if w >= 1 else 0 for w in weights]\n return np.dot(scores, logs) / np.sum(logs)","def compute_multiuser_local_sensitivity(sc, dataset, num_iters_ls,\n num_users_ls):\n res = []\n users_already_processed = set()\n all_users = list(get_user_list(dataset))\n for x in xrange(num_users_ls):\n while True:\n cur_user = random.choice(all_users)\n print \"Trying user\", cur_user\n if cur_user in users_already_processed:\n print \"Oops, we've already processed this one\"\n continue\n if max_movies_per_user == 0:\n break\n print \"Looking at their ratings\"\n u_ratings = get_ratings_from_uid(dataset, cur_user)\n u_ratings_list = u_ratings.collect()\n l = len(u_ratings_list)\n if l > max_movies_per_user:\n print \"This user has too many movies: \",\\\n l, \">\", max_movies_per_user\n users_already_processed.add(cur_user)\n continue\n else:\n print \"This user with\", l, \"movies \" +\\\n \"rated is fine!\"\n break\n print \"Probing user\", cur_user\n report = compute_user_local_sensitivity(sc, dataset, cur_user,\n num_iters_ls)\n users_already_processed.add(cur_user)\n res.append(report)\n return res","def recommend_items(self, dataset, u, max_items=10, return_scores=True, item_features=None):\n try:\n r = (self.similarity_matrix * dataset[u].T).toarray().flatten()\n except AttributeError:\n raise AttributeError('you must call fit() before trying to recommend items')\n known_items = set(dataset[u].indices)\n recs = []\n for i in r.argsort()[::-1]:\n if i not in known_items:\n if return_scores:\n recs.append((i, r[i]))\n else:\n recs.append(i)\n if len(recs) >= max_items:\n break\n return recs","def recommend(self, user):\n K = self.n_sim_user\n N = self.n_rec_movie\n rank = dict()\n watched_movies = self.trainset[user]\n\n # v=similar user, wuv=similarity factor\n for v, wuv in sorted(self.user_sim_mat[user].items(),\n key=itemgetter(1), reverse=True)[0:K]:\n for movie in self.trainset[v]:\n if movie in watched_movies:\n continue\n # predict the user's \"interest\" for each movie\n rank.setdefault(movie, 0)\n rank[movie] += wuv\n # return the N best movies\n return sorted(rank.items(), key=itemgetter(1), reverse=True)[0:N]","def _update_suspicion_1(self):\n\n for bucket in self.buckets:\n multiplier = 1 if bucket.attacked else 0\n for user in bucket.users:\n user.suspicion += multiplier","def recommendations(self):\n return [user for user in self.tags.similar_objects() if user.status == UserStatus.APPROVED]","def predict(self, user, item):\n pred = self.global_bias + self.user_bias[user] + self.item_bias[item]\n pred += self.U[user, :].dot(self.I[:, item])\n return pred","def getSupport(item):\n return float(freqSet[item]) / len(transactionList)"],"string":"[\n \"def _predict_user_item(self, user, item):\\n if not isinstance(user, int):\\n user = self._user_to_ndx[user]\\n if not isinstance(item, int):\\n item = self._item_to_ndx[item]\\n\\n try:\\n rating_mean = self._averages[user]\\n except AttributeError:\\n raise RuntimeError('Must fit before predicting')\\n\\n other_users = [other for other in self._users if other != user and\\n np.isfinite(self._votes[other][item])]\\n weights = np.array([self._weight(user, other)\\n for other in other_users])\\n deviations = np.array([self._votes[other][item] - self._averages[other]\\n for other in other_users])\\n\\n weight_sum = np.sum(np.absolute(weights))\\n if weight_sum < _EPSILON:\\n return rating_mean # No similar users, so guess their avg rating\\n\\n norm_const = 1 / weight_sum\\n\\n weighted_avg = np.sum(weights * deviations)\\n return rating_mean + norm_const * weighted_avg\",\n \"def find_predictions(actives, train_rdd_gbitem_dict, train_rdd_gbuser_dict, num_items):\\n active_user = actives[0][0]\\n active_item = actives[0][1]\\n\\n # -----------------------------------\\n # train_rdd_gbitem_dict = (item, ([(user,r),(user,r)...],avg_of_item))\\n # train_rdd_gbuser_dict = (user, [(item,r),(item,r)...]\\n\\n if active_user not in train_rdd_gbuser_dict and active_item not in train_rdd_gbitem_dict:\\n return (active_user, active_item), 2.5\\n\\n # all user, ratings that have rated active_item\\n if active_item in train_rdd_gbitem_dict:\\n active_item_avg = train_rdd_gbitem_dict[active_item][1]\\n active_item_dict = dict(train_rdd_gbitem_dict[active_item][0]) # {user: rating, user: rating, ...}\\n else:\\n # item not found in training set\\n # new item problem.\\n average_of_user_list = train_rdd_gbuser_dict[active_user]\\n average_of_user = sum([x[1] for x in average_of_user_list]) / len(average_of_user_list)\\n return (active_user, active_item), average_of_user\\n\\n # user rated items - all (item, ratings) that the user has rated\\n if active_user in train_rdd_gbuser_dict:\\n active_user_rated_items = train_rdd_gbuser_dict[active_user] # [(item, rating), (item, rating), ...]\\n else:\\n # user not found in training set\\n # new user problem.\\n return (active_user, active_item), train_rdd_gbitem_dict[active_item][1]\\n\\n similarity_list = []\\n for item, rating in active_user_rated_items:\\n item_dict = dict(train_rdd_gbitem_dict[item][0])\\n item_avg = train_rdd_gbitem_dict[item][1]\\n similarity = find_similarity(dict(active_item_dict), active_item_avg, dict(item_dict), item_avg)\\n similarity_list.append((rating, similarity))\\n\\n # Have obtained similarity list for active item and item from the above code.\\n # Filter according to a top 'N' items and then take avg rating.\\n # similarity_list.sort(key=lambda x: x[1], reverse=True)\\n # similarity_list = similarity_list[:len(similarity_list) // 4]\\n # similarity_list = [(x[0], x[1]*abs(x[1])**1.5) for x in similarity_list]\\n # print(similarity_list)\\n pred_rating = find_weighted_average(similarity_list, num_items)\\n\\n # for i in similarity_list:\\n # print(i)\\n # print(\\\"Pred-rating: \\\", pred_rating)\\n\\n return (active_user, active_item), pred_rating\",\n \"def predict_rating(user_id,item_id):\\n user_preference = latent_user_preferences[user_id]\\n item_preference = latent_item_features[item_id]\\n return user_preference.dot(item_preference)\",\n \"def compute_user_user_sim_base_on_common_items(self):\\n self.sim_matrix = {}\\n for item in self.items.values():\\n # convert to list of tuples for indexing\\n users = list(item.covered_users.items())\\n item_popularity = len(users)\\n # iter through all user pairs\\n for i in range(len(users)-1):\\n for j in range(i+1, len(users)):\\n user_A_info, user_B_info = users[i], users[j]\\n # remember to update pair wise!\\n self.update_user_user_sim(user_A_info, user_B_info,\\n item_popularity)\\n self.update_user_user_sim(user_B_info, user_A_info,\\n item_popularity)\",\n \"def predict_rating(self, user_id, item_id):\\n user_preference = self.latent_user_preferences[user_id]\\n item_feature = self.latent_item_features[item_id]\\n return user_preference.dot(item_feature)\",\n \"def predict(self, user_id, item_id):\\n # DONEreturn prediction for given pair\\n return self._user_factors[user_id, : ].dot(self._item_factors[item_id, :])\",\n \"def item_based_recommend(user_id, user_item_time_dict, item2item_sim, sim_item_topk, recall_item_num, item_topk_click):\\n \\n # fetch the user's history clicks\\n hist_items = user_item_time_dict[user_id]\\n user_hist_items = []\\n for (item_list, click_time) in hist_items:\\n user_hist_items.extend(item_list)\\n user_hist_items_ = {item_id for item_id in user_hist_items}\\n \\n item_rank = {}\\n for item in user_hist_items:\\n try:\\n for another_item, wij in sorted(item2item_sim[item].items(), key=lambda x: x[1], reverse=True)[:sim_item_topk]:\\n if another_item in user_hist_items_:\\n continue\\n\\n item_rank.setdefault(another_item, 0)\\n item_rank[another_item] += wij\\n except:\\n continue\\n \\n # fill the item_rank if the number of news in item_rank is less than recall_item_num\\n if len(item_rank) < recall_item_num:\\n for i, item in enumerate(item_topk_click):\\n if item in item_rank.items():\\n continue\\n item_rank[item] = - i - 100 # set a random negative number\\n if len(item_rank) == recall_item_num:\\n break\\n \\n item_rank = sorted(item_rank.items(), key=lambda x: x[1], reverse=True)[:recall_item_num]\\n \\n return item_rank\",\n \"def calculate_pairwise_user_similarity(self, user1_preferences, user2_preferences):\\r\\n\\r\\n shared_items = set(user1_preferences.indices) & set(user2_preferences.indices)\\r\\n\\r\\n all_items = set(user1_preferences.indices) | set(user2_preferences.indices)\\r\\n\\r\\n num_agreements = sum(1 for x in shared_items if abs(user1_preferences[0, x] - user2_preferences[0, x]) <= 2)\\r\\n\\r\\n return (num_agreements / len(all_items) if len(all_items) > 0 else 0)\",\n \"def pair_items_mapper(self, user_id, values):\\r\\n\\t pass #your code here\\r\",\n \"def _get_recommend(self, user):\\n return self.user_cf.calculate(target_user_id=user, user_n=self.user_n,\\n item_n=self.item_n, type=2)\",\n \"def recommend(self, user_id, N=10):\\n scores = self.user_factors[user_id] @ self.product_factors.T\\n best = np.argpartition(scores, -N)[-N:]\\n return sorted(zip(best, scores[best]), key=lambda x: -x[1])\",\n \"def prediction(pair, uid_allneighbor_info, user_bd, uid):\\n iid, real_rating, time = pair\\n average_uid_rating = user_bd.value[uid][0]\\n sim_rating = []\\n for info in uid_allneighbor_info:\\n uid, sim, ratings = info\\n sim_rating += [\\n (rating[0], sim, rating[1] - average_uid_rating)\\n for rating in ratings if iid in rating[0]]\\n\\n if len(sim_rating) != 0:\\n sim_rating = [\\n (line[0], line[1] * line[2], abs(line[1]))\\n for line in sim_rating]\\n predicted_rating = average_uid_rating + sum(\\n map(lambda line: line[1], sim_rating)) / sum(\\n map(lambda line: line[2], sim_rating))\\n else:\\n predicted_rating = average_uid_rating\\n return iid, real_rating, self.bound_rating(predicted_rating)\",\n \"def ParejaRecommendation(user_preferences: dict, matcher: NodeMatcher):\\r\\n parejaE = user_preferences[\\\"tiene_pareja\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\", pareja = parejaE))\\r\\n return equal_styles\",\n \"def get_user_preferences(self, user_id):\\n # User training ratings\\n user_ratings = self.ratings[(self.ratings['user_id'] == user_id)]\\n\\n # Get rating-movie information\\n movies_user = pd.merge(user_ratings, self.movies, on='movie_id')\\n\\n # Get count of genres\\n genres_sum = movies_user[self.genres].sum()\\n genres_sum_mat = genres_sum.as_matrix()\\n\\n # Weight by average of genre within user\\n mean_ratings = np.zeros(len(self.genres))\\n for i, g in enumerate(genres_sum.index):\\n mean_ratings[i] = movies_user[movies_user[g] == True]['rating'].mean()\\n\\n # Multiply and replace nans to 0\\n cleared = np.nan_to_num(genres_sum_mat * mean_ratings)\\n return cleared / np.sum(cleared)\",\n \"def recommendation_item_based(user_id, item_id):\\n try:\\n user_id = int(user_id)\\n item_id = int(item_id)\\n return str( item_based( user_item, user_id, item_id) )\\n except AssertionError as ae:\\n return str(ae)\\n except Exception as e:\\n traceback.print_exc()\\n return \\\"0\\\"\",\n \"def __insertandretrieve_recommendation(self, userid=None, itemid=None):\\n def recommendation2rec(recommendationsip=None):\\n recs = []\\n for recommendation in recommendationsip:\\n recs.append(self.__itemidx2id[recommendation[0]])\\n return recs\\n userid = str(userid)\\n itemid = str(itemid)\\n if userid in list(self.__userid2idx.keys()):\\n useridx = self.__userid2idx[userid]\\n userarray = numpy.asarray([useridx, ] * len(self.__itemidx2id.keys()))\\n itemarray = numpy.asarray(list(self.__itemidx2id.keys()))\\n predicted_ratings = self.__recommender1.predict([userarray, itemarray], batch_size=10, verbose=0)\\n item_rating = {}\\n for item, pr in zip(itemarray, predicted_ratings):\\n item_rating[item] = pr[0]\\n recommendations = sorted(item_rating.items(), key=lambda value: value[1], reverse=True)[:self._num_recommendations]\\n recommendations = recommendation2rec(recommendationsip=recommendations)\\n else:\\n if itemid in list(self.__itemid2idx.keys()):\\n itemidx = self.__itemid2idx[itemid]\\n recommendations = self.__recommender2.similar_items(itemidx, N=self._num_recommendations)\\n recommendations = recommendation2rec(recommendationsip=recommendations)\\n else:\\n recommendations = list(self.__itemid2idx.keys())\\n random.shuffle(recommendations)\\n recommendations = recommendations[:self._num_recommendations]\\n return recommendations\",\n \"def rank_potential_items(self, target_user_id, top_k_users):\\n items_rank = {}\\n target_user = self.users[target_user_id]\\n for user_id in top_k_users:\\n sim_user = self.users[user_id]\\n sim = self.sim_matrix[target_user_id][user_id]\\n for item_id, item_time in sim_user.covered_items.items():\\n if self.ensure_new and (item_id in target_user.covered_items):\\n continue # skip item that already been bought\\n if self.timestamp:\\n # note that time context model cannot be evaluated\\n # properly using offline data, this is just a demon\\n # user's interest for this history item\\n t_now = 1146454548\\n time_elapse = Model.time_elapse(item_time, t_now)\\n score = time_elapse*sim\\n else:\\n score = sim\\n try:\\n items_rank[item_id] += score\\n except KeyError:\\n items_rank[item_id] = score\\n # assert len(items_rank) >= self.n\\n return items_rank\",\n \"def userSuggestions(database):\\n firstname=str(input(\\\"who do you want to have follow suggestions for :\\\"))\\n usr,find=getByName(database,firstname)\\n if not find:\\n print(\\\"the User could not be found\\\")\\n return\\n else:\\n following=[]\\n followers=[]\\n for folower in usr.folowed:\\n followers.append(folower)\\n for folowed in usr.folow:\\n following.append(folowed)\\n results=[]\\n print(\\\"On what do you want your suggestions to be based on?\\\\n1. Mutual Interests\\\\n2. Mutual Connections\\\\n3. Both\\\")\\n choice=int(input(\\\"Your choice :\\\"))\\n for key ,usrs in database.items():\\n if key not in following: \\n correspondant=0\\n if choice == 1 or choice == 3:\\n for interest in usr.interest:\\n if interest in usrs.interest:\\n correspondant+=1\\n if choice == 2 or choice == 3:\\n for folower in followers:\\n for folows in usrs.folowed:\\n if key == folows:\\n correspondant+=1\\n results.append([key,correspondant])\\n for i in range(len(results)):\\n for j in range(0, len(results)-i-1):\\n if results[j][1] > results[j+1][1] :\\n results[j], results[j+1] = results[j+1], results[j]\\n for k in range(5):\\n print(results[k][0])\",\n \"def get_player_item_val(self, choice_of_item, user):\\n\\n for key in user.player_inventory:\\n\\n if choice_of_item == key:\\n return user.player_inventory[key]\\n\\n return False\",\n \"def pred_for_user(self,u):\\r\\n ids=np.where(self.Y_data_n[:,0]==u)[0]\\r\\n items_rated_by_u=Y_data_n[ids,1].tolist()\\r\\n pred_ratings=[]\\r\\n for i in range(self.n_items):\\r\\n if i not in items_rated_by_u:\\r\\n pred_ratings.append(self.pred(u,i))\\r\\n return pred_ratings\",\n \"def profesionalRecommendation(user_preferences: dict, matcher: NodeMatcher):\\r\\n profesional = user_preferences[\\\"vida_profesional\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\", prof = profesional))\\r\\n return equal_styles\",\n \"def lookup(self,user_preferences):\\n res = list()\\n \\n fit_area = set()\\n fit_price = set()\\n fit_food = set()\\n \\n if user_preferences[0] == \\\"any\\\" or user_preferences[0] == 0:\\n fit_area = set(range(len(self.area)))\\n else:\\n for i,a in enumerate(self.area):\\n if a == user_preferences[0]:\\n fit_area.add(i)\\n if user_preferences[1] == \\\"any\\\" or user_preferences[1] == 0:\\n fit_price = set(range(len(self.price_range)))\\n else:\\n for j,p in enumerate(self.price_range):\\n if p == user_preferences[1]:\\n fit_price.add(j)\\n if user_preferences[2] == \\\"any\\\" or user_preferences[2] == 0:\\n fit_food = set(range(len(self.food_types)))\\n else:\\n for k,f in enumerate(self.food_types):\\n if f == user_preferences[2]:\\n fit_food.add(k)\\n option_numbers = fit_area.intersection(fit_price, fit_food)\\n if option_numbers:\\n for i in option_numbers:\\n res.append(self.restaurant_names[i])\\n \\n return res\",\n \"def popularity(self,train = None,test = None,k = 8,nitem = 10):\\n train = train or self.traindata\\n test = test or self.testdata\\n item_popularity = dict()\\n for user ,items in train.items():\\n for item in items.keys():\\n item_popularity.setdefault(item,0)\\n item_popularity[item] += 1\\n ret = 0\\n n = 0\\n for user in train.keys():\\n rank = self.recommend(user, train, k = k, nitem = nitem)\\n for item ,_ in rank.items():\\n ret += math.log(1+item_popularity[item])\\n n += 1\\n return ret / (n * 1.0)\",\n \"def get_recommendations(prefs, person, similarity=sim_pearson):\\n totals = {}\\n similarity_sums = {}\\n\\n for other in prefs:\\n if other == person:\\n continue\\n\\n sim = similarity(prefs, person, other)\\n\\n if sim <= 0:\\n continue\\n\\n for item in prefs[other]:\\n if item not in prefs[person] or prefs[person][item] == 0:\\n totals.setdefault(item, 0)\\n totals[item] += prefs[other][item] * sim\\n similarity_sums.setdefault(item, 0)\\n similarity_sums[item] += sim\\n\\n # Normalized list\\n rankings = [(total / similarity_sums[item], item)\\n for item, total in totals.items()]\\n\\n # Returns normalized score, not an r that would be between -1 and 1\\n rankings.sort()\\n rankings.reverse()\\n return rankings\",\n \"def recommend(self):\\n\\t\\t\\n\\t\\titems = self.unique_biz_id.items()\\n\\n\\t\\t# business id is essentially restaurant id, replace the naming \\n\\t\\tfor rest1, i1 in items:\\n\\t\\t\\tfor rest2, i2 in items:\\n\\t\\t\\t\\tif i1 < i2:\\n\\t\\t\\t\\t\\tsim, nsup = self.calculate_similarity( rest1 = rest1, rest2 = rest2 )\\n\\t\\t\\t\\t\\tself.database_sim[i1][i2] = sim\\n\\t\\t\\t\\t\\tself.database_sim[i2][i1] = sim\\n\\t\\t\\t\\t\\tself.database_sup[i1][i2] = nsup\\n\\t\\t\\t\\t\\tself.database_sup[i2][i1] = nsup\\n\\t\\t\\t\\telif i1 == i2:\\n\\t\\t\\t\\t\\tnsup = self.df[ self.df['business_id'] == rest1 ]['user_id'].count()\\n\\t\\t\\t\\t\\tself.database_sim[i1][i1] = 1.0\\n\\t\\t\\t\\t\\tself.database_sup[i1][i1] = nsup\",\n \"def calculate_item_relevance_scores(self, user_similarity_profile):\\r\\n scores = user_similarity_profile.dot(self.ratings_matrix.matrix)\\r\\n return self.ratings_matrix.normalize_score_vector(scores)\",\n \"def prediction(self, user, item):\\n return self._prob_to_class(self(user, item))\",\n \"def __insertandretrieve_recommendation(self, userid=None, itemid=None):\\n def recommendation2rec(recommendationsip=None):\\n recs = []\\n for recommendation in recommendationsip:\\n recs.append(self.__itemidx2id[recommendation[0]])\\n return recs\\n userid = str(userid)\\n itemid = str(itemid)\\n if userid in list(self.__userid2idx.keys()):\\n useridx = self.__userid2idx[userid]\\n recommendations = self.__recommender.recommend(useridx, self.__useritem, N=self._num_recommendations)\\n recommendations = recommendation2rec(recommendationsip=recommendations)\\n else:\\n if itemid in list(self.__itemid2idx.keys()):\\n itemidx = self.__itemid2idx[itemid]\\n recommendations = self.__recommender.similar_items(itemidx, N=self._num_recommendations)\\n recommendations = recommendation2rec(recommendationsip=recommendations)\\n else:\\n recommendations = list(self.__itemid2idx.keys())\\n random.shuffle(recommendations)\\n recommendations = recommendations[:self._num_recommendations]\\n return recommendations\",\n \"def recommend(r ,username, users):\\r\\n # first find nearest neighbor\\r\\n nearest = computeNearestNeighbor(r, username, users)[0][1]\\r\\n recommendations = []\\r\\n # now find bands neighbor rated that user didn't\\r\\n neighborRatings = users[nearest]\\r\\n userRatings = users[username]\\r\\n for artist in neighborRatings:\\r\\n if not artist in userRatings:\\r\\n recommendations.append((artist, neighborRatings[artist]))\\r\\n # using the fn sorted for variety - sort is more efficient\\r\\n return sorted(recommendations, key=lambda artistTuple: artistTuple[1], reverse = True)\",\n \"def score(self, user_idx, item_idx=None):\\n if item_idx is None:\\n if self.train_set.is_unk_user(user_idx):\\n raise ScoreException(\\n \\\"Can't make score prediction for (user_id=%d)\\\" % user_idx\\n )\\n\\n known_item_scores = self.V.dot(self.U[user_idx, :])\\n return known_item_scores\\n else:\\n if self.train_set.is_unk_user(user_idx) or self.train_set.is_unk_item(\\n item_idx\\n ):\\n raise ScoreException(\\n \\\"Can't make score prediction for (user_id=%d, item_id=%d)\\\"\\n % (user_idx, item_idx)\\n )\\n\\n user_pred = self.V[item_idx, :].dot(self.U[user_idx, :])\\n\\n user_pred = sigmoid(user_pred)\\n if self.train_set.min_rating == self.train_set.max_rating:\\n user_pred = scale(user_pred, 0.0, self.train_set.max_rating, 0.0, 1.0)\\n else:\\n user_pred = scale(\\n user_pred,\\n self.train_set.min_rating,\\n self.train_set.max_rating,\\n 0.0,\\n 1.0,\\n )\\n\\n return user_pred\",\n \"def user_based_recommendation(\\n self, test_dataRDD,\\n user_based_dict_bd, userbased_sim_pair_dict_bd, user_info_bd):\\n sim_pair_dict_keys = set(userbased_sim_pair_dict_bd.value.keys())\\n return test_dataRDD.filter(\\n lambda line: line[0] in sim_pair_dict_keys).map(\\n lambda line: self.user_based_prediction(\\n line, user_based_dict_bd,\\n userbased_sim_pair_dict_bd, user_info_bd))\",\n \"def popularity(self, user_list):\\n item_popular = Counter(self.train['movieId'].values)\\n ret = 0\\n n = 0\\n print('\\\\nCalculate popularity: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n for rec in set([data[0] for data in recom_data]):\\n ret += math.log(1 + item_popular.get(rec))\\n n += 1\\n ret /= n * 1.0\\n print('\\\\npopularity: ', ret)\\n return ret\",\n \"def prediction(uid, pair, rating_bd, sim_bd, item_bd):\\n iid, real_rating = pair[0], pair[1]\\n if iid not in sim_bd.value.keys():\\n return ()\\n iid_neighbors = [\\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\\n average_iid_rating = item_bd.value[iid][0]\\n sim_rating = []\\n for info in iid_neighbors:\\n niid, nsim, ratings = info\\n sim_rating += [\\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\\n for rating in ratings if uid in rating[0]]\\n if len(sim_rating) != 0:\\n sim_ratings = [\\n (line[1] * line[2], abs(line[1]), line[3])\\n for line in sim_rating]\\n predicted_rating_no_decay = average_iid_rating + sum(\\n map(lambda line: line[0], sim_ratings)) / sum(\\n map(lambda line: line[1], sim_ratings))\\n predicted_rating_decay = \\\\\\n average_iid_rating + add_decay(sim_ratings)\\n else:\\n predicted_rating_no_decay = average_iid_rating\\n predicted_rating_decay = average_iid_rating\\n return iid, real_rating, \\\\\\n self.bound_rating(predicted_rating_no_decay), \\\\\\n self.bound_rating(predicted_rating_decay)\",\n \"def part_two(rucksacks: list) -> int:\\n summ = 0\\n for i in range(0, len(rucksacks), 3):\\n first_group = set(rucksacks[i])\\n second_group = set(rucksacks[i + 1])\\n third_group = set(rucksacks[i + 2])\\n badge = first_group.intersection(second_group).intersection(third_group)\\n badge = list(badge)[0] # extract item id from set\\n summ += PRIORITY.get(badge, 0)\\n return summ\",\n \"def update_weight(user, user_favs, rec_user, rec_user_favs):\\n counter = 0\\n for photo in user_favs:\\n if photo in rec_user_favs:\\n counter += 1\\n weight, created = Weight.objects.get_or_create(against=user, to=rec_user)\\n weight.weight = float(counter)/len(rec_user_favs)\\n weight.save()\",\n \"def recomenadation_user_based(user_id):\\n try:\\n user_id = int(user_id)\\n return str( user_based( rec_matrix, user_item, user_id ) )\\n except AssertionError as ae:\\n # if index + 1 not in df.userid.value_counts().index:\\n # return {\\\"sort_ids\\\": [int(item) for item in df.item_id.value_counts().index[:3]]}\\n return str(ae)\\n except Exception as e:\\n traceback.print_exc()\\n return \\\"0\\\"\",\n \"def precision(self, user_list):\\n hit = 0\\n all_recom = 0\\n print('Calculate precision: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n all_recom += len(recom_item)\\n print('\\\\nprecision is: ', hit / (all_recom * 1.0))\\n return hit / (all_recom * 1.0)\",\n \"def get_best_matching(self):\\r\\n from django.db.models import Q, Avg\\r\\n import copy\\r\\n import operator\\r\\n if self.user is None:\\r\\n raise User.DoesNotExist\\r\\n users = User.objects.all()\\r\\n if self.type == FRIENDS_ONLY:\\r\\n friends = Friends.objects.filter(Q(user_one_id=self.user) | Q(user_two_id=self.user))\\r\\n if len(friends) > 2:\\r\\n users = users.filter(Q(id=friends.values('user_one_id')) | Q(id=friends.values('user_two_id')))\\r\\n\\r\\n user_sims = {}\\r\\n prefs = {}\\r\\n for user in users:\\r\\n tab = {}\\r\\n scores = Score.objects.values('game_id', 'score').filter(user_id=user)\\r\\n for score in scores:\\r\\n tab.update({score['game_id']: score['score']})\\r\\n prefs.update({copy.deepcopy(user.id): copy.deepcopy(tab)})\\r\\n\\r\\n for user in users:\\r\\n sim = self.pearson(prefs, self.user, user.id)\\r\\n user_sims.update({user.id: sim})\\r\\n\\r\\n print(user_sims)\\r\\n del user_sims[self.user] # deletion of user for whom the analysis is beeing performed\\r\\n user_sims = sorted(user_sims.items(), key=operator.itemgetter(1), reverse=True) # dictionary containing user_ids and users' similarities\\r\\n if len(user_sims) < 3:\\r\\n return self.get_most_popular()\\r\\n\\r\\n games_f = Score.objects.values('game_id', 'score').filter(user_id=user_sims[0][0]).order_by('-score')[:3]\\r\\n games_s = Score.objects.values('game_id', 'score').filter(user_id=user_sims[1][0]).order_by('-score')[:3]\\r\\n\\r\\n recommended_games = {}\\r\\n grd = {}\\r\\n games_f_dict = dict([(g['game_id'], g['score']) for g in games_f])\\r\\n recommended_games.update(dict(sorted(games_f_dict.items(), key=operator.itemgetter(1), reverse=True)))\\r\\n\\r\\n games_s_dict = dict([(g['game_id'], g['score']) for g in games_s])\\r\\n recommended_games.update(dict(sorted(games_s_dict.items(), key=operator.itemgetter(1), reverse=True)))\\r\\n\\r\\n for game in recommended_games:\\r\\n scores = list(Score.objects.values('game_id').filter(game_id=game).annotate(Avg('score')))\\r\\n idn = scores[0]['game_id']\\r\\n avg = scores[0]['score__avg']\\r\\n grd.update({idn: avg})\\r\\n\\r\\n return grd\",\n \"def _compute_unique_approval_scores(self, profile: list[set[int]]) -> list[int]:\\n unique_approval_scores = np.zeros(self.m, dtype=int)\\n for party in range(0, self.m):\\n for ballot in profile:\\n if ballot == {party}:\\n unique_approval_scores[party] += 1\\n return list(unique_approval_scores)\",\n \"def calc_score(self, user_id, item_id): \\n p = np.dot(self.U[user_id], self.V[item_id])\\n if self.trunc_score_rule==None:pass\\n else: p=self.trunc_score_rule(p)\\n \\n return p\",\n \"def goalsRecommendation(user_preferences: dict, matcher: NodeMatcher):\\r\\n goalsE = user_preferences[\\\"Metas_similares\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\", goals = goalsE))\\r\\n return equal_styles\",\n \"def collect_items_user_dict(self, test_data):\\n items_to_fill = {}\\n for row in test_data:\\n user = row[0]\\n item = row[1]\\n if item not in items_to_fill:\\n items_to_fill[item] = []\\n items_to_fill[item] += [user.item()]\\n\\n return items_to_fill\",\n \"def classify(user, itemName, itemVector):\\n # first find nearest neighbor\\n nearest = computeNearestNeighbor(itemName, itemVector, items)[0][1]\\n rating = users[user][nearest]\\n return rating\",\n \"def score(self, user_idx, item_idx=None):\\n if self.variant == 'c2pf' or self.variant == 'tc2pf':\\n if item_idx is None:\\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n else:\\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n elif self.variant == 'rc2pf':\\n if item_idx is None:\\n user_pred = self.Xi * self.Theta[user_idx, :].T\\n else:\\n user_pred = self.Xi[item_idx,] * self.Theta[user_idx, :].T\\n else:\\n if item_idx is None:\\n user_pred = self.Beta * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n else:\\n user_pred = self.Beta[item_idx, :] * self.Theta[user_idx, :].T + self.Xi * self.Theta[user_idx, :].T\\n # transform user_pred to a flatten array,\\n user_pred = np.array(user_pred, dtype='float64').flatten()\\n\\n return user_pred\",\n \"def prediction_item(item_id):\\r\\n # Data preprosessing\\r\\n reader = Reader(rating_scale=(0, 5))\\r\\n load_df = Dataset.load_from_df(ratings_df, reader)\\r\\n a_train = load_df.build_full_trainset()\\r\\n\\r\\n predictions = []\\r\\n for ui in a_train.all_users():\\r\\n predictions.append(model.predict(iid=item_id, uid=ui, verbose=False))\\r\\n return predictions\",\n \"def _pval_pairs(self, idx0, idx1):\\n pass\",\n \"def likingdatingapps(user_preferences: dict, matcher: NodeMatcher):\\r\\n appsPreferidas = user_preferences[\\\"app_citas\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\", apps = appsPreferidas))\\r\\n return equal_styles\",\n \"def seen(user, item):\\n print(\\\"---\\\", item.seen_by(user))\\n return item.seen_by(user)\",\n \"def recall(self, user_list):\\n hit = 0\\n like_item = 0\\n print('\\\\nCalculate recall: ')\\n for user in tqdm(user_list):\\n recom_data = self._get_recommend(user)\\n recom_item = set([data[0] for data in recom_data])\\n user_item = set(\\n self.test[self.test['userId'] == user]['movieId'].values)\\n overlap = recom_item & user_item\\n hit += len(overlap)\\n like_item += len(user_item)\\n print('\\\\nrecall is: ', hit / (like_item * 1.0))\\n return hit / (like_item * 1.0)\",\n \"def mainRecommendation(user_preferences: dict, matcher: NodeMatcher):\\r\\n print(\\\"***************************************************\\\\n Recomendaciones principales\\\\n\\\"\\r\\n \\\"***************************************************\\\")\\r\\n pareja = ParejaRecommendation(dict, matcher)\\r\\n apps = likingdatingapps(dict, matcher)\\r\\n dificultad = difficultydates(dict, matcher)\\r\\n importancia = samehobbies(dict, matcher)\\r\\n imp = study(dict, matcher)\\r\\n gusto = musictaste(dict, matcher)\\r\\n region = sameregion(dict, matcher)\\r\\n gustoDif = different(dict, matcher)\\r\\n Habits = habits(dict, matcher)\\r\\n goals = goalsRecommendation(dict, matcher)\\r\\n prof = profesionalRecommendation(dict, matcher)\\r\\n similar = similarRecommendation(dict, matcher)\\r\\n\\r\\n listaopciones = [pareja, apps, dificultad, importancia, imp, gusto, region, gustoDif, Habits, goals, prof, similar]\\r\\n\\r\\n Prospectos = {}\\r\\n for option in listaopciones:\\r\\n for element in option:\\r\\n if Prospectos.has_key(element[\\\"nombre\\\"]):\\r\\n Prospectos[element[\\\"nombre\\\"]] = 1\\r\\n else:\\r\\n Prospectos[element[\\\"nombre\\\"]] = Prospectos[element[\\\"nombre\\\"]] + 1\",\n \"def item_rank(self, u, a, b, alphas, theta, transition_prob):\\n no_of_states = len(alphas[u][0])\\n\\n # calculate distribution over the states for the user at time t+1\\n p_t_plus_1 = []\\n for k in range(no_of_states):\\n total = 0\\n for l in range(no_of_states):\\n total += alphas[u][-1][k] * transition_prob[l][k]\\n p_t_plus_1.append(total)\\n# # print('\\\\np_t_plus_u1')\\n # pprint(p_t_plus_1)\\n\\n item_rank = defaultdict(float)\\n for i in range(len(theta)): # for each item\\n item_rank[i] = -sum(p_t_plus_1[k] * (1 + b[k] * theta[i][k])**(-a[k]) for k in range(no_of_states))\\n\\n# # print(item_rank)\\n items = sorted(item_rank, key=item_rank.__getitem__, reverse=True)\\n\\n return items\",\n \"def compute_user_local_sensitivity(sc, dataset, user_id, num_iters_ls):\\n\\n res = defaultdict(lambda: 0.0)\\n\\n original_recs, original_qii = compute_recommendations_and_qii(sc, dataset,\\n user_id)\\n original_recs = recommendations_to_dd(original_recs)\\n\\n res[\\\"recommendee_user_id\\\"] = user_id\\n res[\\\"recommendee_recs_l1_norm\\\"] = l1_norm(original_recs)\\n res[\\\"recommendee_qii_l1_norm\\\"] = l1_norm(original_qii)\\n res[\\\"recommendee_recs_l0_norm\\\"] = len(original_recs)\\n res[\\\"recommendee_qii_l0_norm\\\"] = len(original_qii)\\n res[\\\"perturbations\\\"] = []\\n\\n all_users = get_user_list(dataset)\\n for x in xrange(num_iters_ls):\\n if perturb_specific_user:\\n other_user_id = perturb_specific_user\\n else:\\n other_user_id = random.choice(list(set(all_users) - {user_id}))\\n print \\\"Perturbing user\\\", other_user_id, \\\"(\\\", x+1, \\\"out of\\\",\\\\\\n num_iters_ls, \\\")\\\"\\n perturbed_dataset = perturb_user_ratings(sc, dataset, other_user_id)\\n start = time.time()\\n recs, qii = compute_recommendations_and_qii(sc, perturbed_dataset, user_id)\\n stop = time.time()\\n recs = recommendations_to_dd(recs)\\n rec_ls = calculate_l1_distance(original_recs, recs)\\n qii_ls = calculate_l1_distance(original_qii, qii)\\n\\n report = {}\\n report[\\\"perturbed_user_id\\\"] = other_user_id\\n report[\\\"perturbed_recs_l1_norm\\\"] = l1_norm(recs)\\n report[\\\"perturbed_qii_l1_norm\\\"] = l1_norm(qii)\\n report[\\\"perturbed_recs_l0_norm\\\"] = len(recs)\\n report[\\\"perturbed_qii_l0_norm\\\"] = len(qii)\\n report[\\\"recs_ls\\\"] = rec_ls\\n report[\\\"qii_ls\\\"] = qii_ls\\n report[\\\"recs_ls_norm\\\"] = rec_ls/float((len(recs)*4))\\n report[\\\"qii_ls_norm\\\"] = qii_ls/float((len(qii)*4))\\n print \\\"Local sensitivity of recs: \\\", rec_ls/float((len(recs)*4))\\n print \\\"Local sensitivity of QII: \\\", qii_ls/float((len(qii)*4))\\n report[\\\"computation_time\\\"] = stop - start\\n\\n\\n res[\\\"perturbations\\\"].append(report)\\n\\n for per in res[\\\"perturbations\\\"]:\\n res[\\\"avg_recs_ls\\\"] += float(per[\\\"recs_ls\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_recs_ls\\\"] = max(res[\\\"max_recs_ls\\\"], per[\\\"recs_ls\\\"])\\n res[\\\"avg_recs_ls_norm\\\"] +=\\\\\\n float(per[\\\"recs_ls_norm\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_recs_ls_norm\\\"] = max(res[\\\"max_recs_ls_norm\\\"],\\n per[\\\"recs_ls_norm\\\"])\\n res[\\\"avg_qii_ls\\\"] += float(per[\\\"qii_ls\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_qii_ls\\\"] = max(res[\\\"max_qii_ls\\\"], per[\\\"qii_ls\\\"])\\n res[\\\"avg_qii_ls_norm\\\"] +=\\\\\\n float(per[\\\"qii_ls_norm\\\"])/len(res[\\\"perturbations\\\"])\\n res[\\\"max_qii_ls_norm\\\"] = max(res[\\\"max_recs_qii_norm\\\"],\\n per[\\\"qii_ls_norm\\\"])\\n return dict(res)\",\n \"def best_policy(self, U):\\n pi = {}\\n utility = {s:dict() for s in self.states}\\n for s in self.states:\\n for a in self.available(s):\\n utility[s][a] = self.expected_utility(a,s,U)\\n pi[s] = utility[s].keys()[utility[s].values().index(max(utility[s].values()))]\\n return pi\",\n \"def compute_kappa_score(self, scorer1, scorer2, items, matrix_weights):\\r\\n #matrice nb items\\r\\n df_n_items = pd.DataFrame(data=0, index=items, columns=items)\\r\\n for score1, score2 in zip(scorer1, scorer2):\\r\\n df_n_items[score1][score2] = df_n_items[score1][score2] + 1\\r\\n #nb items * total number of scoring items\\r\\n df_proba = df_n_items / len(scorer1)\\r\\n #df_proba with weights\\r\\n df_proba_w = df_proba * matrix_weights\\r\\n #relative observed agreement among raters\\r\\n p_a = df_proba_w.sum().sum()\\r\\n #hypothetical probability of chance agreement\\r\\n p_e = 0\\r\\n for lig in df_proba.index:\\r\\n for col in df_proba.columns:\\r\\n p_e = p_e + df_proba.loc[lig, :].sum() * \\\\\\r\\n df_proba.loc[:, col].sum() * matrix_weights.loc[lig, col]\\r\\n #kappa score\\r\\n kappa = 1 - (1 - p_a) / (1 - p_e)\\r\\n return kappa\",\n \"def get_preferences(buyer_count=5):\\n\\n\\n buyer_wants = np.random.randint(1, 4, buyer_count)\\n seller_count = sum(buyer_wants)\\n\\n buyer_start = range(seller_count)\\n seller_start = range(buyer_count)\\n\\n buyer_prefs = list()\\n seller_prefs = list()\\n\\n for i in range(buyer_count):\\n random.shuffle(buyer_start)\\n buyer_prefs.append(buyer_start[:])\\n\\n for i in range(seller_count):\\n random.shuffle(seller_start)\\n seller_prefs.append(seller_start[:])\\n\\n return buyer_prefs, seller_prefs, buyer_wants\",\n \"def get_recommendations(name, data):\\r\\n #sorts preferences in alphabetical order\\r\\n #do this to make it easier to compare\\r\\n for key in data:\\r\\n data[key] = selection_sort(data[key])\\r\\n most_similar_key = \\\"\\\"\\r\\n max_matches = 0\\r\\n for key in data:\\r\\n if not(key[-1] == \\\"$\\\" or data[key] == data[name]):\\r\\n \\\"\\\"\\\"if the person is not private or does not have the same data\\\"\\\"\\\"\\r\\n matches = num_matches(data[key], data[name])\\r\\n if matches > max_matches:\\r\\n most_similar_key = key\\r\\n max_matches = matches\\r\\n if most_similar_key == \\\"\\\":\\r\\n print(\\\"No recommendations available at this time\\\")\\r\\n return 1\\r\\n else:\\r\\n final_recommendations = []\\r\\n for x in data[most_similar_key]:\\r\\n if x not in data[name]:\\r\\n final_recommendations += [x]\\r\\n return final_recommendations\",\n \"def compare_for_list_key_value(self, item_1: Tuple[keyType, valueType], item_2: Tuple[keyType, valueType]) -> int:\\n # When one element is tuple and the other is another type, such as str,\\n # using hash value can make the '<' operator function function normally.\\n if hash(item_1[0]) != hash(item_2[0]):\\n if hash(item_1[0]) < hash(item_2[0]):\\n return -1\\n return 1\\n else:\\n tmp_1 = item_1[1]\\n tmp_2 = item_2[1]\\n # 'values' could be list or set which don't have hash() function.\\n if isinstance(item_1[1], (list, set)):\\n tmp_1 = tuple(item_1[1])\\n if isinstance(item_2[1], (list, set)):\\n tmp_2 = tuple(item_2[1])\\n if hash(tmp_1) < hash(tmp_2):\\n return -1\\n return 1\",\n \"def item_to_ids(items, user):\\r\\n sizes = [\\\"10\\\", \\\"12\\\", \\\"14\\\", \\\"16\\\", \\\"25\\\", \\\"30\\\", \\\"35\\\", \\\"40\\\"]\\r\\n if not items:\\r\\n return []\\r\\n ids = []\\r\\n names_to_id_product = get_names_preconfigured(user)\\r\\n for item in items:\\r\\n for name, product_id in names_to_id_product.items():\\r\\n # CLEAN TO REMOVE SMALL MEDIUM LARGE, AND STRIP\\r\\n item = item.strip()\\r\\n for size in sizes:\\r\\n if size in item:\\r\\n if size == \\\"10\\\" or size == \\\"25\\\":\\r\\n replace = \\\"Small\\\"\\r\\n elif size == \\\"12\\\" or size == \\\"30\\\":\\r\\n replace = \\\"Medium\\\"\\r\\n elif size == \\\"14\\\" or size == \\\"35\\\":\\r\\n replace = \\\"Large\\\"\\r\\n elif size == \\\"16\\\" or size == \\\"40\\\":\\r\\n replace = \\\"X-Large\\\"\\r\\n item = item.replace(size + '\\\"', replace).replace(size + \\\"'\\\", replace)\\r\\n # print(item, \\\" | \\\", name, editDistanceDP(item, name, len(item), len(name)) / (len(name)))\\r\\n if edit_distance_dp(item, name, len(item), len(name)) / (len(name)) < .3 or edit_distance_dp(\\r\\n item.replace(\\\"Pizza\\\", \\\"\\\"), name.replace(\\\"Dipping \\\", \\\"\\\"), len(item.replace(\\\"Pizza\\\", \\\"\\\")),\\r\\n len(name.replace(\\\"Dipping \\\", \\\"\\\"))) / (len(name)) < .1:\\r\\n ids.append(product_id)\\r\\n break\\r\\n final_ids = []\\r\\n for id in ids:\\r\\n if \\\"F_\\\" in id:\\r\\n variants = ids_to_variants(user)\\r\\n replace = variants[id][0]\\r\\n if replace == \\\"STJUDE\\\":\\r\\n replace = \\\"STJUDE10\\\"\\r\\n final_ids.append(replace)\\r\\n else:\\r\\n final_ids.append(id)\\r\\n return final_ids\\r\\n # order.add_item('P12IPAZA') # add a 12-inch pan pizza\\r\\n # order.add_item('MARINARA') # with an extra marinara cup\\r\\n # order.add_item('20BCOKE') # and a 20oz bottle of coke\\r\\n return ['P12IPAZA', 'MARINARA', '20BCOKE']\",\n \"def top_matches(self, prefs, p1):\\n #print 'top_matches', prefs, p1\\n #print '\\\\n'\\n return [(p2, self.similarity(prefs[p1], prefs[p2])) for p2 in prefs if p2 != p1]\",\n \"def _update_suspicion_2(self):\\n\\n for bucket in self.used_buckets:\\n multiplier = 1 if bucket.attacked else -1\\n for user in bucket.users:\\n user.suspicion += (1 / len(bucket)) * multiplier\",\n \"def _update_suspicion_2(self):\\n\\n for bucket in self.buckets:\\n multiplier = 1 if bucket.attacked else -1\\n for user in bucket.users:\\n user.suspicion += (1 / len(bucket)) * multiplier\",\n \"def predict(self, users, items):\\n users_t = torch.tensor(users, dtype=torch.int64, device=self.device)\\n items_t = torch.tensor(items, dtype=torch.int64, device=self.device)\\n with torch.no_grad():\\n scores = torch.mul(\\n torch.cat(\\n (self.user_encode(users_t)[0], self.user_emb(users_t)), dim=1\\n ),\\n torch.cat(\\n (self.item_encode(items_t)[0], self.item_emb(items_t)), dim=1\\n ),\\n ).sum(dim=1)\\n return scores\",\n \"def calculate_recommendations(self, vote_list, itemMatch, itemIgnored):\\n #print \\\"--------------------------------------------------\\\"\\n #print \\\"calculate_recommendations\\\"\\n #print \\\"--------------------------------------------------\\\"\\n\\n # http://www.quuxlabs.com/blog/2010/09/matrix-factorization-a-simple-tutorial-and-implementation-in-python/\\n\\n # U = np.array('users')\\n # D = np.array('video_games')\\n\\n # R = |U| cross |D|\\n\\n # We want to discover K latent features\\n\\n # Find\\n # P(a | |U| corss K matrix)\\n # Q(a | |D| cross K matrix)\\n # Such that their product approximates R\\n # R approx= P cross transpose(Q) = hat(R)\\n #\\n\\n # r[i][j] = transpose(p)[i] * q[j]\\n # = sum( 1..k, p[i][k] * q[k][j] )\\n\\n # e[i][j]**2 = (r[i][j] - hat(r)[i][j])**2\\n # = (r[i][j] - sum( 1..K, p[i][k] * q[k][j]))**2\\n # squared error, estimated rating can be either higher or lower than the real thing\\n\\n # find the gradient\\n # diff(e[i][j]**2, p[i][k]) = -2*(r[i][j] - hat(r)[i][j]) * (q[k][j]) = -2*e[i][j] * q[k][j]\\n # diff(e[i][j]**2, q[k][j]) = -2*(r[i][j] - hat(r)[i][j]) * (p[i][k]) = -2*e[i][j] * p[i][k]\\n\\n # update rules\\n # alpha = settings.alpha # learning_rate\\n # alpha = 0.0002 # learning_rate\\n # p[i][k]' = p[i][k] + alpha * diff(e[i][j]**2, p[i][k])\\n # = p[i][k] + 2 * alpha * e[i][j] * q[k][j]\\n # q[k][j]' = q[k][j] + alpha * diff(e[i][j]**2, q[k][j])\\n # = q[k][j] + 2 * alpha * e[i][j] * p[i][k]\\n\\n # training data\\n # T = (u[i], d[j], r[i][j])\\n # np.array()\\n\\n # iterate until convergance\\n # E = sum((u[i], d[j], r[i][j]) in T, e[i][j])\\n # = sum((u[i], d[j], r[i][j]) in T, r[i][j]\\n # - sum(1..k, p[i][k]*q[k][j]))**2\\n\\n # regularization\\n # beta = 0.02\\n # e[i][j]**2 = (r[i][j] - sum(1..K, p[i][j]*q[k][j]))**2\\n # + ((beta/2) * sum(1..K, norm(P)**2 + norm(Q)**2))\\n #\\n # p[i][k]' = p[i][k] + alpha * (2 * e[i][j] * q[k][j] - beta * p[i][k])\\n # q[k][j]' = q[k][j] + alpha * (2 * e[i][j] * p[i][k] - beta * q[k][j])\\n\\n data = np.array(vote_list)\\n\\n encoder = OneHotEncoder()\\n\\n users = data[:,0]\\n unique_users = list(set(users))\\n for i in range(len(users)):\\n users[i] = unique_users.index(users[i])\\n\\n video_games = data[:,1]\\n unique_games = list(set(video_games))\\n for i in range(len(video_games)):\\n video_games[i] = unique_games.index(video_games[i])\\n\\n ratings = data[:,2]\\n M = len(set(video_games))\\n N = len(set(users))\\n R = np.zeros((N,M))\\n for i in range(len(users)):\\n user = users[i]\\n game = video_games[i]\\n rating = ratings[i]\\n R[user][game] = rating\\n\\n K = 2\\n\\n P = np.random.rand(N,K)\\n Q = np.random.rand(M,K)\\n\\n nP, nQ = self.matrix_factorization(R, P, Q, K)\\n nR = np.dot(nP, nQ.T)\\n\\n itemMatch = {}\\n for i in range(N):\\n user = unique_users[i]\\n itemMatch[user] = []\\n for j in range(M):\\n if R[i][j] == 0:\\n video_game = unique_games[j]\\n recommendation = (video_game, nR[i][j])\\n itemMatch[user].append(recommendation)\\n itemMatch[None] = []\\n print 'pmf recommendations', itemMatch.items()\\n print '\\\\n'\\n recommendations = itemMatch.items()\\n\\n # returns\\n # [\\n # (<user1>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # (<user2>, [\\n # (\\\"<object_identifier1>\\\", <score>),\\n # (\\\"<object_identifier2>\\\", <score>),\\n # ]),\\n # ]\\n\\n return recommendations\",\n \"def agg_preferences(prefs_list):\\n aggregated_preferences=defaultdict(lambda: 0)\\n for els in prefs_list:\\n if els[0]<els[1]:\\n aggregated_preferences[(els[0],els[1])]+=1\\n else:\\n aggregated_preferences[(els[1],els[0])]-=1\\n return aggregated_preferences\",\n \"def update_user_user_sim(self, user_A_info, user_B_info, item_popularity):\\n user_A_id, user_A_time = user_A_info\\n user_B_id, user_B_time = user_B_info\\n try:\\n row = self.sim_matrix[user_A_id]\\n except KeyError:\\n row = self.sim_matrix[user_A_id] = {} # all reference\\n IIF = log(1+item_popularity)\\n if self.timestamp:\\n time_elapse = Model.time_elapse(user_A_time, user_B_time)\\n score = 1*time_elapse/IIF\\n else:\\n score = 1/IIF\\n try:\\n row[user_B_id] += score\\n except KeyError:\\n row[user_B_id] = score\",\n \"def itembase(user_id):\\n frame1 = pd.concat([pd.DataFrame(REVIEWS[x]) for x in REVIEWS])\\n filtered_data = recommender.filtering_not_city()\\n businesses = pd.DataFrame(filtered_data).set_index('business_id')\\n frame2 = frame1.drop_duplicates(subset=[\\\"user_id\\\", \\\"business_id\\\"], keep='last', inplace=False)\\n\\n utility_matrix = pivot_reviews(frame2)\\n\\n similarity = create_similarity_matrix_euclid(utility_matrix)\\n\\n for business in businesses.index:\\n neighborhood = select_neighborhood(similarity, utility_matrix, user_id, business)\\n prediction = weighted_mean(neighborhood, utility_matrix, user_id)\\n businesses.ix[business, 'predicted rating'] = prediction\\n\\n sorted_prediction = businesses.sort_values(by=['predicted rating'], ascending=False)\\n sorted_prediction2 = sorted_prediction.drop(columns=['predicted rating'])\\n sorted_prediction2 = sorted_prediction2.reset_index()\\n sorted_prediction3 = sorted_prediction.reset_index()\\n return sorted_prediction2.to_dict(orient='records'), sorted_prediction3.to_dict(orient='records')\",\n \"def percentage(my_list, item):\\n return 100.0 * frequency(my_list, item)\",\n \"def get_neigh_info(self, user, item):\\r\\n batch_u_neigh = self.u_neigh[user]\\r\\n batch_i_neigh = self.i_neigh[item]\\r\\n return batch_u_neigh, batch_i_neigh\",\n \"def common_likes(self, user):\\n\\n self_like_ids = set(self.likes.keys()) if self.likes else set()\\n other_like_ids = set(user.fb_profile.likes.keys()) if user.fb_profile.likes else set()\\n\\n common_like_ids = self_like_ids.intersection(other_like_ids)\\n\\n return common_like_ids\",\n \"def similarRecommendation(user_preferences: dict, matcher: NodeMatcher):\\r\\n similarE = user_preferences[\\\"gustos_similares\\\"]\\r\\n equal_styles = list(matcher.match(\\\"User\\\",similar = similarE))\\r\\n return equal_styles\",\n \"def total_profit(knapsack, items, weight):\\n return knapsack[items][weight]\",\n \"def count_score(data: GameData) -> Tuple[int, int]:\\n score_user = score_ai = 0\\n\\n for item in data.items:\\n if not hasattr(item, \\\"prediction_user\\\"):\\n return score_user, score_ai\\n\\n if item.prediction_user == item.ground_truth:\\n score_user += 1\\n\\n if item.prediction_ai[0] == item.ground_truth:\\n score_ai += 1\\n\\n return score_user, score_ai\",\n \"def friend_overlap(users):\\n ###TODO-- Completed\\n\\n #Creating a list of tuples to store the values for number of shared accounts by each of the user\\n overlap_tuples = []\\n\\n #Trying for all the combination if user's without repetition\\n for outer_idx,_ in enumerate(users):\\n for inner_idx,_ in enumerate(users):\\n if (inner_idx != len(users)-1) and (outer_idx < inner_idx+1):\\n #Creating a SET of friends for 2 users and finding the INTERSECTION i.e. Common friends between these users\\n overlap_tuples.append(tuple((users[outer_idx]['screen_name'],users[inner_idx+1]['screen_name'],\\n len(list(set(users[outer_idx]['friends']) & set(users[inner_idx+1]['friends']))))))\\n\\n #Sort based on first KEY as N i.e. number of shared account in descending order,\\n # for ties break using screen_name of user one, further on screen_name of user two\\n return sorted(overlap_tuples, key=lambda x:[-x[2], x[0], x[1]])\\n\\n #for perm in combinations(screen_names,2):\\n # overlap_tuples.append(tuple(perm[0],perm[1],len(list(set(user[perm[0]]['friends']) & set(perm[1]['friends'])))))\\n #print(len(list(set(users[0]['friends']) & set(users[1]['friends']))))\",\n \"def item_based_recommendation(\\n self, test_dataRDD,\\n item_based_dict_bd, itembased_sim_pair_dict_bd, item_info_bd):\\n return test_dataRDD.map(\\n lambda line: self.item_based_prediction(\\n line, item_based_dict_bd,\\n itembased_sim_pair_dict_bd, item_info_bd))\",\n \"def create_user_item_array(self):\\n user_em = self.user_factors.weight.detach()\\n item_em = self.product_factors.weight.detach()\\n user_b = self.user_bias.weight.detach()\\n item_b = self.product_bias.weight.detach()\\n\\n user_item_array = (item_em + item_b) @ (user_em + user_b).transpose(0, 1)\\n preds = self._prob_to_class(user_item_array).numpy()\\n\\n return preds\",\n \"def apriori(TDB,supMin):\\n \\\"\\\"\\\" subMin is ......... \\\"\\\"\\\"\\n dic = dict()\\n keys = set()\\n for s in TDB:\\n for element in s:\\n keys.add(frozenset(element))\\n keys = list(keys)\\n\\n while len(keys)>=1:\\n dic.clear()\\n for key in keys:\\n f = getFreq(TDB,key)\\n if f >= supMin:\\n dic[key]=f\\n printItemSet(dic)\\n keys = list(dic.keys())\\n newKeys = set()\\n for i in range (0,len(keys)-1):\\n for j in range(i+1,len(keys)):\\n newKey = frozenset.union(keys[i],keys[j])\\n newKeys.add(newKey)\\n keys = newKeys\\n return dic\",\n \"def personalization(prediction, n):\\n # prediction\\n # n top n recommendation\\n\\n top_n = get_top_n(prediction, n)\\n\\n rec_dict = {}\\n for uid, user_ratings in top_n.items():\\n rec_dict[uid] = [iid for (iid, _) in user_ratings]\\n\\n rec_user_ls = [pred[0] for pred in prediction]\\n rec_item_ls = [pred[1] for pred in prediction]\\n\\n unique_rec_user_ls = np.unique(rec_user_ls)\\n unique_rec_item_ls = np.unique(rec_item_ls)\\n\\n # assign each item with index number\\n unique_rec_item_dict = {item: ind for ind,\\n item in enumerate(unique_rec_item_ls)}\\n\\n n_unique_rec_user = len(unique_rec_user_ls)\\n n_unique_rec_item = len(unique_rec_item_ls)\\n\\n # recommended user item matrix\\n rec_matrix = np.zeros(shape=(n_unique_rec_user, n_unique_rec_item))\\n\\n # represent recommended item for each user as binary 0/1\\n for user in range(n_unique_rec_user):\\n # get userid\\n user_id = unique_rec_user_ls[user]\\n # get rec item list\\n item_ls = rec_dict[user_id]\\n\\n for item_id in item_ls:\\n # get item index\\n item = unique_rec_item_dict[item_id]\\n rec_matrix[user, item] = 1\\n\\n # calculate cosine similarity matrix across all user recommendations\\n similarity = cosine_similarity(X=rec_matrix, dense_output=False)\\n # calculate average of upper triangle of cosine matrix\\n upper_right = np.triu_indices(similarity.shape[0], k=1)\\n # personalization is 1-average cosine similarity\\n score = 1 - np.mean(similarity[upper_right])\\n return score\",\n \"def item_based_prediction(self, line, rating_bd, sim_bd, item_bd):\\n def sort_by_time(pairs):\\n \\\"\\\"\\\"For each user, sort its rating records based on its datetime.\\n More specifically, if time_a > time_b,\\n then: time_a <- x, time_b <- x + 1.\\n \\\"\\\"\\\"\\n pairs = sorted(pairs, key=lambda line: line[2], reverse=False)\\n order = 0\\n out = []\\n for i in range(len(pairs)):\\n if i != 0 and pairs[i][2] == pairs[i - 1][2]:\\n out += [(pairs[i][0], pairs[i][1], order)]\\n else:\\n order += 1\\n out += [(pairs[i][0], pairs[i][1], order)]\\n return out\\n\\n def f_decay(cur, t_ui):\\n return np.exp(- self.alpha * (cur - t_ui))\\n\\n def add_decay(pairs):\\n \\\"\\\"\\\"add decay rate to the pairs.\\n Args:\\n pairs: sim * rating, sim, time\\n \\\"\\\"\\\"\\n new_pairs = sort_by_time(pairs)\\n current_time = max(map(lambda line: line[2], new_pairs)) + 1\\n final_pairs = [\\n (pair[0] * f_decay(current_time, pair[2]),\\n pair[1] * f_decay(current_time, pair[2]))\\n for pair in new_pairs]\\n return sum(map(lambda line: line[0], final_pairs)) / sum(\\n map(lambda line: line[1], final_pairs))\\n\\n def prediction(uid, pair, rating_bd, sim_bd, item_bd):\\n \\\"\\\"\\\"do the prediction. It can either add decay rate or not,\\n which is decided by `method`.\\n \\\"\\\"\\\"\\n iid, real_rating = pair[0], pair[1]\\n if iid not in sim_bd.value.keys():\\n return ()\\n iid_neighbors = [\\n (i[0], i[1], rating_bd.value[i[0]]) for i in sim_bd.value[iid]]\\n average_iid_rating = item_bd.value[iid][0]\\n sim_rating = []\\n for info in iid_neighbors:\\n niid, nsim, ratings = info\\n sim_rating += [\\n (iid, nsim, rating[1] - item_bd.value[niid][0], rating[2])\\n for rating in ratings if uid in rating[0]]\\n if len(sim_rating) != 0:\\n sim_ratings = [\\n (line[1] * line[2], abs(line[1]), line[3])\\n for line in sim_rating]\\n predicted_rating_no_decay = average_iid_rating + sum(\\n map(lambda line: line[0], sim_ratings)) / sum(\\n map(lambda line: line[1], sim_ratings))\\n predicted_rating_decay = \\\\\\n average_iid_rating + add_decay(sim_ratings)\\n else:\\n predicted_rating_no_decay = average_iid_rating\\n predicted_rating_decay = average_iid_rating\\n return iid, real_rating, \\\\\\n self.bound_rating(predicted_rating_no_decay), \\\\\\n self.bound_rating(predicted_rating_decay)\\n\\n uid, pairs = line\\n return uid, [\\n prediction(uid, pair, rating_bd, sim_bd, item_bd)\\n for pair in pairs]\",\n \"def ap(self, result, next_item):\\n if next_item in result.index:\\n rank = result.index.get_loc(next_item) + 1\\n return 1.0 / rank\\n else:\\n return 0\",\n \"def test_reasonable_auction(self):\\n # I have no preferences\\n bids = [Cost(ITEM1, ACTOR1, 1000),\\n Cost(ITEM2, ACTOR1, 1000),\\n Cost(ITEM3, ACTOR1, 1000),\\n Cost(ITEM4, ACTOR1, 1000),\\n Cost(ITEM5, ACTOR1, 1000),\\n\\n # I have linear preferences\\n Cost(ITEM1, ACTOR2, 700),\\n Cost(ITEM2, ACTOR2, 800),\\n Cost(ITEM3, ACTOR2, 1000),\\n Cost(ITEM4, ACTOR2, 1200),\\n Cost(ITEM5, ACTOR2, 1300),\\n\\n # I have non-linear preferences\\n Cost(ITEM1, ACTOR3, 400),\\n Cost(ITEM2, ACTOR3, 800),\\n Cost(ITEM3, ACTOR3, 1000),\\n Cost(ITEM4, ACTOR3, 1200),\\n Cost(ITEM5, ACTOR3, 1600),\\n\\n # I have arbitrary preference\\n Cost(ITEM1, ACTOR4, 2435),\\n Cost(ITEM2, ACTOR4, 305),\\n Cost(ITEM3, ACTOR4, 310),\\n Cost(ITEM4, ACTOR4, 1725),\\n Cost(ITEM5, ACTOR4, 225),\\n\\n # I have strong preferences\\n Cost(ITEM1, ACTOR5, 0),\\n Cost(ITEM2, ACTOR5, 0),\\n Cost(ITEM3, ACTOR5, 0),\\n Cost(ITEM4, ACTOR5, 0),\\n Cost(ITEM5, ACTOR5, 5000)]\\n result = self.splitter.split(ITEMS[:5], ACTORS[:5], bids)\\n expected = [(ITEM1, ACTOR4, None),\\n (ITEM2, ACTOR1, None),\\n (ITEM3, ACTOR3, None),\\n (ITEM4, ACTOR2, None),\\n (ITEM5, ACTOR5, None)]\\n item_assignments_present(self, result, expected)\",\n \"def efficientShopping(family, items, NoOfItems):\\r\\n cost = 0\\r\\n result = {}\\r\\n # items are sorted by price\\r\\n # items closer to list start are items that family wants\\r\\n for f in range(len(family)):\\r\\n member_data = chooseItems(family[f], items, NoOfItems)\\r\\n cost += member_data[0]\\r\\n result[family[f][1] + 1] = member_data[1]\\r\\n # get data in sorted order by family member id\\r\\n final_data = {}\\r\\n for i in range(len(family)):\\r\\n final_data[i+1] = result[i+1]\\r\\n final_data[\\\"total\\\"] = cost\\r\\n return final_data\",\n \"def recommend_me_team(self, user_id: int, user_ids_per_group: list, n_recommendations: int):\\n res_arr = np.array([self.user_similarity.loc[user_id, group_ids].mean() for group_ids in user_ids_per_group])\\n res_inds = np.argsort(res_arr)[::-1][:n_recommendations]\\n return res_inds, res_arr[res_inds]\",\n \"def predict(self, user, item):\\n return self.user_vectors[user, :].dot(self.item_vectors[item, :].T)\",\n \"def get_participation_in_pairing(self):\\n entries = self.c.select(pairing=1)\\n\\n frequency = dict()\\n pairs = []\\n for e in entries:\\n c1, c2 = e.data['parents']\\n pairs.append(tuple(sorted([c1, c2])))\\n if c1 not in frequency.keys():\\n frequency[c1] = 0\\n frequency[c1] += 1\\n if c2 not in frequency.keys():\\n frequency[c2] = 0\\n frequency[c2] += 1\\n return (frequency, pairs)\",\n \"def compare_users(userA, userB):\\n reader = open(\\\"similarities.txt\\\", \\\"r\\\")\\n lines = reader.readlines()\\n similarity = None\\n for line in lines:\\n a, b, sim = line.split(\\\"\\\\t\\\")\\n if userA == a and userB == b:\\n print(sim)\\n similarity = float(sim)\\n\\n reader2 = open(\\\"sorted_similarities.txt\\\", \\\"r\\\")\\n lines = reader2.readlines()\\n index = 0.0\\n for line in lines:\\n sim = float(line)\\n if similarity == sim:\\n return 1.0 - (float(index) / len(lines))\\n index += 1\\n\\n return None\\n \\n \\n \\\"\\\"\\\"\\n if len(sim_dict.keys()) == 0:\\n return None\\n\\n ranked = sorted(sim_dict.keys(), key=lambda x: sim_dict[x],\\n reverse=True)\\n try:\\n index = ranked.index(userB)\\n percentile = 1.0 - (float(index) / len(sim_dict.keys()))\\n return int(100 * percentile)\\n except:\\n return None\\n \\\"\\\"\\\"\",\n \"def single_user_recommendation_vector(self, user_ratings):\\r\\n\\r\\n ratings_vector = self.ratings_matrix.get_ratings_vector(user_ratings)\\r\\n\\r\\n user_similarity_profile = self.calculate_user_similarity_profile(ratings_vector)\\r\\n\\r\\n return self.calculate_item_relevance_scores(user_similarity_profile)\",\n \"def recommend_new(self, user_id, N=10):\\n scores = self.user_factors[user_id] @ self.product_factors.T\\n bought_indices = self.product_user_matrix.T[user_id].nonzero()[1]\\n count = N + len(bought_indices)\\n ids = np.argpartition(scores, -count)[-count:]\\n best = sorted(zip(ids, scores[ids]), key=lambda x: -x[1])\\n return list(itertools.islice((rec for rec in best if rec[0] not in bought_indices), N))\",\n \"def step(self, user: torch.tensor, item: torch.tensor,\\n rating: torch.tensor, preference: torch.tensor):\\n pass\",\n \"def map_user_to_ratings(reviews):\\n\\tuser_ratings = dict()\\n\\tfor review in reviews:\\n\\t\\tuser = review[0]\\n\\t\\tif user not in user_ratings:\\n\\t\\t\\tuser_ratings[user] = 0\\n\\t\\telse:\\n\\t\\t\\tuser_ratings[user] = user_ratings[user] + 1\\n\\n\\treturn user_ratings\",\n \"def test_get_user_rankings(self):\\n user = User(name=u'no win', email=u'generic@thingy.com')\\n user.put()\\n \\n userone = User(name=u'one win', email=u'generic@thingy.com', total_played=1, wins=1)\\n userone.put()\\n \\n usertwo = User(name=u'two wins', email=u'generic@thingy.com', total_played=2, wins=1)\\n usertwo.put()\\n \\n user_rankings = users.get_user_rankings()\\n self.assertEquals(len(user_rankings), 2)\\n self.assertEquals(user_rankings.pop().key, usertwo.key)\\n self.assertEquals(user_rankings.pop().key, userone.key)\",\n \"def chosen_items(sack, items, weight):\\n total = total_profit(sack, items, weight)\\n chosen = []\\n \\n while total != 0:\\n for i in range(items + 1):\\n if total in sack[i]:\\n chosen.append(i) \\n total = total - profit[i - 1] \\n break \\n \\n return sorted(chosen)\",\n \"def _update_suspicion_1(self):\\n\\n for bucket in self.used_buckets:\\n multiplier = 1 if bucket.attacked else 0\\n for user in bucket.users:\\n user.suspicion += multiplier\",\n \"def _pval_pairs(self, idx0, idx1):\\n return self._test_pairs(idx0=idx0, idx1=idx1)\",\n \"def estimate(self, u, j):\\n if not (self.trainset.knows_user(u) and self.trainset.knows_item(j)):\\n raise PredictionImpossible('User and/or item is unknown.')\\n\\n u_ratings = self.trainset.ur[u]\\n\\n if self.weighting == 'linear':\\n weight = sum(self.freqs[i, j, self.to_index(r)] for i, r in u_ratings)\\n score = sum(self.sums[i, j, self.to_index(r)] for i, r in u_ratings)\\n return score / weight\\n\\n # self.weighting == 'log' or None\\n weights = [self.freqs[i, j, self.to_index(r)] for i, r in u_ratings]\\n reciprocals = [1 / w if w else 0 for w in weights]\\n scores = [self.sums[i, j, self.to_index(r)] for i, r in u_ratings]\\n scores = [s * w for s, w in zip(scores, reciprocals)]\\n\\n if self.weighting is None:\\n return np.mean(scores)\\n # self.weighting == 'log'\\n logs = [np.log(w + 1) if w >= 1 else 0 for w in weights]\\n return np.dot(scores, logs) / np.sum(logs)\",\n \"def compute_multiuser_local_sensitivity(sc, dataset, num_iters_ls,\\n num_users_ls):\\n res = []\\n users_already_processed = set()\\n all_users = list(get_user_list(dataset))\\n for x in xrange(num_users_ls):\\n while True:\\n cur_user = random.choice(all_users)\\n print \\\"Trying user\\\", cur_user\\n if cur_user in users_already_processed:\\n print \\\"Oops, we've already processed this one\\\"\\n continue\\n if max_movies_per_user == 0:\\n break\\n print \\\"Looking at their ratings\\\"\\n u_ratings = get_ratings_from_uid(dataset, cur_user)\\n u_ratings_list = u_ratings.collect()\\n l = len(u_ratings_list)\\n if l > max_movies_per_user:\\n print \\\"This user has too many movies: \\\",\\\\\\n l, \\\">\\\", max_movies_per_user\\n users_already_processed.add(cur_user)\\n continue\\n else:\\n print \\\"This user with\\\", l, \\\"movies \\\" +\\\\\\n \\\"rated is fine!\\\"\\n break\\n print \\\"Probing user\\\", cur_user\\n report = compute_user_local_sensitivity(sc, dataset, cur_user,\\n num_iters_ls)\\n users_already_processed.add(cur_user)\\n res.append(report)\\n return res\",\n \"def recommend_items(self, dataset, u, max_items=10, return_scores=True, item_features=None):\\n try:\\n r = (self.similarity_matrix * dataset[u].T).toarray().flatten()\\n except AttributeError:\\n raise AttributeError('you must call fit() before trying to recommend items')\\n known_items = set(dataset[u].indices)\\n recs = []\\n for i in r.argsort()[::-1]:\\n if i not in known_items:\\n if return_scores:\\n recs.append((i, r[i]))\\n else:\\n recs.append(i)\\n if len(recs) >= max_items:\\n break\\n return recs\",\n \"def recommend(self, user):\\n K = self.n_sim_user\\n N = self.n_rec_movie\\n rank = dict()\\n watched_movies = self.trainset[user]\\n\\n # v=similar user, wuv=similarity factor\\n for v, wuv in sorted(self.user_sim_mat[user].items(),\\n key=itemgetter(1), reverse=True)[0:K]:\\n for movie in self.trainset[v]:\\n if movie in watched_movies:\\n continue\\n # predict the user's \\\"interest\\\" for each movie\\n rank.setdefault(movie, 0)\\n rank[movie] += wuv\\n # return the N best movies\\n return sorted(rank.items(), key=itemgetter(1), reverse=True)[0:N]\",\n \"def _update_suspicion_1(self):\\n\\n for bucket in self.buckets:\\n multiplier = 1 if bucket.attacked else 0\\n for user in bucket.users:\\n user.suspicion += multiplier\",\n \"def recommendations(self):\\n return [user for user in self.tags.similar_objects() if user.status == UserStatus.APPROVED]\",\n \"def predict(self, user, item):\\n pred = self.global_bias + self.user_bias[user] + self.item_bias[item]\\n pred += self.U[user, :].dot(self.I[:, item])\\n return pred\",\n \"def getSupport(item):\\n return float(freqSet[item]) / len(transactionList)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6196895","0.6023507","0.6007207","0.59735894","0.5927089","0.59151995","0.5914826","0.590741","0.5795329","0.56757665","0.56184","0.5602994","0.5584905","0.55800134","0.5564539","0.5547924","0.55471706","0.54899234","0.5459986","0.5451552","0.54258966","0.54209244","0.5388015","0.5376603","0.53502774","0.53469896","0.5344142","0.53437376","0.5332137","0.5330267","0.53158444","0.53101474","0.5292084","0.5282267","0.5282261","0.5275663","0.5265569","0.52614164","0.5260824","0.5260074","0.5250618","0.5219643","0.52104336","0.5196843","0.51860064","0.5154824","0.51463777","0.51354796","0.5130657","0.51295996","0.5129141","0.51222974","0.51119035","0.5108723","0.5102208","0.51010215","0.5094492","0.5079583","0.50752753","0.5061997","0.5056326","0.50468946","0.5042581","0.5042548","0.5036664","0.5030155","0.50270367","0.50080675","0.50052345","0.49937662","0.49891025","0.49871227","0.49816456","0.49788553","0.49734733","0.49709338","0.49675348","0.49594465","0.4954356","0.49522278","0.4948908","0.49416783","0.49347872","0.49346521","0.4930449","0.49277353","0.49215943","0.4921339","0.49192226","0.49185002","0.49126554","0.49081507","0.49062407","0.4905769","0.49048883","0.48993126","0.4893923","0.48883414","0.48859063","0.48853117","0.48825967"],"string":"[\n \"0.6196895\",\n \"0.6023507\",\n \"0.6007207\",\n \"0.59735894\",\n \"0.5927089\",\n \"0.59151995\",\n \"0.5914826\",\n \"0.590741\",\n \"0.5795329\",\n \"0.56757665\",\n \"0.56184\",\n \"0.5602994\",\n \"0.5584905\",\n \"0.55800134\",\n \"0.5564539\",\n \"0.5547924\",\n \"0.55471706\",\n \"0.54899234\",\n \"0.5459986\",\n \"0.5451552\",\n \"0.54258966\",\n \"0.54209244\",\n \"0.5388015\",\n \"0.5376603\",\n \"0.53502774\",\n \"0.53469896\",\n \"0.5344142\",\n \"0.53437376\",\n \"0.5332137\",\n \"0.5330267\",\n \"0.53158444\",\n \"0.53101474\",\n \"0.5292084\",\n \"0.5282267\",\n \"0.5282261\",\n \"0.5275663\",\n \"0.5265569\",\n \"0.52614164\",\n \"0.5260824\",\n \"0.5260074\",\n \"0.5250618\",\n \"0.5219643\",\n \"0.52104336\",\n \"0.5196843\",\n \"0.51860064\",\n \"0.5154824\",\n \"0.51463777\",\n \"0.51354796\",\n \"0.5130657\",\n \"0.51295996\",\n \"0.5129141\",\n \"0.51222974\",\n \"0.51119035\",\n \"0.5108723\",\n \"0.5102208\",\n \"0.51010215\",\n \"0.5094492\",\n \"0.5079583\",\n \"0.50752753\",\n \"0.5061997\",\n \"0.5056326\",\n \"0.50468946\",\n \"0.5042581\",\n \"0.5042548\",\n \"0.5036664\",\n \"0.5030155\",\n \"0.50270367\",\n \"0.50080675\",\n \"0.50052345\",\n \"0.49937662\",\n \"0.49891025\",\n \"0.49871227\",\n \"0.49816456\",\n \"0.49788553\",\n \"0.49734733\",\n \"0.49709338\",\n \"0.49675348\",\n \"0.49594465\",\n \"0.4954356\",\n \"0.49522278\",\n \"0.4948908\",\n \"0.49416783\",\n \"0.49347872\",\n \"0.49346521\",\n \"0.4930449\",\n \"0.49277353\",\n \"0.49215943\",\n \"0.4921339\",\n \"0.49192226\",\n \"0.49185002\",\n \"0.49126554\",\n \"0.49081507\",\n \"0.49062407\",\n \"0.4905769\",\n \"0.49048883\",\n \"0.48993126\",\n \"0.4893923\",\n \"0.48883414\",\n \"0.48859063\",\n \"0.48853117\",\n \"0.48825967\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":4996,"cells":{"query":{"kind":"string","value":"calculate latent factors using the alternating least square method applicable to computing both user factors and item factors"},"document":{"kind":"string","value":"def alternate_ls (u_num, Y, P, C, reg):\n\n\t# get # of items/users and # of latent factors\n\t[i_num, f_num] = Y.shape\n\n\t# output buffer\n\tX = np.zeros((u_num, f_num))\n\n\t# precalculate YtY to improve the performance\n\tYtY = Y.T * Y\n\n\t# iterate over each user/item\n\tfor u in range(u_num):\n\n\t\t# store the diagonal elements of the matrix Cu discussed in the paper in a vector\n\t\tCu = C[u,:]\n\n\t\t# store the coresponding row/column of the preference matrix\n\t\tPu = P[u,:]\n\n\t\t# compute Cu-I\n\t\tCu_I = Cu - 1\n\n\t\t# calculate Yt(Cu-I)Y\n\t\tYtCu_IY = np.zeros((f_num, f_num))\n\t\tCuIY = np.multiply(Y, Cu_I.T) # weight each row of Y with Cu-I\n\t\tfor row in range(f_num):\n\t\t\tfor col in range(f_num):\n\t\t\t\tYtCu_IY[row,col] = Y[:,row].T * CuIY[:,col]\n\t\t\n\t\t# left term : ((YtCuY + regI)^(-1)) = (YtY + Yt(Cu-I)Y + regI)^(-1)\n\t\tleft_inv = YtY + YtCu_IY + reg*np.eye(f_num)\n\t\tleft = np.linalg.inv(left_inv)\n\n\t\t# right term : YtCuPu\n\t\tright = Y.T * np.multiply(Cu.T, Pu.T)\n\n\t\t# compute the latent factor of the user/item\n\t\tx = left * right\n\t\t\n\t\t# store it in a matrix\n\t\tX[u,:] = x.T\n\n\t# return an MxF or NxF matrix\n\treturn np.matrix(X)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_factors():","def factors(self):\n X = [Var(i,2) for i in range(self.nvar)]\n factors = [Factor([],np.exp(self.c))] \n # TODO: exclude if zero? or exclude if inf/-inf, or if in \"assigned\", or?\n factors = factors + [Factor([X[i]],[-th,th]).exp() for i,th in enumerate(self.h) if self.dims[i]>1]\n L = coo(self.L)\n factors = factors + [Factor([X[i],X[j]],[[th,-th],[-th,th]]).exp() for i,j,th in zip(L.row,L.col,L.data) if i<j]\n return factors\n # TODO: should we exponentiate if isLog not True? ","def factor_mat(all_dat, f_num, iterations, regularization):\n\n\t# get # of users and # of items\n\t[u_num, i_num] = all_dat.shape\n\n\t# init user factors and item factors with random values\n\tu_fac = np.matrix(np.random.rand(u_num, f_num))\t# MxF\n\ti_fac = np.matrix(np.random.rand(i_num, f_num))\t# NxF\n\n\t# calculate the preference matrix\n\tpreference = cal_preference(all_dat)\n\n\t# calculate the confidence matrix\n\tconfidence = cal_confidence(all_dat)\n\t\n\t# recalculate the user factors and item factors using the alternating least square method\n\tfor itr in range(iterations):\n\t\tu_fac = alternate_ls(u_num, i_fac, preference, confidence, regularization)\n\t\t#print itr, \"u_fac\"\n\t\ti_fac = alternate_ls(i_num, u_fac, preference.T, confidence.T, regularization)\n\t\t#print itr, \"i_fac\"\n\t\n\t# save the output\n\tdf = pd.DataFrame(u_fac)\n\tdf.to_csv(\"tmp/u_fac.tmp\", index=False, header=False, sep='\\t', encoding='utf-8')\n\tdf = pd.DataFrame(i_fac.T)\n\tdf.to_csv(\"tmp/i_fac.tmp\", index=False, header=False, sep='\\t', encoding='utf-8')\n\n\t# an MxF user factor matrix and an FxN item factor matrix\n\treturn [u_fac, i_fac.T]","def test_lu_factor():\n\t#[A, b] = lu_read('test1.txt')\n\t# it is poor form to read an external file into a test function, as above\n\tA = np.array([\n\t\t[ 2., 3., -4., 2.],\n\t\t[-4., -5., 6., -3.],\n\t\t[ 2., 2., 1., 0.],\n\t\t[-6., -7., 14., -4.]])\t\n\tLU,p = lu_factor(A, pivot=False)\n\tLU_soln = np.array([\n\t\t[ 2, 3,-4, 2],\n\t\t[-2, 1,-2, 1],\n\t\t[ 1,-1, 3,-1],\n\t\t[-3, 2, 2, 2]])\t\n\tassert norm(LU - LU_soln) < 1.e-10\t\n\n\n\t# test 2\n\t[A2, b2] = lu_read('test2.txt')\t\t\t\t\t\t# read a matrix and RHS vector\n\tLU2,p2 = lu_factor(A2) \t\t\t\t\t\t\t\t# change display to False when LU_FACTOR working\n\tLU_soln2 = np.array([\n\t\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\n\t\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\n\t\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\n\t\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\n\t\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\n\t\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\n\t\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\n\t\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\n\t\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\n\tassert norm(LU2 - LU_soln2) < 1.e-10","def factorsWith(self,v,copy=True):\n Lv = self.L.getrow(v).tocoo();\n factors = [Factor([Var(int(v),2)],[-th,th]).exp() for th in [self.h[v]] if self.dims[i]>1]\n factors = factors + [Factor([Var(int(v),2),Var(int(j),2)],[[th,-th],[-th,th]]).exp() for j,th in zip(Lv.col,Lv.data)]\n return factors","def _als_partial_step_explicit(self, user_mode):\n # DONE minmize loss function and update factors\n # Loss = (R - X * Y^T)^2 + λ_x * ||X||^2 + λ_y * ||Y||^2\n # X = ((Y^T * Y) + λ_x * I)^-1 * (R * Y) for dLoss / dX == 0\n # Useful functions: np.linalg.inv or np.linalg.solve\n if user_mode:\n fixed_factors = self._item_factors\n updated_factors = self._user_factors\n ratings = self._ratings\n reg_loss = self._user_reg_loss\n else:\n fixed_factors = self._user_factors\n updated_factors = self._item_factors\n ratings = self._ratings.T\n reg_loss = self._item_reg_loss\n \n A = (fixed_factors.T).dot(fixed_factors)\n A += np.eye(A.shape[0]) * reg_loss\n \n B = ratings.dot(fixed_factors)\n \n \n for row in range(updated_factors.shape[0]):\n updated_factors[row, : ] = np.linalg.solve(A, B[row])","def factor(self, A):\n \n self.m, self.n = A.shape\n \n if self.use_sub_factor:\n self.sub_factor(A)\n else:\n self.A_factorized = spla.factorized(A)\n \n #if self.A_factorized is not None:\n # self.A_factorized.free() \n #self.A_factorized = pardiso.Factor(A.tocsr())","def get_factors(self, triples):\n pass","def factorsWithAny(self,vs):\n factors = []\n for v in vs:\n factors += [Factor([Var(int(v),2)],[-th,th]).exp() for th in [self.h[v]] if self.dims[i]>1]\n for u in self.markovBlanket(v):\n if u not in vs or v < u:\n factors += [Factor([Var(int(v),2),Var(int(u),2)],[[th,-th],[-th,th]]).exp() for th in [L[v,u]] if th!=0] \n return factors","def _factorsX(self, inputs):\n return tensor.dot(inputs[0], self.wxf)","def factor(self):\r\n\t\t\r\n\t\t# get gcf\r\n\t\tg = self.extract()\r\n\t\t\r\n\t\t# invert and multiply\r\n\t\tv = g.invert()\r\n\t\tf = self.multiply(v)\r\n\t\t\r\n\t\treturn f,g","def lu_factorization (M) -> list:\n dim = len(M)\n L = np.eye(dim)\n\n #Itero sulle Incognite da Trovare\n for i in range(dim-1):\n\n #Itero sulle righe su cui devo cancellare un elemento\n for j in range(i+1,dim):\n m__j_i = M[j][i] / M[i][i]\n L[j][i] = m__j_i\n \n M[j][i] = 0.0\n\n for k in range (i+1,dim):\n M[j][k] = M[j][k] - m__j_i * M[i][k]\n \n\n return M,L","def forward(self, user, item):\n item_emb = self.product_factors(item.view(-1)) + self.product_bias(\n item.view(-1)\n )\n user_emb = self.user_factors(user.view(-1)) + self.user_bias(user.view(-1))\n mat_mult = (item_emb * user_emb).sum(1)\n\n return mat_mult","def nfactors(self):\n return self.L.nnz","def _compute_mu_factor2(*input_mols):\n mu_factor = 1\n for mol in input_mols:\n mu_factor *= np.prod(fact(mol))\n return mu_factor","def doolittle_factorization(self, matrix=None):\n try:\n local_matrix = self.matrix.matrix if not matrix else matrix.matrix\n except AttributeError:\n local_matrix = matrix\n \n (result, upper, lower, temp_sum) = (0.0, [[]], [[]], 0.0)\n for i in range(len(local_matrix)):\n lower.append([])\n for j in range(len(local_matrix[i])):\n lower[i].append(0)\n \n lower.remove([])\n\n for i in range(len(local_matrix)):\n for j in range(len(local_matrix[i])):\n temp_sum = 0.0\n for k in range(i):\n temp_sum += lower[i][k] * upper[k][j]\n result = local_matrix[i][j] - temp_sum\n upper[i].append(round(result, 9))\n upper.append([])\n \n for j in range(len(local_matrix[i])):\n temp_sum = 0.0\n for k in range(i):\n temp_sum += lower[j][k] * upper[k][i]\n result = local_matrix[j][i] - temp_sum\n lower[j][i] = round(result / upper[i][i], 9)\n\n upper.remove([])\n upper = Matrix(upper, name=\"U\")\n lower = Matrix(lower, name=\"L\")\n\n print(\"Las matrices son: \")\n upper.print_matrix()\n lower.print_matrix()\n\n print(\"Al multiplicarlas queda\")\n comprobation = lower.multiply_matrix(upper.matrix)\n comprobation.set_name(\"comprobación de la factorización LU\")\n comprobation.print_matrix()\n\n return (lower, upper)","def _compute_kl(self, lvl):\n kl = [] # kernal length\n for n in range(lvl):\n fct = self.scaling**n # up-sampling factor\n kl.append(fct*(self.nfreq-1)+1)\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\n return kl[::-1]","def compute_factor(X, v, c1, c2):\n\n assert np.shape(v)[1] == 1,\"v is not a column vector\"\n\n v = normalize_l2(v)\n\n sz_u = np.shape(X)[0]\n sz_v = np.shape(X)[1]\n\n assert sz_v == np.size(v)\n\n u = update_with_delta(X @ v, c1)\n v = update_with_delta(X.T @ u, c2)\n\n delta_u = 1000\n delta_v = 1000\n\n while delta_u > 1e-5 or delta_v > 1e-5:\n oldU = u\n oldV = v\n\n u = update_with_delta(X @ v, c1)\n v = update_with_delta(X.T @ u, c2)\n\n delta_u = npla.norm(u - oldU) / sz_u\n delta_v = npla.norm(v - oldV) / sz_v\n\n d = u.T @ X @ v\n\n return (d,u,v)","def totient(self,x):\r\n dist = self.distr(self.factors(x)).items()\r\n if self.verbose: print(dist)\r\n \r\n # return Euler's result based on product of each prime factor p and its power n\r\n # return prod([ p**n*(1-(1/p)) for p,n in dist])\r\n # return prod([ p**n*1 - p**n/p for p,n in dist])\r\n # return prod([ p**n - p**(n-1) for p,n in dist])\r\n \r\n return prod([ p**n - p**(n-1) for p,n in dist])","def DualDecomposition(model, maxIter=100, verbose=False):\n lnF = sum( np.log(f.max()) for f in model.factors )\n lnX, xhat = -np.inf, np.zeros( (len(model.X),), dtype=int) \n lnR, rhat = -np.inf, np.zeros( (len(model.X),), dtype=int) \n if verbose: print(\"Iter 0: \"+str(lnF))\n \n for t in xrange(1,maxIter+1): # for each iteration:\n # Update each variable in turn:\n for Xi in model.X: # for each variable, \n flist = model.factorsWith(Xi, copy=False)\n gamma = [f.maxmarginal([Xi]) for f in flist]\n avg = np.prod(gamma)**(1.0/len(gamma))\n for f,g in zip(flist,gamma): f *= avg/(g+1e-300) # !!! numerical issues... \n xhat[Xi] = avg.argmax()[0] # guess a state for Xi\n #\n # Compute the upper bound on the maximum and the value of our current guess\n lnF = sum( np.log(f.max()) for f in model.factors )\n lnX = model.logValue( xhat )\n if lnR < lnX: lnR = lnX; rhat[:]=xhat;\n if verbose: print(\"Iter \"+str(t)+\": \"+str(lnF)+\" > \"+str(lnX))\n if (lnF == lnX): break\n return lnF,lnR,rhat","def calEachCrossflowAllAxialNode():\n AxialNodeno = 14 # axial node number in CFD data\n Nodes = []\n base = 'Node'\n for i in range(0, AxialNodeno):\n Nodes.append(base+str(i))\n \n crossFlow = pd.read_csv('Data_crossflow.csv', index_col = 'Unnamed: 0')\n lateralFactors = []\n for node in Nodes:\n lateralFactors.append(crossFlow[node]/0.8)\n #need to judge the sign of lateral flow according to CTF rule!!\n gapsToFlip = [2,4,6,7,9,11,13,14,16,18,20,21] #gaps in y direction\n gapsToFlipIndex = [x - 1 for x in gapsToFlip]\n for factors in lateralFactors:\n for index in gapsToFlipIndex:\n factors[index] = -factors[index] \n #note: lateralFactors is a list of list\n \n #below calculate factors averaged over all subchannels\n crossFlowAveFactor = crossFlow.apply(abs).mean(axis = 0)/0.8\n lateralFactorsAvelist = []\n for i in range(0,14):\n base = []\n for j in range(0,24):\n base.append(crossFlowAveFactor[i])\n lateralFactorsAvelist.append(base)\n \n \n for i in range(0, 14):\n for j in range(0, 24):\n #note, in the original model there is only one sign for all source\n #terms in one sub-channel. therefore -- sign(crossFlow.iloc[j,2])\n lateralFactorsAvelist[i][j] = lateralFactorsAvelist[i][j] *sign(crossFlow.iloc[j,2]) \n for each in lateralFactorsAvelist:\n for index in gapsToFlipIndex:\n each[index] = -each[index] \n \n \n return lateralFactors, lateralFactorsAvelist","def do_factor(m=4, q=11):\n from sage.rings.finite_rings.integer_mod_ring import IntegerModRing\n from sage.matrix.constructor import identity_matrix, block_matrix\n from sage.matrix.matrix_space import MatrixSpace\n from sage.rings.integer_ring import IntegerRing\n from sage.modules.free_module_integer import IntegerLattice\n \n \n m=n+1\n ZZ = IntegerRing()\n ZZ_q = IntegerModRing(q)\n \n \n \n from sage.arith.all import euler_phi\n from sage.misc.functional import cyclotomic_polynomial\n \n for a in range(\n R = ZZ_q['x']#.quotient(cyclotomic_polynomial(k, 'x'), 'x')\n f=cyclotomic_polynomial(m,'x')\n return f.factor()","def _compute_factors(roots, multiplicity, include_powers=False):\n current = cupy.array([1])\n suffixes = [current]\n for pole, mult in zip(roots[-1:0:-1], multiplicity[-1:0:-1]):\n monomial = cupy.r_[1, -pole]\n for _ in range(int(mult)):\n current = cupy.polymul(current, monomial)\n suffixes.append(current)\n suffixes = suffixes[::-1]\n\n factors = []\n current = cupy.array([1])\n for pole, mult, suffix in zip(roots, multiplicity, suffixes):\n monomial = cupy.r_[1, -pole]\n block = []\n for i in range(int(mult)):\n if i == 0 or include_powers:\n block.append(cupy.polymul(current, suffix))\n current = cupy.polymul(current, monomial)\n factors.extend(reversed(block))\n\n return factors, current","def _fv(self):\n return self.beta * (self.x ** self.c)","def NMF(model, maxIter=100, beliefs=None, verbose=False):\n if beliefs is None: beliefs = [Factor([Xi],1.0/Xi.states) for Xi in model.X]\n \n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\n for f in model.factors:\n m = f.log()\n for v in f.vars: m *= beliefs[v]\n lnZ += m.sum()\n if verbose: print(\"Iter 0: \"+str(lnZ))\n\n for t in xrange(1,maxIter+1): # for each iteration:\n # Update all the beliefs via coordinate ascent:\n for Xi in model.X: # for each variable, \n bNew = 0.0 # compute E[ log f ] as a function of Xi:\n for f in model.factorsWith(Xi,copy=False): # for each factor f_a, compute:\n m = f.log() # E[log f_a] = \\sum \\log f_a \\prod b_v\n for v in f.vars - [Xi]: m *= beliefs[v]\n bNew += m.marginal([Xi]) # sum them up to get E[log f]\n bNew -= bNew.max() # (numerical issues)\n bNew = bNew.exp()\n bNew /= bNew.sum() # set b(Xi) = exp( E[log f] ) / Z\n beliefs[Xi] = bNew\n #\n # Compute the lower bound on the partition function:\n # E_b [ log f ] + H(b) = \\sum_a E[log f_a] + \\sum_i H(b_i) for independent beliefs\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\n for f in model.factors:\n m = f.log()\n for v in f.vars: m *= beliefs[v]\n lnZ += m.sum()\n if verbose: print(\"Iter \"+str(t)+\": \"+str(lnZ))\n return lnZ,beliefs","def factors(self):\n self.assert_sampled()\n return self._factors","def normalize(self, factor):","def alternating_least_squares(Cui, factors, regularization=0.01,\n iterations=15, use_native=True, num_threads=0,\n dtype=np.float64):\n _check_open_blas()\n\n users, items = Cui.shape\n\n X = np.random.rand(users, factors).astype(dtype) * 0.01\n Y = np.random.rand(items, factors).astype(dtype) * 0.01\n\n Cui, Ciu = Cui.tocsr(), Cui.T.tocsr()\n\n solver = implicit.als.least_squares if use_native else least_squares\n\n for iteration in range(iterations):\n s = time.time()\n solver(Cui, X, Y, regularization, num_threads)\n solver(Ciu, Y, X, regularization, num_threads)\n log.debug(\"finished iteration %i in %s\", iteration, time.time() - s)\n\n return X, Y","def fit(self, user_x_product, latent_features_guess=2, learning_rate=0.0002, steps=5000, regularization_penalty=0.02, convergeance_threshold=0.001):\n print 'training model...'\n return self.__factor_matrix(user_x_product, latent_features_guess, learning_rate, steps, regularization_penalty, convergeance_threshold)","def _factorsH(self, inputs):\n return tensor.dot(self._hidden_activation(inputs), self.whf)","def rebalance(self):\n\n # Compute norms along columns for each factor matrix\n norms = [np.linalg.norm(f, axis=0) for f in self.factors]\n\n # Multiply norms across all modes\n lam = np.prod(norms, axis=0) ** (1/self.ndim)\n\n # Update factors\n self.factors = [f * (lam / fn) for f, fn in zip(self.factors, norms)]\n return self","def fn(i, n):\n if len(stack) > 0 and stack[-1] <= n: ans.append(stack + [n])\n for ii in range(i, len(factors)):\n if n % factors[ii] == 0: \n stack.append(factors[ii])\n fn(ii, n//factors[ii])\n stack.pop()","def create_factors(self):\n\n super(SVDPlusPlus, self).create_factors()\n self.y = np.random.normal(self.init_mean, self.init_stdev, (len(self.items), self.factors))","def factor_polynomial(a,b,c):\r\n afacts = factors(abs(a))\r\n cfacts = factors(abs(c))\r\n #choose a factor of a (d), then f is a/d and so on\r\n for d in afacts:\r\n for g in cfacts:\r\n f = a/d\r\n e = c/g\r\n if e*f + d*g == b:\r\n print(\"{}*x**2 + {}*x + {} = ({}x + {})({}x + {})\".format(a,b,c,d,int(e),int(f),g))\r\n return\r\n #return False\r","def compute_quotients(X = np.zeros((1,1,2))):\r\n \r\n start=time.time()\r\n rad = X[:,:,1]\r\n\r\n X = np.reshape(X,(X.shape[0],1,X.shape[1]*X.shape[2]))\r\n\r\n drad = np.asarray([[item[0]/item[1] if item[1] != 0 else 0 for item in list(itertools.combinations(rad[sample],2))] \\\r\n for sample in range(X.shape[0])])\r\n\r\n dradsum = np.asarray([[item[0]/item[1] if item[1] != 0 else 0 for item in itertools.combinations([ \\\r\n item[0]+item[1] for item in list(itertools.combinations(rad[sample],2))], 2)] \\\r\n for sample in range(drad.shape[0])])\r\n \r\n drad = np.reshape(drad,(drad.shape[0],1,drad.shape[-1]))\r\n drads = np.reshape(dradsum,(dradsum.shape[0],1,dradsum.shape[-1]))\r\n\r\n X = np.concatenate((drad,drads), axis=2)\r\n print('Geometric and packing factors computed in', round(time.time()-start,2),' s')\r\n np.save('X', X)\r\n \r\n return X","def _cache_factors(self, Pibra, Piket, Kbra, Kket, eps):\n q1, p1, Q1, P1 = Pibra\n q2, p2, Q2, P2 = Piket\n\n # If both parameter sets are identical, we are back in the homogeneous case.\n if q1 == q2 and p1 == p2 and Q1 == Q2 and P1 == P2:\n self._Hl = None\n\n # We have k in [0, 1, ..., K-1] where |K| is the basis size\n # hence K-1 is the maximal index.\n L = Kket.get_basis_size()\n\n makl = L\n\n # Factorials\n f = factorial(arange(makl))\n self._f = 1.0 / sqrt(f[:L].reshape(1, -1))\n\n # Note: formula currently fails for non-inhomogeneous case\n # because of divisions by zero in the two args below.\n argl = ((1.0j * conjugate(P1) * (q1 - q2) - 1.0j * conjugate(Q1) * (p1 - p2)) /\n (sqrt(1.0j * conjugate(Q2 * P1) - 1.0j * conjugate(Q1 * P2)) *\n sqrt(1.0j * conjugate(P1) * Q2 - 1.0j * conjugate(Q1) * P2)))\n\n # TODO: Better test for failure?\n if self._doraise and isnan(squeeze(argl)):\n raise InnerProductException(\"Symbolic formula failed due to Q_k = Q_l and P_k = P_l.\")\n\n # The parameter j varies in the range [0, 1, ..., min(K-1,L-1)]\n # hence we have that k-j can be in [K-1, K-2, ..., K-1-min(K-1,L-1)]\n # and similar for l-j we have [L-1, L-2, ..., L-1-min(K-1,L-1)]\n # where both K-1-min(K-1,L-1) and L-1-min(K-1,L-1) are non-negative.\n self._Hl = self._evaluate_hermite(L - 1, 1.0 / eps * argl)\n\n il = arange(L).reshape(-1, 1)\n self._pfl = ((1.0j * conjugate(Q2 * P1) - 1.0j * conjugate(Q1 * P2)) ** (il / 2.0)).reshape(L)\n\n # And the groundstate value\n self._I0 = self.exact_result_ground(Pibra, Piket, eps)","def removeFactors(self,flist, isLog=False):\n # Currently: just divide out factors (add inverse factors) -- can't check if factor present? (minimal)\n # TODO: set entries to zero, then call self.L.eliminate_zeros()\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\n for k,f in enumerate(flist):\n if not isLog: \n if np.any(f.t==0): f = f+1e-30; # TODO: log nonzero tol\n f = f.log()\n if f.nvar == 1:\n Xi = f.vars[0]\n self.h[Xi] -= .5*(f[1]-f[0])\n self.c -= .5*(f[1]+f[0])\n else:\n Xi,Xj = f.vars[0],f.vars[1]\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n self.h[Xi] -= .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.h[Xj] -= .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.c -= .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\n self.L -= csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar)); \n #raise NotImplementedError();","def sub_factor(self, A):\n \n #\n # In general, to slice a sparse matrix use:\n #\n # indices = np.where(bool_vect)[0]\n # out1 = M.tocsc()[:,indices] # for column slices\n # out2 = M.tocsr()[indices,:] # for row slices\n #\n \n print \"Running subfactor routine.\"\n \n self.m, self.n = A.shape\n \n # Build fixed/known solution vector mask\n x_sol_mask = numpy.zeros((self.n,));\n x_sol_mask[self.xinds] = 1;\n \n # Get the indices for the unknowns\n unknown_inds_mask = numpy.logical_not(x_sol_mask)\n self.unknown_inds = numpy.arange(self.n)[unknown_inds_mask]\n \n # Store internal r.h.s. for known part\n Apart = A.tocsc()[:,self.xinds]\n self.r = Apart.dot(self.xsol)\n # note: in the backsolve step this is subtracted from b, and it\n # works even if xsol is a matrix, with each column corresponding\n # to the known part of the solution for each column of b.\n \n # Get the part of A that corresponds to the unknown displacements.\n Asub = A.tocsr()[self.unknown_inds,:]\n Asub = Asub.tocsc()[:,self.unknown_inds]\n\n self.Asub_factorized = spla.factorized(Asub)\n #if self.Asub_factorized is not None:\n # self.Asub_factorized.free() \n #self.Asub_factorized = pardiso.Factor(Asub.tocsr())\n \n print \"Done with subfactor routine.\"","def __init__(self, user_factors, item_factors):\n self._user_factors = np.copy(user_factors)\n self._item_factors = np.copy(item_factors)\n \n self._users_num = user_factors.shape[0]\n self._items_num = item_factors.shape[0]\n\n assert user_factors.shape[1] == item_factors.shape[1]","def AlternatingLeastSquares(\n factors=100,\n regularization=0.01,\n alpha=1.0,\n dtype=np.float32,\n use_native=True,\n use_cg=True,\n use_gpu=implicit.gpu.HAS_CUDA,\n iterations=15,\n calculate_training_loss=False,\n num_threads=0,\n random_state=None,\n):\n if use_gpu:\n return implicit.gpu.als.AlternatingLeastSquares(\n factors,\n regularization,\n alpha,\n dtype=dtype,\n iterations=iterations,\n calculate_training_loss=calculate_training_loss,\n random_state=random_state,\n )\n return implicit.cpu.als.AlternatingLeastSquares(\n factors,\n regularization,\n alpha,\n dtype,\n use_native,\n use_cg,\n iterations,\n calculate_training_loss,\n num_threads,\n random_state,\n )","def exo1():\n randu = randn(N/ 2, N/ 2, 2); % a random vector field\n b = 2\n for i in 1: 4:\n LLs_u = Li{i}(LiS{i}(randu))\n % relative error should be very small\n norm(abs(LLs_u(: ) - b*randu(: )))/ norm(randu(: ))","def _factorsY(self, inputs):\n return tensor.dot(inputs[1], self.wyf)","def F(cst, x):\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\n [u, v, g1, g2, g3] = x\n a = g1*u1 - u0\n b = g2*u2 - u0\n c = g3*u - u0\n l = g1*v1 - v0 \n m = g2*v2 - v0\n n = g3*v - v0\n r = g1 - 1\n s = g2 - 1\n t = g3 - 1\n return np.array([\n coeffs[0]*(a**2-l**2) + 2*coeffs[1]*(a*b-l*m) + coeffs[2]*(b**2-m**2) + 2*coeffs[3]*(a*c-l*n) + 2*coeffs[4]*(b*c-m*n) + c**2 - n**2,\n coeffs[0]*(l**2-r**2) + 2*coeffs[1]*(l*m-r*s) + coeffs[2]*(m**2-s**2) + 2*coeffs[3]*(l*n-r*t) + 2*coeffs[4]*(m*n-s*t) + n**2 - t**2,\n coeffs[0]*a*l + coeffs[1]*(l*b+m*a) + coeffs[2]*m*b + coeffs[3]*(l*c+n*a) + coeffs[4]*(m*c+b*n) + c*n,\n coeffs[0]*a*r + coeffs[1]*(r*b+s*a) + coeffs[2]*s*b + coeffs[3]*(r*c+t*a) + coeffs[4]*(s*c+b*t) + c*t,\n coeffs[0]*r*l + coeffs[1]*(l*s+m*r) + coeffs[2]*m*s + coeffs[3]*(l*t+n*r) + coeffs[4]*(m*t+s*n) + t*n \n ])","def get_factors(self, x: np.ndarray, y: np.ndarray) -> np.ndarray:\n if self.fit_result:\n return 1. / (funcs.gaussian_2d(x, y, **self.fit_result) /\n self.fit_amplitude)\n else:\n return np.transpose(1. / self.interp(np.array([y, x]).T))","def compute_norm_fac_per_weight(fan_in):\n ksi = 1. / math.sqrt(fan_in)\n return (1 / 3) * ksi ** 2","def landau1(n):\n\n i = 2\n sum_factors = 1\n factors = set()\n\n while i <= n: \n common = {j for j in factors if gcd(j, i) != 1}\n if len(common) == 0:\n factors = add_factor(i, n, factors)\n sum_factors = sum(factors)\n elif product(common) <= i:\n difference = factors.difference(common)\n new_factors = add_factor(i, n, difference)\n if product(new_factors) > product(factors):\n factors = new_factors\n sum_factors = sum(factors)\n i += 1\n\n print(n, product(factors), factors)\n return product(factors)","def fs_form_factor(x_c_m,t_c,mach,max_t_sweep):\n return (1.0+(0.6/x_c_m)*t_c+100.0*(t_c**4))*(1.34*(mach**0.18)*((np.cos(np.deg2rad(max_t_sweep)))**0.28))","def test_two_qubit_weyl_decomposition_aama(self, smallest=1e-18, factor=9.8, steps=11):\n for aaa in (\n [smallest * factor**i for i in range(steps)]\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\n ):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(aaa, aaa, -aaa)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def solve():\n result = 1\n map = dict()\n for x in range(2, 20):\n temp = prime_factors(x)\n for n in range(2, 20):\n if n in temp:\n if n in map:\n map[n] = max(temp.count(n), map[n])\n else:\n map[n] = temp.count(n)\n\n for x in map:\n result *= (x ** map[x])\n\n return result","def calculate_217f_part_stress(**attributes): # pylint: disable=R0912, R0914\n _dic_ref_temp = {\n 1: 343.0,\n 2: {\n 1: 343.0,\n 2: 343.0,\n 3: 398.0,\n 4: 398.0\n },\n 3: 298.0,\n 5: 398.0,\n 6: 298.0,\n 7: 298.0,\n 9: 358.0,\n 10: 358.0,\n 11: 313.0,\n 12: 298.0,\n 13: 358.0,\n 14: 343.0,\n 15: 343.0\n }\n _dic_factors = {\n 1: [4.5E-9, 12.0, 1.0, 0.6, 1.0, 1.0],\n 2: {\n 1: [3.25E-4, 1.0, 3.0, 1.0, 1.0, 1.0],\n 2: [3.25E-4, 1.0, 3.0, 1.0, 1.0, 1.0],\n 3: [5.0E-5, 3.5, 1.0, 1.0, 1.0, 1.0],\n 4: [5.0E-5, 3.5, 1.0, 1.0, 1.0, 1.0]\n },\n 3: [7.33E-3, 0.202, 2.6, 1.45, 0.89, 1.3],\n 5: [0.0031, 1.0, 10.0, 1.0, 1.0, 1.5],\n 6: [0.00148, 1.0, 2.0, 0.5, 1.0, 1.0],\n 7: [0.00015, 2.64, 1.0, 0.466, 1.0, 1.0],\n 8: [0.021, 0.065, 0.105, 0.0, 0.0, 0.0],\n 9: [0.0062, 1.0, 5.0, 1.0, 1.0, 1.0],\n 10: [0.0735, 1.03, 4.45, 2.74, 3.51, 1.0],\n 11: [0.0398, 0.514, 5.28, 1.44, 4.46, 1.0],\n 12: [0.0481, 0.334, 4.66, 1.47, 2.83, 1.0],\n 13: [0.019, 0.445, 7.3, 2.69, 2.46, 1.0],\n 14: [0.0246, 0.459, 9.3, 2.32, 5.3, 1.0],\n 15: [0.018, 1.0, 7.4, 2.55, 3.6, 1.0]\n }\n _dic_piQ = {\n 1: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\n 2: [0.03, 0.1, 0.3, 1.0, 5.0, 5.0, 15.0],\n 3: [1.0, 3.0],\n 4: [1.0, 3.0],\n 5: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\n 6: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\n 7: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\n 8: [1.0, 15.0],\n 9: [0.02, 0.06, 0.2, 0.6, 3.0, 10.0],\n 10: [2.5, 5.0],\n 11: [2.0, 4.0],\n 12: [2.0, 4.0],\n 13: [0.02, 0.06, 0.2, 0.6, 3.0, 10.0],\n 14: [2.5, 5.0],\n 15: [2.0, 4.0]\n }\n _dic_piE = {\n 1: [\n 1.0, 3.0, 8.0, 5.0, 13.0, 4.0, 5.0, 7.0, 11.0, 19.0, 0.5, 11.0,\n 27.0, 490.0\n ],\n 2: [\n 1.0, 2.0, 8.0, 4.0, 14.0, 4.0, 8.0, 10.0, 18.0, 19.0, 0.2, 10.0,\n 28.0, 510.0\n ],\n 3: [\n 1.0, 2.0, 10.0, 5.0, 17.0, 6.0, 8.0, 14.0, 18.0, 25.0, 0.5, 14.0,\n 36.0, 660.0\n ],\n 4: [\n 1.0, 2.0, 10.0, 5.0, 17.0, 6.0, 8.0, 14.0, 18.0, 25.0, 0.5, 14.0,\n 36.0, 660.0\n ],\n 5: [\n 1.0, 2.0, 11.0, 5.0, 18.0, 15.0, 18.0, 28.0, 35.0, 27.0, 0.8, 14.0,\n 38.0, 610.0\n ],\n 6: [\n 1.0, 2.0, 10.0, 5.0, 16.0, 4.0, 8.0, 9.0, 18.0, 23.0, 0.3, 13.0,\n 34.0, 610.0\n ],\n 7: [\n 1.0, 2.0, 10.0, 5.0, 16.0, 4.0, 8.0, 9.0, 18.0, 23.0, 0.5, 13.0,\n 34.0, 610.0\n ],\n 8: [\n 1.0, 5.0, 21.0, 11.0, 24.0, 11.0, 30.0, 16.0, 42.0, 37.0, 0.5,\n 20.0, 53.0, 950.0\n ],\n 9: [\n 1.0, 2.0, 12.0, 6.0, 20.0, 5.0, 8.0, 9.0, 15.0, 33.0, 0.5, 18.0,\n 48.0, 870.0\n ],\n 10: [\n 1.0, 2.0, 18.0, 8.0, 30.0, 8.0, 12.0, 13.0, 18.0, 53.0, 0.5, 29.0,\n 76.0, 1400.0\n ],\n 11: [\n 1.0, 2.0, 16.0, 7.0, 28.0, 8.0, 12.0, 0.0, 0.0, 38.0, 0.5, 0.0,\n 0.0, 0.0\n ],\n 12: [\n 1.0, 3.0, 16.0, 7.0, 28.0, 8.0, 12.0, 0.0, 0.0, 38.0, 0.5, 0.0,\n 0.0, 0.0\n ],\n 13: [\n 1.0, 3.0, 14.0, 6.0, 24.0, 5.0, 7.0, 12.0, 18.0, 39.0, 0.5, 22.0,\n 57.0, 1000.0\n ],\n 14: [\n 1.0, 2.0, 19.0, 8.0, 29.0, 40.0, 65.0, 48.0, 78.0, 46.0, 0.5, 25.0,\n 66.0, 1200.0\n ],\n 15: [\n 1.0, 3.0, 14.0, 7.0, 24.0, 6.0, 12.0, 20.0, 30.0, 39.0, 0.5, 22.0,\n 57.0, 1000.0\n ]\n }\n # Resistance factor (piR) dictionary of values. The key is the\n # subcategory ID. The index in the returned list is the resistance range\n # breakpoint (breakpoint values are in _lst_breakpoints below). For\n # subcategory ID 6 and 7, the specification ID selects the correct set of\n # lists, then the style ID selects the proper list of piR values and then\n # the resistance range breakpoint is used to select\n _dic_piR = {\n 1: [1.0, 1.1, 1.6, 2.5],\n 2: [1.0, 1.1, 1.6, 2.5],\n 3: [1.0, 1.2, 1.3, 3.5],\n 5: [1.0, 1.7, 3.0, 5.0],\n 6: [[[1.0, 1.0, 1.2, 1.2, 1.6, 1.6, 1.6,\n 0.0], [1.0, 1.0, 1.0, 1.2, 1.6, 1.6, 0.0,\n 0.0], [1.0, 1.0, 1.0, 1.0, 1.2, 1.2, 1.2,\n 1.6], [1.0, 1.2, 1.6, 1.6, 0.0, 0.0, 0.0, 0.0],\n [1.0, 1.6, 0.0, 0.0, 0.0, 0.0, 0.0,\n 0.0], [1.0, 1.6, 1.6, 0.0, 0.0, 0.0, 0.0,\n 0.0], [1.0, 1.0, 1.1, 1.2, 1.2, 1.6, 0.0, 0.0],\n [1.0, 1.0, 1.4, 0.0, 0.0, 0.0, 0.0, 0.0]],\n [[1.0, 1.0, 1.0, 1.0, 1.2, 1.6], [1.0, 1.0, 1.0, 1.2, 1.6, 0.0],\n [1.0, 1.0, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.0, 2.0, 0.0, 0.0], [\n 1.0, 1.0, 1.0, 2.0, 0.0, 0.0\n ], [1.0, 1.0, 1.2, 2.0, 0.0, 0.0], [1.0, 1.2, 1.4, 0.0, 0.0, 0.0],\n [1.0, 1.0, 1.6, 0.0, 0.0, 0.0], [1.0, 1.0, 1.2, 2.0, 0.0, 0.0], [\n 1.0, 1.0, 1.2, 1.6, 0.0, 0.0\n ], [1.0, 1.0, 1.0, 1.4, 0.0, 0.0], [1.0, 1.0, 1.0, 1.2, 0.0, 0.0],\n [1.0, 1.0, 1.4, 0.0, 0.0, 0.0], [1.0, 1.2, 1.6, 0.0, 0.0, 0.0], [\n 1.0, 1.0, 1.4, 0.0, 0.0, 0.0\n ], [1.0, 1.0, 1.2, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.4, 0.0, 0.0],\n [1.0, 1.0, 1.0, 1.4, 0.0, 0.0], [1.0, 1.0, 1.0, 1.4, 0.0, 0.0], [\n 1.0, 1.0, 1.2, 1.5, 0.0, 0.0\n ], [1.0, 1.0, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.0, 1.4, 1.6, 0.0],\n [1.0, 1.0, 1.0, 1.4, 1.6, 2.0], [1.0, 1.0, 1.0, 1.4, 1.6, 2.0], [\n 1.0, 1.0, 1.4, 2.4, 0.0, 0.0\n ], [1.0, 1.0, 1.2, 2.6, 0.0,\n 0.0], [1.0, 1.0, 1.0, 0.0, 0.0,\n 0.0], [1.0, 1.0, 1.0, 0.0, 0.0,\n 0.0], [1.0, 1.0, 0.0, 0.0, 0.0, 0.0], [\n 1.0, 1.2, 1.4, 0.0, 0.0, 0.0\n ], [1.0, 1.0, 1.2, 1.6, 0.0,\n 0.0], [1.0, 1.0, 1.0, 1.6, 0.0, 0.0], [\n 1.0, 1.0, 1.4, 0.0, 0.0, 0.0\n ], [1.0, 1.2, 1.5, 0.0, 0.0,\n 0.0], [1.0, 1.2, 0.0, 0.0, 0.0, 0.0]]],\n 7: [[[1.0, 1.2, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.2, 1.6, 0.0, 0.0],\n [1.0, 1.0, 1.2, 1.2, 1.6, 0.0], [1.0, 1.0, 1.0, 1.1, 1.2, 1.6],\n [1.0, 1.0, 1.0, 1.0, 1.2, 1.6], [1.0, 1.0, 1.0, 1.0, 1.2, 1.6]],\n [[1.0, 1.2, 1.6, 0.0, 0.0, 0.0], [1.0, 1.2, 1.6, 0.0, 0.0, 0.0],\n [1.0, 1.0, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.1, 1.2, 1.4, 0.0],\n [1.0, 1.0, 1.0, 1.2, 1.6, 0.0], [1.0, 1.0, 1.0, 1.1, 1.4, 0.0]]],\n 9: [1.0, 1.4, 2.0],\n 10: [1.0, 1.1, 1.4, 2.0, 2.5, 3.5],\n 11: [1.0, 1.4, 2.0],\n 12: [1.0, 1.4, 2.0],\n 13: [1.0, 1.1, 1.2, 1.4, 1.8],\n 14: [1.0, 1.1, 1.2, 1.4, 1.8],\n 15: [1.0, 1.1, 1.2, 1.4, 1.8]\n }\n # Dictionary containing the number of element breakpoints for determining\n # the resistance factor list to use.\n _dic_breakpoints = {\n 1: [1.0E5, 1.0E6, 1.0E7],\n 2: [1.0E5, 1.0E6, 1.0E7],\n 3: [100.0, 1.0E5, 1.0E6],\n 5: [1.0E4, 1.0E5, 1.0E6],\n 6: [[500.0, 1.0E3, 5.0E3, 7.5E3, 1.0E4, 1.5E4, 2.0E4],\n [100.0, 1.0E3, 1.0E4, 1.0E5, 1.5E5, 2.0E5]],\n 7: [500.0, 1.0E3, 5.0E3, 1.0E4, 2.0E4],\n 9: [2.0E3, 5.0E3],\n 10: [1.0E4, 2.0E4, 5.0E4, 1.0E5, 2.0E5],\n 11: [2.0E3, 5.0E3],\n 12: [2.0E3, 5.0E3],\n 13: [5.0E4, 1.0E5, 2.0E5, 5.0E5],\n 14: [5.0E4, 1.0E5, 2.0E5, 5.0E5],\n 15: [1.0E4, 5.0E4, 2.0E5, 1.0E6]\n }\n _dic_piV = {\n 9: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\n 10: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\n 11: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\n 12: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\n 13: [1.0, 1.05, 1.2],\n 14: [1.0, 1.05, 1.2],\n 15: [1.0, 1.05, 1.2]\n }\n _dic_piC = {10: [2.0, 1.0, 3.0, 1.5], 12: [2.0, 1.0]}\n _msg = ''\n\n # Calculate the base hazard rate.\n if attributes['subcategory_id'] == 2:\n _ref_temp = _dic_ref_temp[attributes['subcategory_id']][attributes[\n 'specification_id']]\n _f0 = _dic_factors[attributes['subcategory_id']][attributes[\n 'specification_id']][0]\n _f1 = _dic_factors[attributes['subcategory_id']][attributes[\n 'specification_id']][1]\n _f2 = _dic_factors[attributes['subcategory_id']][attributes[\n 'specification_id']][2]\n _f3 = _dic_factors[attributes['subcategory_id']][attributes[\n 'specification_id']][3]\n _f4 = _dic_factors[attributes['subcategory_id']][attributes[\n 'specification_id']][4]\n _f5 = _dic_factors[attributes['subcategory_id']][attributes[\n 'specification_id']][5]\n elif attributes['subcategory_id'] not in [4, 8]:\n _ref_temp = _dic_ref_temp[attributes['subcategory_id']]\n _f0 = _dic_factors[attributes['subcategory_id']][0]\n _f1 = _dic_factors[attributes['subcategory_id']][1]\n _f2 = _dic_factors[attributes['subcategory_id']][2]\n _f3 = _dic_factors[attributes['subcategory_id']][3]\n _f4 = _dic_factors[attributes['subcategory_id']][4]\n _f5 = _dic_factors[attributes['subcategory_id']][5]\n\n if attributes['subcategory_id'] == 4:\n attributes['lambda_b'] = 0.00006\n elif attributes['subcategory_id'] == 8:\n attributes['lambda_b'] = _dic_factors[attributes['subcategory_id']][\n attributes['type_id'] - 1]\n else:\n attributes['lambda_b'] = _f0 * exp(_f1 * (\n (attributes['temperature_active'] + 273.0) /\n _ref_temp))**_f2 * exp(((attributes['power_ratio'] / _f3) * (\n (attributes['temperature_active'] + 273.0) / 273.0)**_f4)**_f5)\n\n if attributes['lambda_b'] <= 0.0:\n _msg = _msg + 'RAMSTK WARNING: Base hazard rate is 0.0 when ' \\\n 'calculating resistor, hardware ID: ' \\\n '{0:d}'.format(attributes['hardware_id'])\n\n # Calculate the resistance factor (piR).\n if attributes['subcategory_id'] not in [4, 8]:\n _index = -1\n if attributes['subcategory_id'] == 6:\n _breaks = _dic_breakpoints[attributes['subcategory_id']][\n attributes['specification_id'] - 1]\n else:\n _breaks = _dic_breakpoints[attributes['subcategory_id']]\n\n for _index, _value in enumerate(_breaks):\n _diff = _value - attributes['n_elements']\n if len(_breaks) == 1 and _diff < 0:\n break\n elif _diff >= 0:\n break\n\n if attributes['subcategory_id'] in [6, 7]:\n attributes['piR'] = _dic_piR[attributes['subcategory_id']][\n attributes['specification_id'] - 1][attributes['family_id'] -\n 1][_index + 1]\n elif attributes['subcategory_id'] not in [4, 8]:\n attributes['piR'] = _dic_piR[attributes['subcategory_id']][_index +\n 1]\n\n # Determine the quality factor (piQ).\n attributes['piQ'] = _dic_piQ[attributes['subcategory_id']][\n attributes['quality_id'] - 1]\n\n if attributes['piQ'] <= 0.0:\n _msg = _msg + 'RAMSTK WARNING: piQ is 0.0 when calculating ' \\\n 'resistor, hardware ID: {0:d}'.format(attributes['hardware_id'])\n\n # Determine the environmental factor (piE).\n attributes['piE'] = _dic_piE[attributes['subcategory_id']][\n attributes['environment_active_id'] - 1]\n\n if attributes['piE'] <= 0.0:\n _msg = _msg + 'RAMSTK WARNING: piE is 0.0 when calculating ' \\\n 'resistor, hardware ID: {0:d}'.format(attributes['hardware_id'])\n\n # Calculate the temperature factor (piT).\n if attributes['subcategory_id'] == 4:\n attributes['temperature_case'] = (attributes['temperature_active'] +\n 55.0 * attributes['power_ratio'])\n attributes['piT'] = exp(-4056.0 * (\n (1.0 / (attributes['temperature_case'] + 273.0)) - 1.0 / 298.0))\n\n # Calculate the taps factor (piTAPS).\n if attributes['subcategory_id'] in [9, 10, 11, 12, 13, 14, 15]:\n attributes['piTAPS'] = (attributes['n_elements']**1.5 / 25.0) + 0.792\n\n # Calculate the voltage factor (piV).\n if attributes['subcategory_id'] > 8:\n _index = -1\n if attributes['subcategory_id'] in [9, 10, 11, 12]:\n _breaks = [0.1, 0.2, 0.6, 0.7, 0.8, 0.9]\n elif attributes['subcategory_id'] in [13, 14, 15]:\n _breaks = [0.8, 0.9]\n for _index, _value in enumerate(_breaks):\n _diff = _value - attributes['voltage_ratio']\n if len(_breaks) == 1 and _diff < 0.0:\n break\n elif _index == 0 and _diff >= 0.0:\n break\n elif _diff >= 0:\n break\n attributes['piV'] = _dic_piV[attributes['subcategory_id']][_index]\n\n # Determine the consruction class factor (piC).\n if attributes['subcategory_id'] in [10, 12]:\n attributes['piC'] = _dic_piC[attributes['subcategory_id']][\n attributes['construction_id'] - 1]\n\n # Calculate the active hazard rate.\n attributes['hazard_rate_active'] = (\n attributes['lambda_b'] * attributes['piQ'] * attributes['piE'])\n if attributes['subcategory_id'] == 4:\n attributes['hazard_rate_active'] = (\n attributes['hazard_rate_active'] * attributes['piT'] *\n attributes['n_elements'])\n elif attributes['subcategory_id'] in [9, 11, 13, 14, 15]:\n attributes['hazard_rate_active'] = (\n attributes['hazard_rate_active'] * attributes['piTAPS'] *\n attributes['piR'] * attributes['piV'])\n elif attributes['subcategory_id'] in [10, 12]:\n attributes['hazard_rate_active'] = (\n attributes['hazard_rate_active'] * attributes['piTAPS'] *\n attributes['piC'] * attributes['piR'] * attributes['piV'])\n elif attributes['subcategory_id'] != 8:\n attributes['hazard_rate_active'] = (\n attributes['hazard_rate_active'] * attributes['piR'])\n\n return attributes, _msg","def improve(factors):\n factors = defaultdict(int, factors)\n improvement = 0\n for a, b in find_pairs(factors):\n c = a*b\n # If local improvement is possible, create remove the two\n # old factors once and introduce a new one\n if DR[c] >= DR[a] + DR[b]:\n new_factors = factors.copy()\n new_factors[a] -= 1\n new_factors[b] -= 1\n new_factors[c] += 1\n improvement += 1\n improve(new_factors)\n\n # If no more local improvements are possible then add\n # to the pool of local optima as candidates for MDRS\n if not improvement:\n candidates.append(factors)","def empirical( cliques, data, normalize=False):\n factors = [None]*len(cliques)\n for i,vs in enumerate(cliques):\n vs_data = np.array([data[v] for v in vs])\n if len(vs_data.shape)>1: vs_data = vs_data.T # data axis first, now\n factors[i] = Factor(vs, 0.)\n for xs in vs_data:\n if np.any(np.isnan(xs)): continue # skip data with missing entries \n factors[i].t[ tuple(xs.astype(int)) ] += 1.\n if normalize: factors[i].t /= factors[i].sum()\n return factors","def test_two_qubit_weyl_decomposition_ab0(self, smallest=1e-18, factor=9.8, steps=11):\n for aaa in (\n [smallest * factor**i for i in range(steps)]\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\n ):\n for bbb in np.linspace(0, aaa, 10):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(aaa, bbb, 0)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def test_two_qubit_weyl_decomposition_aaa(self, smallest=1e-18, factor=9.8, steps=11):\n for aaa in (\n [smallest * factor**i for i in range(steps)]\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\n ):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(aaa, aaa, aaa)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def _compute_mu_factor(*input_mols):\n return np.sqrt(_compute_mu_factor2(*input_mols))","def projective_factorization(x, max_iterations=1):\n\n n_views = len(x)\n n_points = x[0].shape[1]\n\n iterations = 0\n\n #lambda matrix, approximate depths\n l = np.ones((n_views, n_points))\n\n #normalization matrices\n norm_matrices = []\n\n # normalize coordinates\n xn = np.zeros((3*n_views, n_points))\n for i in range(n_views):\n\n #find normalization matrix for projections i\n x_norm, T = normalize_points(x[i], is_homogeneous=True)\n xn[3*i:3*(i+1), :] = x_norm\n norm_matrices.append(T)\n\n while iterations < max_iterations:\n # normalize the lambda matrix\n lr_norm = norm(l, axis=1)\n ln = l / lr_norm[:, np.newaxis]\n lc_norm = norm(ln, axis=0)\n ln /= lc_norm\n\n # repeat the lambdas\n ln = np.repeat(ln, 3, axis=0)\n\n #build the factorization matrix\n fact_matrix = ln*xn\n\n u, d, vh = svd(fact_matrix)\n\n print(d[3] / d[4])\n d = d[:4]/d[0]\n\n # from the svd decomposition we can find the projections and 3d points\n p_matrices = u[:, :4]\n x_3d = np.dot(np.diag(d), vh[:4, :])\n\n iterations += 1\n if iterations != max_iterations:\n\n w_matrix = np.dot(p_matrices, x_3d)\n\n for i in range(n_views):\n l[i, :] = w_matrix[3*i+2, :]\n\n cameras = []\n\n for i in range(n_views):\n # denormalize camera matrices\n c_matrix = np.dot(inv(norm_matrices[i]), p_matrices[3*i:3*(i+1), :])\n\n cameras.append(c_matrix)\n\n return cameras, x_3d","def get_norm_factor(self, arr):\r\n\r\n\t\tif self.func == \"sigmoid\":\r\n\t\t\tnorm_factor = sigmoid(arr, *self.popt) \r\n\t\telif self.func == \"constant\":\r\n\t\t\tnorm_factor = arr*0 + self.popt\t#ensures that output is the same size as arr\r\n\t\treturn(norm_factor)","def test_two_qubit_weyl_decomposition_aa0(self, smallest=1e-18, factor=9.8, steps=11):\n for aaa in (\n [smallest * factor**i for i in range(steps)]\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\n ):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(aaa, aaa, 0)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def get_scale_factor(self, jets, passing_cut):\n # First of all flatten everything to make it easier to handle\n pt = ak.to_numpy(ak.flatten(jets.pt))\n eta = ak.to_numpy(ak.flatten(jets.eta))\n flav = ak.to_numpy(ak.flatten(jets.hadronFlavour))\n pass_wp = ak.to_numpy(ak.flatten(jets[passing_cut]))\n\n # Get the MC efficiency\n eff = self.efficiency_(pt, eta, flav)\n # for each systematic/central value compute the proper SF\n # cache the SF values as sometimes they are repeated, there \n # might also be systematic combinations that are never accessed\n # but pruning them at the beginning can be hard\n # use schema to define combinations, lcb is a tuple with the sf keys\n # for light, charm, bottom for each systematic\n flavour_sf_cache = {}\n scale_factors = {} # our final product\n for key, lcb in self.schema_.items(): \n # populate cache if needed\n for i in range(3):\n # protect against using prelim csv files that don't have UDSG wps\n flavour_sf_cache[lcb[i]] = np.ones(eta.size) if lcb[i] not in self.sf_.keys() else flavour_sf_cache.get(lcb[i], self.sf_[lcb[i]](eta, pt, pass_wp))\n \n scale_factors[key] = eff * self.match_flav_(\n flavour_sf_cache[lcb[0]],\n flavour_sf_cache[lcb[1]],\n flavour_sf_cache[lcb[2]],\n flav\n )\n\n # use SF and eff to compute p(data) and p(MC)\n p_data = {key : np.where(pass_wp, val, 1 - val) \n for key, val in scale_factors.items()}\n p_mc = np.where(pass_wp, eff, 1 - eff)\n\n # return the unflattened version of the ratio\n return {key : ak.unflatten(i/p_mc, ak.num(jets.pt))\n for key, i in p_data.items()}","def test_two_qubit_weyl_decomposition_a00(self, smallest=1e-18, factor=9.8, steps=11):\n for aaa in (\n [smallest * factor**i for i in range(steps)]\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\n ):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(aaa, 0, 0)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def update_factors(self,u,i,j,update_u=True,update_i=True):\n #print(\"session run\")\n loss_v = self.sess.run(self.train_step , feed_dict={\n self.u: u,\n self.i: i,\n self.j: j})\n\n returnText = \"\"\n\n if self.alg_type == \"TFL\" or self.alg_type == \"TFLWM\":\n sum_lambda = 0\n for k in self.sim_matrix_names:\n sum_lambda += abs(self.sim_lambda[k].eval())\n #print(sum_lambda,self.sim_lambda)\n for k in self.sim_matrix_names:\n if math.isnan(sum_lambda):\n print(\"sim_lambda overflow\")\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\n returnText = \"sim_lambda overflow\"\n else:\n tf.assign(self.sim_lambda[k], self.sim_lambda[k].eval()/sum_lambda).eval()\n else:\n for k in self.sim_matrix_names:\n val = self.sim_lambda[k].eval()\n if math.isnan(val[0]):\n print(\"sim_lambda overflow\")\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\n returnText = \"sim_lambda overflow\"\n if val[0] <= 0.0:\n tf.assign(self.sim_lambda[k], [self.delta], validate_shape=False).eval()\n elif val[0] >= 1.0:\n tf.assign(self.sim_lambda[k], [self.one - self.delta], validate_shape=False).eval()\n\n return returnText","def factors(self, X):\r\n return (lambda fd: [X] if not fd else fd + self.factors(X // fd[0])) (self.firstdiv(X))","def discount_factors(r,n,m):\n return [1/((1+r/m)**i) for i in cashflow_times(n,m)]","def original_factors(self):\n self.assert_sampled()\n # the original factors is the same for all samples set\n return self._original_factors","def test_two_qubit_weyl_decomposition_abc(self, smallest=1e-18, factor=9.8, steps=11):\n for aaa in (\n [smallest * factor**i for i in range(steps)]\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\n ):\n for bbb in np.linspace(0, aaa, 4):\n for ccc in np.linspace(-bbb, bbb, 4):\n for k1l, k1r, k2l, k2r in K1K2S:\n k1 = np.kron(k1l.data, k1r.data)\n k2 = np.kron(k2l.data, k2r.data)\n a = Ud(aaa, bbb, ccc)\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)","def initiate_factors(Y, latent_dim):\n\tt = Y.shape[0]\n\tpca = PCA(n_components=latent_dim)\n\tcomponents = pca.fit_transform(Y)\n\tmu_0 = np.repeat(0, latent_dim) # prior mean 0 for regression coefficients\n\tSigma_0 = np.diag(np.repeat(1, latent_dim)) # prior variance 1\n\ta_0 = 1 # Inverse-Gamma(1, 1) is fairly diffused\n\tb_0 = 1\n\tloading_matrix, Y_variance = blr_mv(Y, components, mu_0, Sigma_0, a_0, b_0)\n\tX = np.linspace(0.1, t * 0.1, t).reshape((t, 1)) # create initial GP covariance matrices\n\tcov1 = sample_covariance_matern(X, 1.0, 1.0) # length scale 1.0 corresponds to 10 time points\n\tcov2 = sample_covariance_matern(X, 1.0, 1.0) # variance scale set to 1.0 as well\n\tS1, S2, S3, S4 = build_covariance_blocks([cov1, cov2], loading_matrix, Y_variance)\n\tF = sample_conditional_F(Y, S1, S2, S3, S4)\n\treturn F","def compute_error(data, user_features, item_features, nz):\n sum_err = 0\n for d, n in nz:\n err = data[d,n] - np.dot(item_features[d,:],user_features[:,n])\n sum_err += err**2\n rmse = 0.5*sum_err/len(nz)\n return rmse","def factor(n: int) -> List[Tuple[int, int]]:\n if n <= 1:\n raise ValueError\n\n factors = list()\n\n ml = 0\n p = 2\n while n % p == 0:\n n //= p\n ml += 1\n if ml > 0:\n factors.append((p, ml,))\n\n p = 3\n while p ** 2 <= n:\n ml = 0\n while n % p == 0:\n n //= p\n ml += 1\n if ml > 0:\n factors.append((p, ml,))\n p += 2\n\n if n > 2:\n factors.append((n, 1,))\n\n return factors","def _m_to_F_on_basis(self, la):\n Sym = self._kBoundedRing.ambient()\n kB = Sym.kBoundedSubspace(self.k, t=1)\n h = kB.khomogeneous()\n ks = kB.kschur()\n return sum( h(ks(x)).coefficient(la) * self(x) for x in PartitionsGreatestLE(sum(la), self.k))","def nonnegative_tensor_factorization(X, r, method='anls_bpp',\n tol=1e-4, stop_criterion=1,\n min_iter=20, max_iter=200, max_time=1e6,\n init=None, orderWays=None):\n\n nWay = len(X.shape)\n\n if orderWays is None:\n orderWays = np.arange(nWay)\n\n # set initial values\n if init is not None:\n F_cell = init\n else:\n Finit = [np.random.rand(X.shape[i], r) for i in range(nWay)]\n F_cell = Finit\n\n grad = getGradient(X, F_cell, nWay, r)\n\n nr_X = X.norm()\n nr_grad_all = np.sqrt(np.sum(np.linalg.norm(grad[i], 'fro') ** 2\n for i in range(nWay)))\n\n if method == \"anls_bpp\":\n method = anls_bpp()\n elif method == \"anls_asgroup\":\n method = anls_asgroup()\n else:\n raise Exception(\"Unknown method\")\n\n # Execute initializer\n F_cell, FF_init = method.initializer(X, F_cell, nWay, orderWays)\n\n tStart = time.time()\n\n if stop_criterion == 2:\n F_kten = ktensor(F_cell)\n rel_Error = getRelError(X, ktensor(F_cell), nWay, nr_X)\n\n if stop_criterion == 1:\n pGrad = getProjGradient(X, F_cell, nWay, r)\n SC_PGRAD = getStopCriterion(pGrad, nWay, nr_grad_all)\n\n # main iterations\n for iteration in range(max_iter):\n cntu = True\n\n F_cell, FF_init = method.iterSolver(X, F_cell,\n FF_init, nWay, r, orderWays)\n F_kten = ktensor(F_cell)\n\n if iteration >= min_iter:\n\n if time.time() - tStart > max_time:\n cntu = False\n\n else:\n\n if stop_criterion == 1:\n pGrad = getProjGradient(X, F_cell, nWay, r)\n SC_PGRAD = getStopCriterion(pGrad, nWay, nr_grad_all)\n if SC_PGRAD < tol:\n cntu = False\n\n elif stop_criterion == 2:\n prev_rel_Error = rel_Error\n rel_Error = getRelError(X, F_kten, nWay, nr_X)\n SC_DIFF = np.abs(prev_rel_Error - rel_Error)\n if SC_DIFF < tol:\n cntu = False\n else:\n rel_Error = getRelError(X, F_kten, nWay, nr_X)\n if rel_Error < 1:\n cntu = False\n\n if not cntu:\n break\n\n return F_kten","def return_factors(self):\n if self.global_rank==0:print([i.shape for i in self.factors])\n return self.factors","def stretch_factor(self):\n p = self._pants_decomposition\n\n # pick a curve to iterate\n c = PantsLamination.random(p)\n # print(c)\n\n cc = (self**100) * c\n # print(self**100)\n # print(cc)\n return float(sum(abs(x) for x in (self*cc).to_vector())) / \\\n sum(abs(x) for x in cc.to_vector())","def trifactor(a, d, c):\n u, l = zeros_like(d), zeros_like(a)\n u[0] = d[0]\n for k in range(len(a)):\n l[k] = a[k]/u[k]\n u[k+1] = d[k+1] - l[k]*c[k]\n return l, u","def compute_pmf(X_inp, rank, c1, c2):\n\n X_arr = []\n u_arr = []\n v_arr = []\n d_arr = []\n\n X = deepcopy(X_inp)\n\n v_init = np.ones((np.shape(X)[1],1))\n\n for i in range(rank):\n X_arr.append(X)\n (d,u,v) = compute_factor(X, v_init, c1, c2)\n\n\n assert abs(npla.norm(u) - 1 ) < 1e-3\n assert abs(npla.norm(v) - 1 ) < 1e-3\n\n d_arr.append(d)\n u_arr.append(u)\n v_arr.append(v)\n\n toSub = np.outer(u,v)\n assert np.shape(toSub) == np.shape(X)\n X -= d * toSub\n\n return (X_arr, u_arr, v_arr, d_arr)","def problem3():\n def _prime_factorization(n):\n \"\"\"Returns the list of prime factors of a number n\"\"\"\n factors = []\n f = 2\n # Use trial division to add factors\n while f**2 <= n:\n while (n % f) == 0:\n factors.append(f)\n n //= f\n f += 1\n\n if n > 1:\n factors.append(n)\n\n return factors\n\n return max(_prime_factorization(600851475143))","def __det3x3__(a):\r\n # val = +a[0,0] * ( a[1,1] * a[2,2] - a[2,1] * a[1,2] )\r\n # val += -a[0,1] * ( a[1,0] * a[2,2] - a[2,0] * a[1,2] )\r\n # val += +a[0,2] * ( a[1,0] * a[2,1] - a[2,0] * a[1,1] )\r\n val = +a[0] * (a[4] * a[8] - a[7] * a[5])\r\n val += -a[1] * (a[3] * a[8] - a[6] * a[5])\r\n val += +a[2] * (a[3] * a[7] - a[6] * a[4])\r\n return val","def addFactors(self, flist, copy=True, isLog=False):\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\n for k,f in enumerate(flist):\n if not isLog: \n if np.any(f.t<=0): f = f+1e-10; # TODO: log nonzero tol\n f = f.log()\n if f.nvar == 1:\n Xi = f.vars[0]\n self.h[Xi] += .5*(f[1]-f[0])\n self.c += .5*(f[1]+f[0])\n else:\n Xi,Xj = f.vars[0],f.vars[1]\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\n self.h[Xi] += .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.h[Xj] += .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\n self.c += .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\n self.L += csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar));","def _fit(self):\n I_mat = []\n for i in range(self._num_bases):\n temp = []\n for j in range(self._num_bases):\n v = 1.0 if i == j else 0.0\n temp.append(v)\n I_mat.append(temp)\n I_mat = Mat(I_mat)\n return (self._input.t() * self._input + self._lambda * I_mat).inv() * self._input.t() * self._label","def solveForModeB1(X, M, n, maxInner, epsilon, tol,sita,Y1, lambta2):\n # Pi(n) = [A(N) kr A(N-1) kr ... A(n+1) kr A(n-1) kr .. A(1)]^T\n Pi = tensorTools.calculatePi(X, M, n)\n #print 'Pi size', Pi.shape\n #print 'pi='+str(Pi)\n #print(M.U[n])\n for iter in range(maxInner):\n # Phi = (X(n) elem-div (B Pi)) Pi^T\n #print X.vals.shape,X.shape\n #print X.vals.flatten().shape\n Phi = tensorTools.calculatePhi(X, M.U[n], Pi, n, epsilon=epsilon)\n #print('phi'+str(Phi))\n #print(Phi)\n # check for convergence that min(B(n), E - Phi(n)) = 0 [or close]\n kktModeViolation = np.max(np.abs(np.minimum(M.U[n], 1-Phi).flatten()))\n if (kktModeViolation < tol):\n break\n\n B=M.U[n]\n #print B.shape\n colNorm = np.apply_along_axis(np.linalg.norm, 0, B, 1)\n zeroNorm = np.where(colNorm == 0)[0]\n colNorm[zeroNorm] = 1\n B = B / colNorm[np.newaxis, :]\n tm=np.hstack((np.ones((B.shape[0],1)),B))\n Y1=Y1.reshape((Y1.shape[0],1))\n\n derive=-1.0*lambta2/B.shape[0]*np.dot((Y1-np.dot(tm,sita)),sita.T)\n #print derive.shape\n #print np.multiply(M.U[n],derive[:,1:]).shape\n #print np.multiply(M.U[n],Phi).shape\n M.U[n] = np.array(np.multiply(M.U[n],Phi))-np.array((np.multiply(M.U[n],derive[:,1:])))\n\n #print 'after'\n #print M.U[n][0]\n #print(\" Mode={0}, Inner Iter={1}, KKT violation={2}\".format(n, iter, kktModeViolation))\n return M, Phi, iter, kktModeViolation","def rfactor(h,rmask):\n\n Lp, Mp = h.shape\n L=Lp-1\n M=Mp-1\n\n # Land/Sea mask on U-points.\n umask = np.zeros((L,Mp))\n for j in range(Mp):\n for i in range(1,Lp):\n umask[i-1,j] = rmask[i,j] * rmask[i-1,j]\n\n # Land/Sea mask on V-points.\n vmask = np.zeros((Lp,M))\n for j in range(1,Mp):\n for i in range(Lp):\n vmask[i,j-1] = rmask[i,j] * rmask[i,j-1]\n\n #-------------------------------------------------------------------\n # Compute R-factor.\n #-------------------------------------------------------------------\n\n hx = np.zeros((L,Mp))\n hy = np.zeros((Lp,M))\n\n hx = abs(h[1:,:] - h[:-1,:]) / (h[1:,:] + h[:-1,:])\n hy = abs(h[:,1:] - h[:,:-1]) / (h[:,1:] + h[:,:-1])\n\n hx = hx * umask\n hy = hy * vmask\n\n r = np.zeros((L,M))\n\n r = np.maximum(np.maximum(hx[:,:-1],hx[:,1:]), np.maximum(hy[:-1,:],hy[1:,:]))\n\n rmin = r.min()\n rmax = r.max()\n ravg = r.mean()\n rmed = np.median(r)\n\n print ' '\n print 'Minimum r-value = ', rmin\n print 'Maximum r-value = ', rmax\n print 'Mean r-value = ', ravg\n print 'Median r-value = ', rmed\n\n return r","def factor_naive(n):\n factors = []\n\n for factor in range(2, n // 2):\n q, r = divmod(n, factor)\n power = 0\n while r == 0:\n power += 1\n n = q\n q, r = divmod(q, factor)\n if power != 0:\n factors.append((factor, power))\n\n if factors == []:\n factors = [(n, 1)]\n\n return factors","def get_factors(val):\n N = np.sqrt(val)\n N = np.floor(N)\n M = val/N\n\n while (val % N != 0):\n N = N-1\n M = val/N\n\n return int(M), int(N)","def blueschist_felsic():\n\n rho = 2970.\n\n C = np.zeros((6,6), dtype=float)\n C[0,0] = 149.85; C[0,1] = 38.7; C[0,2] = 32.59; C[0,3] = -0.15; C[0,4] = -1.; C[0,5] = -0.19\n C[1,0] = C[0,1]; C[1,1] = 163.55; C[1,2] = 30.03; C[1,3] = 1.05; C[1,4] = -1.81; C[1,5] = -1.78\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 121.62; C[2,3] = 0.22; C[2,4] = -0.95; C[2,5] = -0.13\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 48.03; C[3,4] = -0.63; C[3,5] = -1.14\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 48.62; C[4,5] = -0.01\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 58.42\n\n return C, rho","def als(matrix, n_factors=8,n_iterations=15, lambda_=10):\r\n\tm, n = matrix.shape\r\n\tQ = matrix\r\n\tW = Q > 0.5\r\n\tW = W.astype(int)\r\n\tprint('X and Y randomly initialzied.')\r\n\tX = 5 * np.random.rand(m, n_factors) \r\n\tY = 5 * np.random.rand(n_factors, n)\r\n\tfor ii in range(n_iterations):\r\n\t\tfor u, Wu in enumerate(W):\r\n\t\t\tX[u] = np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),\r\n\t np.dot(Y, np.dot(np.diag(Wu), Q[u].T))).T\r\n\t\tfor i, Wi in enumerate(W.T):\r\n\t\t\tY[:,i] = np.linalg.solve(np.dot(X.T, np.dot(np.diag(Wi), X)) + lambda_ * np.eye(n_factors),\r\n\t np.dot(X.T, np.dot(np.diag(Wi), Q[:, i])))\r\n\t\tprint('{}th iteration is completed of {}'.format(ii + 1,n_iterations))\r\n\tprediction = np.dot(X,Y)\r\n\tprint('Done.')\r\n\treturn prediction, X, Y","def rf_prod(prime_factors: [int, ]):\n return 1 if not prime_factors else reduce(mul, prime_factors, 1)","def reciprocal_lattice_vectors(a):\n b = np.zeros(shape=(3,3))\n b[:,0] = 2 * np.pi * np.cross(a[:,1], a[:,2]) / triple_product(a[:,0], a[:,1], a[:,2])\n b[:,1] = 2 * np.pi * np.cross(a[:,2], a[:,0]) / triple_product(a[:,1], a[:,2], a[:,0])\n b[:,2] = 2 * np.pi * np.cross(a[:,0], a[:,1]) / triple_product(a[:,2], a[:,0], a[:,1])\n return b","def __truediv__(self, factor):\n if type(factor) == Vector:\n raise NotImplementedError\n else:\n return Vector([c / factor for c in self.components])","def _factors(n):\n gen = ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)\n return set(sum(gen, []))","def csrbf(r):\n return num.power((num.maximum(0, 1-r)), 3)*(3*r+1)","def auxminf1(x):\n \n# Sum over data points\n f = 0.0\n for m_ind in range(cfg.ntrain):\n f += auxmin_f1_part_i(x,m_ind) \n \n return f","def expand_factors(factor_components, factor_data):\n logger.debug('Transforming input from %d x %d to full %d-dimensional feature space',\n factor_data.shape[0], factor_data.shape[1], factor_components.shape[1])\n return factor_data.dot(factor_components)","def state_norm_opt(state):\n fact_arr = np.array([factorial(x) for x in range(len(state))])\n tf2 = np.tensordot(fact_arr, fact_arr, axes=0)\n tf4 = np.tensordot(tf2, tf2, axes=0)\n st_abs_quad = np.power(np.abs(state), 2)\n mult = np.multiply(st_abs_quad, tf4)\n return sqrt(np.sum(mult))","def get_factors(number):\n\n factors = [1, number]\n\n for i in range(2, int(math.sqrt(number))):\n if number % i == 0:\n factors.extend([i, number / i])\n\n return(factors)","def fit(self, y):\n if isinstance(y, np.ndarray) and y.ndim == 2:\n y = [y]\n y_all = np.concatenate(y)\n self.mean_ = y_all.mean(axis=0, keepdims=True)\n y = [yi - self.mean_ for yi in y]\n n = y[0].shape[1]\n T = [yi.shape[0] for yi in y]\n model = FA(self.n_factors, svd_method='lapack')\n model.fit(y_all)\n\n self.R_ = np.diag(model.noise_variance_)\n self.C_ = model.components_.T\n self.d_ = np.zeros(n)\n self.tau_ = self.tau_init + self.rng.rand(self.n_factors)\n # Allocated and reuse these\n C = self.C_\n R = self.R_\n big_K = {Ti: calc_big_K(Ti, self.n_factors, self.tau_, self.var_n) for Ti in set(T)}\n y_cov = {Ti: block_dot_B(block_dot_A(C, big_K[Ti], Ti), C.T, Ti) + make_block_diag(R, Ti)\n for Ti in set(T)}\n big_d = {Ti: np.tile(self.d_, Ti) for Ti in set(T)}\n big_y = [yi.ravel() for yi in y]\n ll_pre = log_likelihood(big_d, y_cov, big_y, T)\n if self.verbose:\n print(\"FA log likelihood:\", ll_pre)\n\n converged = False\n for ii in range(self.max_iter):\n ll = self._em_iter(y, big_K)\n if abs(ll - ll_pre) / np.amax([abs(ll), abs(ll_pre), 1.]) <= self.tol:\n converged = True\n break\n ll_pre = ll\n if not converged:\n warnings.warn(\"EM max_iter reached.\", ConvergenceWarning)\n return self","def factor_list(f):\n coeff, factors = dmp_factor_list(f.rep, f.lev, f.dom)\n return coeff, [ (f.per(g), k) for g, k in factors ]","def test_l1norm () :\n n = 10\n rfs = RewardFnSpace(list(range(n)))\n for i in range(10): \n b = rfs.bs[i]\n rfs.lp += b == 0\n rfs.lp.solve()\n rfs._setCoeffs()\n coeffs = np.array(rfs.coeffs)\n assert(np.linalg.norm(coeffs - np.ones(n)) < 1e-4)","def __solve_alternative_linear_problem(self, user):\n result = [0] * self.layout_slots\n de_rand_approach = \"greedy\"\n bins_per_category = []\n bins_cardinality = []\n for _ in range(len(self.categories)):\n bins_per_category.append([])\n bins_cardinality.append([])\n\n for cat in range(len(self.categories)):\n for _ in range(len(self.news_row_pivots) + 1):\n bins_per_category[cat].append([])\n bins_cardinality[cat].append([])\n for _ in range(len(self.news_column_pivots) + 1):\n bins_per_category[cat][-1].append([])\n bins_cardinality[cat][-1].append(0)\n\n for news in self.news_pool:\n category_index = self.categories.index(news.news_category)\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\n bins_per_category[category_index][x][y].append(news)\n bins_cardinality[category_index][x][y] += 1\n\n index = 0\n bin_samples = []\n for cat in range(len(self.categories)):\n for x in range(len(self.news_row_pivots) + 1):\n for y in range(len(self.news_column_pivots) + 1):\n if (y == 0) and (x != 0):\n continue\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\n index += 1\n try:\n selected_news = np.random.choice(bins_per_category[cat][x][y])\n self.sample_quality(selected_news, user, interest_decay=True)\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\n except ValueError:\n bin_samples += [0] * self.layout_slots\n\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\n\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\n slots_assegnation_probabilities = []\n slot_counter = 0\n tmp_slot_probabilities = []\n while slot_counter < self.layout_slots:\n i = slot_counter\n while i < len(linear_problem.x):\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\n i += self.layout_slots\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\n tmp_slot_probabilities.clear()\n slot_counter += 1\n\n slot_promenances = self.real_slot_promenances.copy()\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\n slots_nr = [s for s in range(0, self.layout_slots)]\n for i in range(self.layout_slots):\n if de_rand_approach == \"ordered\":\n k = i\n elif (de_rand_approach == \"greedy\") or (de_rand_approach == \"greedy_max\"):\n k = np.argmax(slot_promenances)\n slot_promenances[k] = 0\n elif de_rand_approach == \"randomized\":\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\n slot_promenances[k] = 0\n else:\n raise RuntimeError(\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \"\n \"'randomized' or 'greedy_max'.\")\n\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\n if de_rand_approach == \"greedy_max\":\n assigning_bin_index = np.argmax(target_slot_probabilities)\n cat_index = int(assigning_bin_index / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin_index)][0]\n y = self.bins_for_position[int(assigning_bin_index)][1]\n\n else:\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\n cat_index = int(assigning_bin / self.num_of_bins)\n x = self.bins_for_position[int(assigning_bin)][0]\n y = self.bins_for_position[int(assigning_bin)][1]\n\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\n\n return result","def kullback_leibler_dirichlet(m_true, alpha):\n\n alpha = alpha * (1 - m_true) + m_true\n M = int(m_true.shape[1])\n beta = tf.constant(np.ones((1, M)), dtype=tf.float32)\n alpha0 = tf.reduce_sum(input_tensor=alpha, axis=1, keepdims=True)\n \n kl = tf.reduce_sum(input_tensor=(alpha - beta) * (tf.math.digamma(alpha) - tf.math.digamma(alpha0)), axis=1, keepdims=True) + \\\n tf.math.lgamma(alpha0) - tf.reduce_sum(input_tensor=tf.math.lgamma(alpha), axis=1, keepdims=True) + \\\n tf.reduce_sum(input_tensor=tf.math.lgamma(beta), axis=1, keepdims=True) - tf.math.lgamma(tf.reduce_sum(input_tensor=beta, axis=1, keepdims=True))\n kl = tf.reduce_mean(input_tensor=kl)\n return kl","def exclusive_lasso5(X, n_clusters, gamma=0.5):\n MAX_ITERS = 100\n n_dims, n_samples = X.shape\n\n # Initialize indicaotr matrix F\n F = np.zeros((n_samples, n_clusters), dtype=np.int8)\n for i in xrange(n_samples):\n F[i, randint(0, n_clusters-1)] = 1\n\n conv = False\n iteration = 0\n results = np.zeros(n_clusters, dtype=np.float64)\n\n while iteration < MAX_ITERS and not conv:\n conv = True\n # Calculate H = XF(F^TF)^-1\n H = X.dot(sp.linalg.pinv(F.T))\n\n base_sum = ((X-H.dot(F.T))**2).sum(axis=0)\n F_counts = F.sum(axis=0)\n\n # Caculate F\n # For each row (sample)\n for i in xrange(n_samples):\n # Get current indicator\n curr_ind = F[i].nonzero()[0][0]\n F_counts[curr_ind] = F_counts[curr_ind] - 1\n\n # We want to find the indicator column that minimizes\n # X-HF^T + gamma * Tr(F^T11^TF)\n for j in xrange(n_clusters):\n F_counts[j] = F_counts[j] + 1\n tr = (F_counts**2).sum()\n res = ((X[:, i]-H[:, j])**2).sum() - base_sum[i] + gamma * tr\n results[j] = res\n F_counts[j] = F_counts[j] - 1\n new_ind = results.argmin()\n\n F_counts[new_ind] = F_counts[new_ind] + 1\n\n if (curr_ind != new_ind):\n conv = False\n F[i, curr_ind] = 0\n F[i, new_ind] = 1\n iteration = iteration + 1\n print iteration\n return map(lambda x: x.index(1), F.tolist())","def V_fit(x, a, b, c, d, e, f):\n x1 = x[0] # I\n x2 = x[1] # dT\n m = (a * x1 ** 2 + b * x1 + c)\n b = (d * x1 ** 2 + e * x1 + f)\n return m * x2 + b"],"string":"[\n \"def get_factors():\",\n \"def factors(self):\\n X = [Var(i,2) for i in range(self.nvar)]\\n factors = [Factor([],np.exp(self.c))] \\n # TODO: exclude if zero? or exclude if inf/-inf, or if in \\\"assigned\\\", or?\\n factors = factors + [Factor([X[i]],[-th,th]).exp() for i,th in enumerate(self.h) if self.dims[i]>1]\\n L = coo(self.L)\\n factors = factors + [Factor([X[i],X[j]],[[th,-th],[-th,th]]).exp() for i,j,th in zip(L.row,L.col,L.data) if i<j]\\n return factors\\n # TODO: should we exponentiate if isLog not True? \",\n \"def factor_mat(all_dat, f_num, iterations, regularization):\\n\\n\\t# get # of users and # of items\\n\\t[u_num, i_num] = all_dat.shape\\n\\n\\t# init user factors and item factors with random values\\n\\tu_fac = np.matrix(np.random.rand(u_num, f_num))\\t# MxF\\n\\ti_fac = np.matrix(np.random.rand(i_num, f_num))\\t# NxF\\n\\n\\t# calculate the preference matrix\\n\\tpreference = cal_preference(all_dat)\\n\\n\\t# calculate the confidence matrix\\n\\tconfidence = cal_confidence(all_dat)\\n\\t\\n\\t# recalculate the user factors and item factors using the alternating least square method\\n\\tfor itr in range(iterations):\\n\\t\\tu_fac = alternate_ls(u_num, i_fac, preference, confidence, regularization)\\n\\t\\t#print itr, \\\"u_fac\\\"\\n\\t\\ti_fac = alternate_ls(i_num, u_fac, preference.T, confidence.T, regularization)\\n\\t\\t#print itr, \\\"i_fac\\\"\\n\\t\\n\\t# save the output\\n\\tdf = pd.DataFrame(u_fac)\\n\\tdf.to_csv(\\\"tmp/u_fac.tmp\\\", index=False, header=False, sep='\\\\t', encoding='utf-8')\\n\\tdf = pd.DataFrame(i_fac.T)\\n\\tdf.to_csv(\\\"tmp/i_fac.tmp\\\", index=False, header=False, sep='\\\\t', encoding='utf-8')\\n\\n\\t# an MxF user factor matrix and an FxN item factor matrix\\n\\treturn [u_fac, i_fac.T]\",\n \"def test_lu_factor():\\n\\t#[A, b] = lu_read('test1.txt')\\n\\t# it is poor form to read an external file into a test function, as above\\n\\tA = np.array([\\n\\t\\t[ 2., 3., -4., 2.],\\n\\t\\t[-4., -5., 6., -3.],\\n\\t\\t[ 2., 2., 1., 0.],\\n\\t\\t[-6., -7., 14., -4.]])\\t\\n\\tLU,p = lu_factor(A, pivot=False)\\n\\tLU_soln = np.array([\\n\\t\\t[ 2, 3,-4, 2],\\n\\t\\t[-2, 1,-2, 1],\\n\\t\\t[ 1,-1, 3,-1],\\n\\t\\t[-3, 2, 2, 2]])\\t\\n\\tassert norm(LU - LU_soln) < 1.e-10\\t\\n\\n\\n\\t# test 2\\n\\t[A2, b2] = lu_read('test2.txt')\\t\\t\\t\\t\\t\\t# read a matrix and RHS vector\\n\\tLU2,p2 = lu_factor(A2) \\t\\t\\t\\t\\t\\t\\t\\t# change display to False when LU_FACTOR working\\n\\tLU_soln2 = np.array([\\n\\t\\t [0.01, 0., 0., 0., 0., 0., 0., 0., 0., 0., 1],\\n\\t\\t [-100., 0.01, 0., 0., 0., 0., 0., 0., 0., 0., 100],\\n\\t\\t [0., -100., 0.01, 0., 0., 0., 0., 0., 0., 0., 10000],\\n\\t\\t [0., 0., -100., 0.01, 0., 0., 0., 0., 0., 0., 1000000],\\n\\t\\t [0., 0., 0., -100., 0.01, 0., 0., 0., 0., 0., 100000000],\\n\\t\\t [0., 0., 0., 0., -100., 0.01, 0., 0., 0., 0., 10000000000],\\n\\t\\t [0., 0., 0., 0., 0., -100., 0.01, 0., 0., 0., 1000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., -100., 0.01, 0., 0., 100000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., -100., 0.01, 0., 10000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., -100, 0.01, 1000000000000000000],\\n\\t\\t [0., 0., 0., 0., 0., 0., 0., 0., 0., -100., 100000000000000000000]])\\n\\tassert norm(LU2 - LU_soln2) < 1.e-10\",\n \"def factorsWith(self,v,copy=True):\\n Lv = self.L.getrow(v).tocoo();\\n factors = [Factor([Var(int(v),2)],[-th,th]).exp() for th in [self.h[v]] if self.dims[i]>1]\\n factors = factors + [Factor([Var(int(v),2),Var(int(j),2)],[[th,-th],[-th,th]]).exp() for j,th in zip(Lv.col,Lv.data)]\\n return factors\",\n \"def _als_partial_step_explicit(self, user_mode):\\n # DONE minmize loss function and update factors\\n # Loss = (R - X * Y^T)^2 + λ_x * ||X||^2 + λ_y * ||Y||^2\\n # X = ((Y^T * Y) + λ_x * I)^-1 * (R * Y) for dLoss / dX == 0\\n # Useful functions: np.linalg.inv or np.linalg.solve\\n if user_mode:\\n fixed_factors = self._item_factors\\n updated_factors = self._user_factors\\n ratings = self._ratings\\n reg_loss = self._user_reg_loss\\n else:\\n fixed_factors = self._user_factors\\n updated_factors = self._item_factors\\n ratings = self._ratings.T\\n reg_loss = self._item_reg_loss\\n \\n A = (fixed_factors.T).dot(fixed_factors)\\n A += np.eye(A.shape[0]) * reg_loss\\n \\n B = ratings.dot(fixed_factors)\\n \\n \\n for row in range(updated_factors.shape[0]):\\n updated_factors[row, : ] = np.linalg.solve(A, B[row])\",\n \"def factor(self, A):\\n \\n self.m, self.n = A.shape\\n \\n if self.use_sub_factor:\\n self.sub_factor(A)\\n else:\\n self.A_factorized = spla.factorized(A)\\n \\n #if self.A_factorized is not None:\\n # self.A_factorized.free() \\n #self.A_factorized = pardiso.Factor(A.tocsr())\",\n \"def get_factors(self, triples):\\n pass\",\n \"def factorsWithAny(self,vs):\\n factors = []\\n for v in vs:\\n factors += [Factor([Var(int(v),2)],[-th,th]).exp() for th in [self.h[v]] if self.dims[i]>1]\\n for u in self.markovBlanket(v):\\n if u not in vs or v < u:\\n factors += [Factor([Var(int(v),2),Var(int(u),2)],[[th,-th],[-th,th]]).exp() for th in [L[v,u]] if th!=0] \\n return factors\",\n \"def _factorsX(self, inputs):\\n return tensor.dot(inputs[0], self.wxf)\",\n \"def factor(self):\\r\\n\\t\\t\\r\\n\\t\\t# get gcf\\r\\n\\t\\tg = self.extract()\\r\\n\\t\\t\\r\\n\\t\\t# invert and multiply\\r\\n\\t\\tv = g.invert()\\r\\n\\t\\tf = self.multiply(v)\\r\\n\\t\\t\\r\\n\\t\\treturn f,g\",\n \"def lu_factorization (M) -> list:\\n dim = len(M)\\n L = np.eye(dim)\\n\\n #Itero sulle Incognite da Trovare\\n for i in range(dim-1):\\n\\n #Itero sulle righe su cui devo cancellare un elemento\\n for j in range(i+1,dim):\\n m__j_i = M[j][i] / M[i][i]\\n L[j][i] = m__j_i\\n \\n M[j][i] = 0.0\\n\\n for k in range (i+1,dim):\\n M[j][k] = M[j][k] - m__j_i * M[i][k]\\n \\n\\n return M,L\",\n \"def forward(self, user, item):\\n item_emb = self.product_factors(item.view(-1)) + self.product_bias(\\n item.view(-1)\\n )\\n user_emb = self.user_factors(user.view(-1)) + self.user_bias(user.view(-1))\\n mat_mult = (item_emb * user_emb).sum(1)\\n\\n return mat_mult\",\n \"def nfactors(self):\\n return self.L.nnz\",\n \"def _compute_mu_factor2(*input_mols):\\n mu_factor = 1\\n for mol in input_mols:\\n mu_factor *= np.prod(fact(mol))\\n return mu_factor\",\n \"def doolittle_factorization(self, matrix=None):\\n try:\\n local_matrix = self.matrix.matrix if not matrix else matrix.matrix\\n except AttributeError:\\n local_matrix = matrix\\n \\n (result, upper, lower, temp_sum) = (0.0, [[]], [[]], 0.0)\\n for i in range(len(local_matrix)):\\n lower.append([])\\n for j in range(len(local_matrix[i])):\\n lower[i].append(0)\\n \\n lower.remove([])\\n\\n for i in range(len(local_matrix)):\\n for j in range(len(local_matrix[i])):\\n temp_sum = 0.0\\n for k in range(i):\\n temp_sum += lower[i][k] * upper[k][j]\\n result = local_matrix[i][j] - temp_sum\\n upper[i].append(round(result, 9))\\n upper.append([])\\n \\n for j in range(len(local_matrix[i])):\\n temp_sum = 0.0\\n for k in range(i):\\n temp_sum += lower[j][k] * upper[k][i]\\n result = local_matrix[j][i] - temp_sum\\n lower[j][i] = round(result / upper[i][i], 9)\\n\\n upper.remove([])\\n upper = Matrix(upper, name=\\\"U\\\")\\n lower = Matrix(lower, name=\\\"L\\\")\\n\\n print(\\\"Las matrices son: \\\")\\n upper.print_matrix()\\n lower.print_matrix()\\n\\n print(\\\"Al multiplicarlas queda\\\")\\n comprobation = lower.multiply_matrix(upper.matrix)\\n comprobation.set_name(\\\"comprobación de la factorización LU\\\")\\n comprobation.print_matrix()\\n\\n return (lower, upper)\",\n \"def _compute_kl(self, lvl):\\n kl = [] # kernal length\\n for n in range(lvl):\\n fct = self.scaling**n # up-sampling factor\\n kl.append(fct*(self.nfreq-1)+1)\\n kl.append(kl[-1]) # repeat the value of the coarsest scale for the approximation coefficient\\n return kl[::-1]\",\n \"def compute_factor(X, v, c1, c2):\\n\\n assert np.shape(v)[1] == 1,\\\"v is not a column vector\\\"\\n\\n v = normalize_l2(v)\\n\\n sz_u = np.shape(X)[0]\\n sz_v = np.shape(X)[1]\\n\\n assert sz_v == np.size(v)\\n\\n u = update_with_delta(X @ v, c1)\\n v = update_with_delta(X.T @ u, c2)\\n\\n delta_u = 1000\\n delta_v = 1000\\n\\n while delta_u > 1e-5 or delta_v > 1e-5:\\n oldU = u\\n oldV = v\\n\\n u = update_with_delta(X @ v, c1)\\n v = update_with_delta(X.T @ u, c2)\\n\\n delta_u = npla.norm(u - oldU) / sz_u\\n delta_v = npla.norm(v - oldV) / sz_v\\n\\n d = u.T @ X @ v\\n\\n return (d,u,v)\",\n \"def totient(self,x):\\r\\n dist = self.distr(self.factors(x)).items()\\r\\n if self.verbose: print(dist)\\r\\n \\r\\n # return Euler's result based on product of each prime factor p and its power n\\r\\n # return prod([ p**n*(1-(1/p)) for p,n in dist])\\r\\n # return prod([ p**n*1 - p**n/p for p,n in dist])\\r\\n # return prod([ p**n - p**(n-1) for p,n in dist])\\r\\n \\r\\n return prod([ p**n - p**(n-1) for p,n in dist])\",\n \"def DualDecomposition(model, maxIter=100, verbose=False):\\n lnF = sum( np.log(f.max()) for f in model.factors )\\n lnX, xhat = -np.inf, np.zeros( (len(model.X),), dtype=int) \\n lnR, rhat = -np.inf, np.zeros( (len(model.X),), dtype=int) \\n if verbose: print(\\\"Iter 0: \\\"+str(lnF))\\n \\n for t in xrange(1,maxIter+1): # for each iteration:\\n # Update each variable in turn:\\n for Xi in model.X: # for each variable, \\n flist = model.factorsWith(Xi, copy=False)\\n gamma = [f.maxmarginal([Xi]) for f in flist]\\n avg = np.prod(gamma)**(1.0/len(gamma))\\n for f,g in zip(flist,gamma): f *= avg/(g+1e-300) # !!! numerical issues... \\n xhat[Xi] = avg.argmax()[0] # guess a state for Xi\\n #\\n # Compute the upper bound on the maximum and the value of our current guess\\n lnF = sum( np.log(f.max()) for f in model.factors )\\n lnX = model.logValue( xhat )\\n if lnR < lnX: lnR = lnX; rhat[:]=xhat;\\n if verbose: print(\\\"Iter \\\"+str(t)+\\\": \\\"+str(lnF)+\\\" > \\\"+str(lnX))\\n if (lnF == lnX): break\\n return lnF,lnR,rhat\",\n \"def calEachCrossflowAllAxialNode():\\n AxialNodeno = 14 # axial node number in CFD data\\n Nodes = []\\n base = 'Node'\\n for i in range(0, AxialNodeno):\\n Nodes.append(base+str(i))\\n \\n crossFlow = pd.read_csv('Data_crossflow.csv', index_col = 'Unnamed: 0')\\n lateralFactors = []\\n for node in Nodes:\\n lateralFactors.append(crossFlow[node]/0.8)\\n #need to judge the sign of lateral flow according to CTF rule!!\\n gapsToFlip = [2,4,6,7,9,11,13,14,16,18,20,21] #gaps in y direction\\n gapsToFlipIndex = [x - 1 for x in gapsToFlip]\\n for factors in lateralFactors:\\n for index in gapsToFlipIndex:\\n factors[index] = -factors[index] \\n #note: lateralFactors is a list of list\\n \\n #below calculate factors averaged over all subchannels\\n crossFlowAveFactor = crossFlow.apply(abs).mean(axis = 0)/0.8\\n lateralFactorsAvelist = []\\n for i in range(0,14):\\n base = []\\n for j in range(0,24):\\n base.append(crossFlowAveFactor[i])\\n lateralFactorsAvelist.append(base)\\n \\n \\n for i in range(0, 14):\\n for j in range(0, 24):\\n #note, in the original model there is only one sign for all source\\n #terms in one sub-channel. therefore -- sign(crossFlow.iloc[j,2])\\n lateralFactorsAvelist[i][j] = lateralFactorsAvelist[i][j] *sign(crossFlow.iloc[j,2]) \\n for each in lateralFactorsAvelist:\\n for index in gapsToFlipIndex:\\n each[index] = -each[index] \\n \\n \\n return lateralFactors, lateralFactorsAvelist\",\n \"def do_factor(m=4, q=11):\\n from sage.rings.finite_rings.integer_mod_ring import IntegerModRing\\n from sage.matrix.constructor import identity_matrix, block_matrix\\n from sage.matrix.matrix_space import MatrixSpace\\n from sage.rings.integer_ring import IntegerRing\\n from sage.modules.free_module_integer import IntegerLattice\\n \\n \\n m=n+1\\n ZZ = IntegerRing()\\n ZZ_q = IntegerModRing(q)\\n \\n \\n \\n from sage.arith.all import euler_phi\\n from sage.misc.functional import cyclotomic_polynomial\\n \\n for a in range(\\n R = ZZ_q['x']#.quotient(cyclotomic_polynomial(k, 'x'), 'x')\\n f=cyclotomic_polynomial(m,'x')\\n return f.factor()\",\n \"def _compute_factors(roots, multiplicity, include_powers=False):\\n current = cupy.array([1])\\n suffixes = [current]\\n for pole, mult in zip(roots[-1:0:-1], multiplicity[-1:0:-1]):\\n monomial = cupy.r_[1, -pole]\\n for _ in range(int(mult)):\\n current = cupy.polymul(current, monomial)\\n suffixes.append(current)\\n suffixes = suffixes[::-1]\\n\\n factors = []\\n current = cupy.array([1])\\n for pole, mult, suffix in zip(roots, multiplicity, suffixes):\\n monomial = cupy.r_[1, -pole]\\n block = []\\n for i in range(int(mult)):\\n if i == 0 or include_powers:\\n block.append(cupy.polymul(current, suffix))\\n current = cupy.polymul(current, monomial)\\n factors.extend(reversed(block))\\n\\n return factors, current\",\n \"def _fv(self):\\n return self.beta * (self.x ** self.c)\",\n \"def NMF(model, maxIter=100, beliefs=None, verbose=False):\\n if beliefs is None: beliefs = [Factor([Xi],1.0/Xi.states) for Xi in model.X]\\n \\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\\n for f in model.factors:\\n m = f.log()\\n for v in f.vars: m *= beliefs[v]\\n lnZ += m.sum()\\n if verbose: print(\\\"Iter 0: \\\"+str(lnZ))\\n\\n for t in xrange(1,maxIter+1): # for each iteration:\\n # Update all the beliefs via coordinate ascent:\\n for Xi in model.X: # for each variable, \\n bNew = 0.0 # compute E[ log f ] as a function of Xi:\\n for f in model.factorsWith(Xi,copy=False): # for each factor f_a, compute:\\n m = f.log() # E[log f_a] = \\\\sum \\\\log f_a \\\\prod b_v\\n for v in f.vars - [Xi]: m *= beliefs[v]\\n bNew += m.marginal([Xi]) # sum them up to get E[log f]\\n bNew -= bNew.max() # (numerical issues)\\n bNew = bNew.exp()\\n bNew /= bNew.sum() # set b(Xi) = exp( E[log f] ) / Z\\n beliefs[Xi] = bNew\\n #\\n # Compute the lower bound on the partition function:\\n # E_b [ log f ] + H(b) = \\\\sum_a E[log f_a] + \\\\sum_i H(b_i) for independent beliefs\\n lnZ = sum([beliefs[Xi].entropy() for Xi in model.X])\\n for f in model.factors:\\n m = f.log()\\n for v in f.vars: m *= beliefs[v]\\n lnZ += m.sum()\\n if verbose: print(\\\"Iter \\\"+str(t)+\\\": \\\"+str(lnZ))\\n return lnZ,beliefs\",\n \"def factors(self):\\n self.assert_sampled()\\n return self._factors\",\n \"def normalize(self, factor):\",\n \"def alternating_least_squares(Cui, factors, regularization=0.01,\\n iterations=15, use_native=True, num_threads=0,\\n dtype=np.float64):\\n _check_open_blas()\\n\\n users, items = Cui.shape\\n\\n X = np.random.rand(users, factors).astype(dtype) * 0.01\\n Y = np.random.rand(items, factors).astype(dtype) * 0.01\\n\\n Cui, Ciu = Cui.tocsr(), Cui.T.tocsr()\\n\\n solver = implicit.als.least_squares if use_native else least_squares\\n\\n for iteration in range(iterations):\\n s = time.time()\\n solver(Cui, X, Y, regularization, num_threads)\\n solver(Ciu, Y, X, regularization, num_threads)\\n log.debug(\\\"finished iteration %i in %s\\\", iteration, time.time() - s)\\n\\n return X, Y\",\n \"def fit(self, user_x_product, latent_features_guess=2, learning_rate=0.0002, steps=5000, regularization_penalty=0.02, convergeance_threshold=0.001):\\n print 'training model...'\\n return self.__factor_matrix(user_x_product, latent_features_guess, learning_rate, steps, regularization_penalty, convergeance_threshold)\",\n \"def _factorsH(self, inputs):\\n return tensor.dot(self._hidden_activation(inputs), self.whf)\",\n \"def rebalance(self):\\n\\n # Compute norms along columns for each factor matrix\\n norms = [np.linalg.norm(f, axis=0) for f in self.factors]\\n\\n # Multiply norms across all modes\\n lam = np.prod(norms, axis=0) ** (1/self.ndim)\\n\\n # Update factors\\n self.factors = [f * (lam / fn) for f, fn in zip(self.factors, norms)]\\n return self\",\n \"def fn(i, n):\\n if len(stack) > 0 and stack[-1] <= n: ans.append(stack + [n])\\n for ii in range(i, len(factors)):\\n if n % factors[ii] == 0: \\n stack.append(factors[ii])\\n fn(ii, n//factors[ii])\\n stack.pop()\",\n \"def create_factors(self):\\n\\n super(SVDPlusPlus, self).create_factors()\\n self.y = np.random.normal(self.init_mean, self.init_stdev, (len(self.items), self.factors))\",\n \"def factor_polynomial(a,b,c):\\r\\n afacts = factors(abs(a))\\r\\n cfacts = factors(abs(c))\\r\\n #choose a factor of a (d), then f is a/d and so on\\r\\n for d in afacts:\\r\\n for g in cfacts:\\r\\n f = a/d\\r\\n e = c/g\\r\\n if e*f + d*g == b:\\r\\n print(\\\"{}*x**2 + {}*x + {} = ({}x + {})({}x + {})\\\".format(a,b,c,d,int(e),int(f),g))\\r\\n return\\r\\n #return False\\r\",\n \"def compute_quotients(X = np.zeros((1,1,2))):\\r\\n \\r\\n start=time.time()\\r\\n rad = X[:,:,1]\\r\\n\\r\\n X = np.reshape(X,(X.shape[0],1,X.shape[1]*X.shape[2]))\\r\\n\\r\\n drad = np.asarray([[item[0]/item[1] if item[1] != 0 else 0 for item in list(itertools.combinations(rad[sample],2))] \\\\\\r\\n for sample in range(X.shape[0])])\\r\\n\\r\\n dradsum = np.asarray([[item[0]/item[1] if item[1] != 0 else 0 for item in itertools.combinations([ \\\\\\r\\n item[0]+item[1] for item in list(itertools.combinations(rad[sample],2))], 2)] \\\\\\r\\n for sample in range(drad.shape[0])])\\r\\n \\r\\n drad = np.reshape(drad,(drad.shape[0],1,drad.shape[-1]))\\r\\n drads = np.reshape(dradsum,(dradsum.shape[0],1,dradsum.shape[-1]))\\r\\n\\r\\n X = np.concatenate((drad,drads), axis=2)\\r\\n print('Geometric and packing factors computed in', round(time.time()-start,2),' s')\\r\\n np.save('X', X)\\r\\n \\r\\n return X\",\n \"def _cache_factors(self, Pibra, Piket, Kbra, Kket, eps):\\n q1, p1, Q1, P1 = Pibra\\n q2, p2, Q2, P2 = Piket\\n\\n # If both parameter sets are identical, we are back in the homogeneous case.\\n if q1 == q2 and p1 == p2 and Q1 == Q2 and P1 == P2:\\n self._Hl = None\\n\\n # We have k in [0, 1, ..., K-1] where |K| is the basis size\\n # hence K-1 is the maximal index.\\n L = Kket.get_basis_size()\\n\\n makl = L\\n\\n # Factorials\\n f = factorial(arange(makl))\\n self._f = 1.0 / sqrt(f[:L].reshape(1, -1))\\n\\n # Note: formula currently fails for non-inhomogeneous case\\n # because of divisions by zero in the two args below.\\n argl = ((1.0j * conjugate(P1) * (q1 - q2) - 1.0j * conjugate(Q1) * (p1 - p2)) /\\n (sqrt(1.0j * conjugate(Q2 * P1) - 1.0j * conjugate(Q1 * P2)) *\\n sqrt(1.0j * conjugate(P1) * Q2 - 1.0j * conjugate(Q1) * P2)))\\n\\n # TODO: Better test for failure?\\n if self._doraise and isnan(squeeze(argl)):\\n raise InnerProductException(\\\"Symbolic formula failed due to Q_k = Q_l and P_k = P_l.\\\")\\n\\n # The parameter j varies in the range [0, 1, ..., min(K-1,L-1)]\\n # hence we have that k-j can be in [K-1, K-2, ..., K-1-min(K-1,L-1)]\\n # and similar for l-j we have [L-1, L-2, ..., L-1-min(K-1,L-1)]\\n # where both K-1-min(K-1,L-1) and L-1-min(K-1,L-1) are non-negative.\\n self._Hl = self._evaluate_hermite(L - 1, 1.0 / eps * argl)\\n\\n il = arange(L).reshape(-1, 1)\\n self._pfl = ((1.0j * conjugate(Q2 * P1) - 1.0j * conjugate(Q1 * P2)) ** (il / 2.0)).reshape(L)\\n\\n # And the groundstate value\\n self._I0 = self.exact_result_ground(Pibra, Piket, eps)\",\n \"def removeFactors(self,flist, isLog=False):\\n # Currently: just divide out factors (add inverse factors) -- can't check if factor present? (minimal)\\n # TODO: set entries to zero, then call self.L.eliminate_zeros()\\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\\n for k,f in enumerate(flist):\\n if not isLog: \\n if np.any(f.t==0): f = f+1e-30; # TODO: log nonzero tol\\n f = f.log()\\n if f.nvar == 1:\\n Xi = f.vars[0]\\n self.h[Xi] -= .5*(f[1]-f[0])\\n self.c -= .5*(f[1]+f[0])\\n else:\\n Xi,Xj = f.vars[0],f.vars[1]\\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \\n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n self.h[Xi] -= .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.h[Xj] -= .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.c -= .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\\n self.L -= csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar)); \\n #raise NotImplementedError();\",\n \"def sub_factor(self, A):\\n \\n #\\n # In general, to slice a sparse matrix use:\\n #\\n # indices = np.where(bool_vect)[0]\\n # out1 = M.tocsc()[:,indices] # for column slices\\n # out2 = M.tocsr()[indices,:] # for row slices\\n #\\n \\n print \\\"Running subfactor routine.\\\"\\n \\n self.m, self.n = A.shape\\n \\n # Build fixed/known solution vector mask\\n x_sol_mask = numpy.zeros((self.n,));\\n x_sol_mask[self.xinds] = 1;\\n \\n # Get the indices for the unknowns\\n unknown_inds_mask = numpy.logical_not(x_sol_mask)\\n self.unknown_inds = numpy.arange(self.n)[unknown_inds_mask]\\n \\n # Store internal r.h.s. for known part\\n Apart = A.tocsc()[:,self.xinds]\\n self.r = Apart.dot(self.xsol)\\n # note: in the backsolve step this is subtracted from b, and it\\n # works even if xsol is a matrix, with each column corresponding\\n # to the known part of the solution for each column of b.\\n \\n # Get the part of A that corresponds to the unknown displacements.\\n Asub = A.tocsr()[self.unknown_inds,:]\\n Asub = Asub.tocsc()[:,self.unknown_inds]\\n\\n self.Asub_factorized = spla.factorized(Asub)\\n #if self.Asub_factorized is not None:\\n # self.Asub_factorized.free() \\n #self.Asub_factorized = pardiso.Factor(Asub.tocsr())\\n \\n print \\\"Done with subfactor routine.\\\"\",\n \"def __init__(self, user_factors, item_factors):\\n self._user_factors = np.copy(user_factors)\\n self._item_factors = np.copy(item_factors)\\n \\n self._users_num = user_factors.shape[0]\\n self._items_num = item_factors.shape[0]\\n\\n assert user_factors.shape[1] == item_factors.shape[1]\",\n \"def AlternatingLeastSquares(\\n factors=100,\\n regularization=0.01,\\n alpha=1.0,\\n dtype=np.float32,\\n use_native=True,\\n use_cg=True,\\n use_gpu=implicit.gpu.HAS_CUDA,\\n iterations=15,\\n calculate_training_loss=False,\\n num_threads=0,\\n random_state=None,\\n):\\n if use_gpu:\\n return implicit.gpu.als.AlternatingLeastSquares(\\n factors,\\n regularization,\\n alpha,\\n dtype=dtype,\\n iterations=iterations,\\n calculate_training_loss=calculate_training_loss,\\n random_state=random_state,\\n )\\n return implicit.cpu.als.AlternatingLeastSquares(\\n factors,\\n regularization,\\n alpha,\\n dtype,\\n use_native,\\n use_cg,\\n iterations,\\n calculate_training_loss,\\n num_threads,\\n random_state,\\n )\",\n \"def exo1():\\n randu = randn(N/ 2, N/ 2, 2); % a random vector field\\n b = 2\\n for i in 1: 4:\\n LLs_u = Li{i}(LiS{i}(randu))\\n % relative error should be very small\\n norm(abs(LLs_u(: ) - b*randu(: )))/ norm(randu(: ))\",\n \"def _factorsY(self, inputs):\\n return tensor.dot(inputs[1], self.wyf)\",\n \"def F(cst, x):\\n [u0, v0, u1, v1, u2, v2, coeffs] = cst\\n [u, v, g1, g2, g3] = x\\n a = g1*u1 - u0\\n b = g2*u2 - u0\\n c = g3*u - u0\\n l = g1*v1 - v0 \\n m = g2*v2 - v0\\n n = g3*v - v0\\n r = g1 - 1\\n s = g2 - 1\\n t = g3 - 1\\n return np.array([\\n coeffs[0]*(a**2-l**2) + 2*coeffs[1]*(a*b-l*m) + coeffs[2]*(b**2-m**2) + 2*coeffs[3]*(a*c-l*n) + 2*coeffs[4]*(b*c-m*n) + c**2 - n**2,\\n coeffs[0]*(l**2-r**2) + 2*coeffs[1]*(l*m-r*s) + coeffs[2]*(m**2-s**2) + 2*coeffs[3]*(l*n-r*t) + 2*coeffs[4]*(m*n-s*t) + n**2 - t**2,\\n coeffs[0]*a*l + coeffs[1]*(l*b+m*a) + coeffs[2]*m*b + coeffs[3]*(l*c+n*a) + coeffs[4]*(m*c+b*n) + c*n,\\n coeffs[0]*a*r + coeffs[1]*(r*b+s*a) + coeffs[2]*s*b + coeffs[3]*(r*c+t*a) + coeffs[4]*(s*c+b*t) + c*t,\\n coeffs[0]*r*l + coeffs[1]*(l*s+m*r) + coeffs[2]*m*s + coeffs[3]*(l*t+n*r) + coeffs[4]*(m*t+s*n) + t*n \\n ])\",\n \"def get_factors(self, x: np.ndarray, y: np.ndarray) -> np.ndarray:\\n if self.fit_result:\\n return 1. / (funcs.gaussian_2d(x, y, **self.fit_result) /\\n self.fit_amplitude)\\n else:\\n return np.transpose(1. / self.interp(np.array([y, x]).T))\",\n \"def compute_norm_fac_per_weight(fan_in):\\n ksi = 1. / math.sqrt(fan_in)\\n return (1 / 3) * ksi ** 2\",\n \"def landau1(n):\\n\\n i = 2\\n sum_factors = 1\\n factors = set()\\n\\n while i <= n: \\n common = {j for j in factors if gcd(j, i) != 1}\\n if len(common) == 0:\\n factors = add_factor(i, n, factors)\\n sum_factors = sum(factors)\\n elif product(common) <= i:\\n difference = factors.difference(common)\\n new_factors = add_factor(i, n, difference)\\n if product(new_factors) > product(factors):\\n factors = new_factors\\n sum_factors = sum(factors)\\n i += 1\\n\\n print(n, product(factors), factors)\\n return product(factors)\",\n \"def fs_form_factor(x_c_m,t_c,mach,max_t_sweep):\\n return (1.0+(0.6/x_c_m)*t_c+100.0*(t_c**4))*(1.34*(mach**0.18)*((np.cos(np.deg2rad(max_t_sweep)))**0.28))\",\n \"def test_two_qubit_weyl_decomposition_aama(self, smallest=1e-18, factor=9.8, steps=11):\\n for aaa in (\\n [smallest * factor**i for i in range(steps)]\\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\\n ):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(aaa, aaa, -aaa)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def solve():\\n result = 1\\n map = dict()\\n for x in range(2, 20):\\n temp = prime_factors(x)\\n for n in range(2, 20):\\n if n in temp:\\n if n in map:\\n map[n] = max(temp.count(n), map[n])\\n else:\\n map[n] = temp.count(n)\\n\\n for x in map:\\n result *= (x ** map[x])\\n\\n return result\",\n \"def calculate_217f_part_stress(**attributes): # pylint: disable=R0912, R0914\\n _dic_ref_temp = {\\n 1: 343.0,\\n 2: {\\n 1: 343.0,\\n 2: 343.0,\\n 3: 398.0,\\n 4: 398.0\\n },\\n 3: 298.0,\\n 5: 398.0,\\n 6: 298.0,\\n 7: 298.0,\\n 9: 358.0,\\n 10: 358.0,\\n 11: 313.0,\\n 12: 298.0,\\n 13: 358.0,\\n 14: 343.0,\\n 15: 343.0\\n }\\n _dic_factors = {\\n 1: [4.5E-9, 12.0, 1.0, 0.6, 1.0, 1.0],\\n 2: {\\n 1: [3.25E-4, 1.0, 3.0, 1.0, 1.0, 1.0],\\n 2: [3.25E-4, 1.0, 3.0, 1.0, 1.0, 1.0],\\n 3: [5.0E-5, 3.5, 1.0, 1.0, 1.0, 1.0],\\n 4: [5.0E-5, 3.5, 1.0, 1.0, 1.0, 1.0]\\n },\\n 3: [7.33E-3, 0.202, 2.6, 1.45, 0.89, 1.3],\\n 5: [0.0031, 1.0, 10.0, 1.0, 1.0, 1.5],\\n 6: [0.00148, 1.0, 2.0, 0.5, 1.0, 1.0],\\n 7: [0.00015, 2.64, 1.0, 0.466, 1.0, 1.0],\\n 8: [0.021, 0.065, 0.105, 0.0, 0.0, 0.0],\\n 9: [0.0062, 1.0, 5.0, 1.0, 1.0, 1.0],\\n 10: [0.0735, 1.03, 4.45, 2.74, 3.51, 1.0],\\n 11: [0.0398, 0.514, 5.28, 1.44, 4.46, 1.0],\\n 12: [0.0481, 0.334, 4.66, 1.47, 2.83, 1.0],\\n 13: [0.019, 0.445, 7.3, 2.69, 2.46, 1.0],\\n 14: [0.0246, 0.459, 9.3, 2.32, 5.3, 1.0],\\n 15: [0.018, 1.0, 7.4, 2.55, 3.6, 1.0]\\n }\\n _dic_piQ = {\\n 1: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\\n 2: [0.03, 0.1, 0.3, 1.0, 5.0, 5.0, 15.0],\\n 3: [1.0, 3.0],\\n 4: [1.0, 3.0],\\n 5: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\\n 6: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\\n 7: [0.03, 0.1, 0.3, 1.0, 5.0, 15.0],\\n 8: [1.0, 15.0],\\n 9: [0.02, 0.06, 0.2, 0.6, 3.0, 10.0],\\n 10: [2.5, 5.0],\\n 11: [2.0, 4.0],\\n 12: [2.0, 4.0],\\n 13: [0.02, 0.06, 0.2, 0.6, 3.0, 10.0],\\n 14: [2.5, 5.0],\\n 15: [2.0, 4.0]\\n }\\n _dic_piE = {\\n 1: [\\n 1.0, 3.0, 8.0, 5.0, 13.0, 4.0, 5.0, 7.0, 11.0, 19.0, 0.5, 11.0,\\n 27.0, 490.0\\n ],\\n 2: [\\n 1.0, 2.0, 8.0, 4.0, 14.0, 4.0, 8.0, 10.0, 18.0, 19.0, 0.2, 10.0,\\n 28.0, 510.0\\n ],\\n 3: [\\n 1.0, 2.0, 10.0, 5.0, 17.0, 6.0, 8.0, 14.0, 18.0, 25.0, 0.5, 14.0,\\n 36.0, 660.0\\n ],\\n 4: [\\n 1.0, 2.0, 10.0, 5.0, 17.0, 6.0, 8.0, 14.0, 18.0, 25.0, 0.5, 14.0,\\n 36.0, 660.0\\n ],\\n 5: [\\n 1.0, 2.0, 11.0, 5.0, 18.0, 15.0, 18.0, 28.0, 35.0, 27.0, 0.8, 14.0,\\n 38.0, 610.0\\n ],\\n 6: [\\n 1.0, 2.0, 10.0, 5.0, 16.0, 4.0, 8.0, 9.0, 18.0, 23.0, 0.3, 13.0,\\n 34.0, 610.0\\n ],\\n 7: [\\n 1.0, 2.0, 10.0, 5.0, 16.0, 4.0, 8.0, 9.0, 18.0, 23.0, 0.5, 13.0,\\n 34.0, 610.0\\n ],\\n 8: [\\n 1.0, 5.0, 21.0, 11.0, 24.0, 11.0, 30.0, 16.0, 42.0, 37.0, 0.5,\\n 20.0, 53.0, 950.0\\n ],\\n 9: [\\n 1.0, 2.0, 12.0, 6.0, 20.0, 5.0, 8.0, 9.0, 15.0, 33.0, 0.5, 18.0,\\n 48.0, 870.0\\n ],\\n 10: [\\n 1.0, 2.0, 18.0, 8.0, 30.0, 8.0, 12.0, 13.0, 18.0, 53.0, 0.5, 29.0,\\n 76.0, 1400.0\\n ],\\n 11: [\\n 1.0, 2.0, 16.0, 7.0, 28.0, 8.0, 12.0, 0.0, 0.0, 38.0, 0.5, 0.0,\\n 0.0, 0.0\\n ],\\n 12: [\\n 1.0, 3.0, 16.0, 7.0, 28.0, 8.0, 12.0, 0.0, 0.0, 38.0, 0.5, 0.0,\\n 0.0, 0.0\\n ],\\n 13: [\\n 1.0, 3.0, 14.0, 6.0, 24.0, 5.0, 7.0, 12.0, 18.0, 39.0, 0.5, 22.0,\\n 57.0, 1000.0\\n ],\\n 14: [\\n 1.0, 2.0, 19.0, 8.0, 29.0, 40.0, 65.0, 48.0, 78.0, 46.0, 0.5, 25.0,\\n 66.0, 1200.0\\n ],\\n 15: [\\n 1.0, 3.0, 14.0, 7.0, 24.0, 6.0, 12.0, 20.0, 30.0, 39.0, 0.5, 22.0,\\n 57.0, 1000.0\\n ]\\n }\\n # Resistance factor (piR) dictionary of values. The key is the\\n # subcategory ID. The index in the returned list is the resistance range\\n # breakpoint (breakpoint values are in _lst_breakpoints below). For\\n # subcategory ID 6 and 7, the specification ID selects the correct set of\\n # lists, then the style ID selects the proper list of piR values and then\\n # the resistance range breakpoint is used to select\\n _dic_piR = {\\n 1: [1.0, 1.1, 1.6, 2.5],\\n 2: [1.0, 1.1, 1.6, 2.5],\\n 3: [1.0, 1.2, 1.3, 3.5],\\n 5: [1.0, 1.7, 3.0, 5.0],\\n 6: [[[1.0, 1.0, 1.2, 1.2, 1.6, 1.6, 1.6,\\n 0.0], [1.0, 1.0, 1.0, 1.2, 1.6, 1.6, 0.0,\\n 0.0], [1.0, 1.0, 1.0, 1.0, 1.2, 1.2, 1.2,\\n 1.6], [1.0, 1.2, 1.6, 1.6, 0.0, 0.0, 0.0, 0.0],\\n [1.0, 1.6, 0.0, 0.0, 0.0, 0.0, 0.0,\\n 0.0], [1.0, 1.6, 1.6, 0.0, 0.0, 0.0, 0.0,\\n 0.0], [1.0, 1.0, 1.1, 1.2, 1.2, 1.6, 0.0, 0.0],\\n [1.0, 1.0, 1.4, 0.0, 0.0, 0.0, 0.0, 0.0]],\\n [[1.0, 1.0, 1.0, 1.0, 1.2, 1.6], [1.0, 1.0, 1.0, 1.2, 1.6, 0.0],\\n [1.0, 1.0, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.0, 2.0, 0.0, 0.0], [\\n 1.0, 1.0, 1.0, 2.0, 0.0, 0.0\\n ], [1.0, 1.0, 1.2, 2.0, 0.0, 0.0], [1.0, 1.2, 1.4, 0.0, 0.0, 0.0],\\n [1.0, 1.0, 1.6, 0.0, 0.0, 0.0], [1.0, 1.0, 1.2, 2.0, 0.0, 0.0], [\\n 1.0, 1.0, 1.2, 1.6, 0.0, 0.0\\n ], [1.0, 1.0, 1.0, 1.4, 0.0, 0.0], [1.0, 1.0, 1.0, 1.2, 0.0, 0.0],\\n [1.0, 1.0, 1.4, 0.0, 0.0, 0.0], [1.0, 1.2, 1.6, 0.0, 0.0, 0.0], [\\n 1.0, 1.0, 1.4, 0.0, 0.0, 0.0\\n ], [1.0, 1.0, 1.2, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.4, 0.0, 0.0],\\n [1.0, 1.0, 1.0, 1.4, 0.0, 0.0], [1.0, 1.0, 1.0, 1.4, 0.0, 0.0], [\\n 1.0, 1.0, 1.2, 1.5, 0.0, 0.0\\n ], [1.0, 1.0, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.0, 1.4, 1.6, 0.0],\\n [1.0, 1.0, 1.0, 1.4, 1.6, 2.0], [1.0, 1.0, 1.0, 1.4, 1.6, 2.0], [\\n 1.0, 1.0, 1.4, 2.4, 0.0, 0.0\\n ], [1.0, 1.0, 1.2, 2.6, 0.0,\\n 0.0], [1.0, 1.0, 1.0, 0.0, 0.0,\\n 0.0], [1.0, 1.0, 1.0, 0.0, 0.0,\\n 0.0], [1.0, 1.0, 0.0, 0.0, 0.0, 0.0], [\\n 1.0, 1.2, 1.4, 0.0, 0.0, 0.0\\n ], [1.0, 1.0, 1.2, 1.6, 0.0,\\n 0.0], [1.0, 1.0, 1.0, 1.6, 0.0, 0.0], [\\n 1.0, 1.0, 1.4, 0.0, 0.0, 0.0\\n ], [1.0, 1.2, 1.5, 0.0, 0.0,\\n 0.0], [1.0, 1.2, 0.0, 0.0, 0.0, 0.0]]],\\n 7: [[[1.0, 1.2, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.2, 1.6, 0.0, 0.0],\\n [1.0, 1.0, 1.2, 1.2, 1.6, 0.0], [1.0, 1.0, 1.0, 1.1, 1.2, 1.6],\\n [1.0, 1.0, 1.0, 1.0, 1.2, 1.6], [1.0, 1.0, 1.0, 1.0, 1.2, 1.6]],\\n [[1.0, 1.2, 1.6, 0.0, 0.0, 0.0], [1.0, 1.2, 1.6, 0.0, 0.0, 0.0],\\n [1.0, 1.0, 1.2, 1.6, 0.0, 0.0], [1.0, 1.0, 1.1, 1.2, 1.4, 0.0],\\n [1.0, 1.0, 1.0, 1.2, 1.6, 0.0], [1.0, 1.0, 1.0, 1.1, 1.4, 0.0]]],\\n 9: [1.0, 1.4, 2.0],\\n 10: [1.0, 1.1, 1.4, 2.0, 2.5, 3.5],\\n 11: [1.0, 1.4, 2.0],\\n 12: [1.0, 1.4, 2.0],\\n 13: [1.0, 1.1, 1.2, 1.4, 1.8],\\n 14: [1.0, 1.1, 1.2, 1.4, 1.8],\\n 15: [1.0, 1.1, 1.2, 1.4, 1.8]\\n }\\n # Dictionary containing the number of element breakpoints for determining\\n # the resistance factor list to use.\\n _dic_breakpoints = {\\n 1: [1.0E5, 1.0E6, 1.0E7],\\n 2: [1.0E5, 1.0E6, 1.0E7],\\n 3: [100.0, 1.0E5, 1.0E6],\\n 5: [1.0E4, 1.0E5, 1.0E6],\\n 6: [[500.0, 1.0E3, 5.0E3, 7.5E3, 1.0E4, 1.5E4, 2.0E4],\\n [100.0, 1.0E3, 1.0E4, 1.0E5, 1.5E5, 2.0E5]],\\n 7: [500.0, 1.0E3, 5.0E3, 1.0E4, 2.0E4],\\n 9: [2.0E3, 5.0E3],\\n 10: [1.0E4, 2.0E4, 5.0E4, 1.0E5, 2.0E5],\\n 11: [2.0E3, 5.0E3],\\n 12: [2.0E3, 5.0E3],\\n 13: [5.0E4, 1.0E5, 2.0E5, 5.0E5],\\n 14: [5.0E4, 1.0E5, 2.0E5, 5.0E5],\\n 15: [1.0E4, 5.0E4, 2.0E5, 1.0E6]\\n }\\n _dic_piV = {\\n 9: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\\n 10: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\\n 11: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\\n 12: [1.1, 1.05, 1.0, 1.1, 1.22, 1.4, 2.0],\\n 13: [1.0, 1.05, 1.2],\\n 14: [1.0, 1.05, 1.2],\\n 15: [1.0, 1.05, 1.2]\\n }\\n _dic_piC = {10: [2.0, 1.0, 3.0, 1.5], 12: [2.0, 1.0]}\\n _msg = ''\\n\\n # Calculate the base hazard rate.\\n if attributes['subcategory_id'] == 2:\\n _ref_temp = _dic_ref_temp[attributes['subcategory_id']][attributes[\\n 'specification_id']]\\n _f0 = _dic_factors[attributes['subcategory_id']][attributes[\\n 'specification_id']][0]\\n _f1 = _dic_factors[attributes['subcategory_id']][attributes[\\n 'specification_id']][1]\\n _f2 = _dic_factors[attributes['subcategory_id']][attributes[\\n 'specification_id']][2]\\n _f3 = _dic_factors[attributes['subcategory_id']][attributes[\\n 'specification_id']][3]\\n _f4 = _dic_factors[attributes['subcategory_id']][attributes[\\n 'specification_id']][4]\\n _f5 = _dic_factors[attributes['subcategory_id']][attributes[\\n 'specification_id']][5]\\n elif attributes['subcategory_id'] not in [4, 8]:\\n _ref_temp = _dic_ref_temp[attributes['subcategory_id']]\\n _f0 = _dic_factors[attributes['subcategory_id']][0]\\n _f1 = _dic_factors[attributes['subcategory_id']][1]\\n _f2 = _dic_factors[attributes['subcategory_id']][2]\\n _f3 = _dic_factors[attributes['subcategory_id']][3]\\n _f4 = _dic_factors[attributes['subcategory_id']][4]\\n _f5 = _dic_factors[attributes['subcategory_id']][5]\\n\\n if attributes['subcategory_id'] == 4:\\n attributes['lambda_b'] = 0.00006\\n elif attributes['subcategory_id'] == 8:\\n attributes['lambda_b'] = _dic_factors[attributes['subcategory_id']][\\n attributes['type_id'] - 1]\\n else:\\n attributes['lambda_b'] = _f0 * exp(_f1 * (\\n (attributes['temperature_active'] + 273.0) /\\n _ref_temp))**_f2 * exp(((attributes['power_ratio'] / _f3) * (\\n (attributes['temperature_active'] + 273.0) / 273.0)**_f4)**_f5)\\n\\n if attributes['lambda_b'] <= 0.0:\\n _msg = _msg + 'RAMSTK WARNING: Base hazard rate is 0.0 when ' \\\\\\n 'calculating resistor, hardware ID: ' \\\\\\n '{0:d}'.format(attributes['hardware_id'])\\n\\n # Calculate the resistance factor (piR).\\n if attributes['subcategory_id'] not in [4, 8]:\\n _index = -1\\n if attributes['subcategory_id'] == 6:\\n _breaks = _dic_breakpoints[attributes['subcategory_id']][\\n attributes['specification_id'] - 1]\\n else:\\n _breaks = _dic_breakpoints[attributes['subcategory_id']]\\n\\n for _index, _value in enumerate(_breaks):\\n _diff = _value - attributes['n_elements']\\n if len(_breaks) == 1 and _diff < 0:\\n break\\n elif _diff >= 0:\\n break\\n\\n if attributes['subcategory_id'] in [6, 7]:\\n attributes['piR'] = _dic_piR[attributes['subcategory_id']][\\n attributes['specification_id'] - 1][attributes['family_id'] -\\n 1][_index + 1]\\n elif attributes['subcategory_id'] not in [4, 8]:\\n attributes['piR'] = _dic_piR[attributes['subcategory_id']][_index +\\n 1]\\n\\n # Determine the quality factor (piQ).\\n attributes['piQ'] = _dic_piQ[attributes['subcategory_id']][\\n attributes['quality_id'] - 1]\\n\\n if attributes['piQ'] <= 0.0:\\n _msg = _msg + 'RAMSTK WARNING: piQ is 0.0 when calculating ' \\\\\\n 'resistor, hardware ID: {0:d}'.format(attributes['hardware_id'])\\n\\n # Determine the environmental factor (piE).\\n attributes['piE'] = _dic_piE[attributes['subcategory_id']][\\n attributes['environment_active_id'] - 1]\\n\\n if attributes['piE'] <= 0.0:\\n _msg = _msg + 'RAMSTK WARNING: piE is 0.0 when calculating ' \\\\\\n 'resistor, hardware ID: {0:d}'.format(attributes['hardware_id'])\\n\\n # Calculate the temperature factor (piT).\\n if attributes['subcategory_id'] == 4:\\n attributes['temperature_case'] = (attributes['temperature_active'] +\\n 55.0 * attributes['power_ratio'])\\n attributes['piT'] = exp(-4056.0 * (\\n (1.0 / (attributes['temperature_case'] + 273.0)) - 1.0 / 298.0))\\n\\n # Calculate the taps factor (piTAPS).\\n if attributes['subcategory_id'] in [9, 10, 11, 12, 13, 14, 15]:\\n attributes['piTAPS'] = (attributes['n_elements']**1.5 / 25.0) + 0.792\\n\\n # Calculate the voltage factor (piV).\\n if attributes['subcategory_id'] > 8:\\n _index = -1\\n if attributes['subcategory_id'] in [9, 10, 11, 12]:\\n _breaks = [0.1, 0.2, 0.6, 0.7, 0.8, 0.9]\\n elif attributes['subcategory_id'] in [13, 14, 15]:\\n _breaks = [0.8, 0.9]\\n for _index, _value in enumerate(_breaks):\\n _diff = _value - attributes['voltage_ratio']\\n if len(_breaks) == 1 and _diff < 0.0:\\n break\\n elif _index == 0 and _diff >= 0.0:\\n break\\n elif _diff >= 0:\\n break\\n attributes['piV'] = _dic_piV[attributes['subcategory_id']][_index]\\n\\n # Determine the consruction class factor (piC).\\n if attributes['subcategory_id'] in [10, 12]:\\n attributes['piC'] = _dic_piC[attributes['subcategory_id']][\\n attributes['construction_id'] - 1]\\n\\n # Calculate the active hazard rate.\\n attributes['hazard_rate_active'] = (\\n attributes['lambda_b'] * attributes['piQ'] * attributes['piE'])\\n if attributes['subcategory_id'] == 4:\\n attributes['hazard_rate_active'] = (\\n attributes['hazard_rate_active'] * attributes['piT'] *\\n attributes['n_elements'])\\n elif attributes['subcategory_id'] in [9, 11, 13, 14, 15]:\\n attributes['hazard_rate_active'] = (\\n attributes['hazard_rate_active'] * attributes['piTAPS'] *\\n attributes['piR'] * attributes['piV'])\\n elif attributes['subcategory_id'] in [10, 12]:\\n attributes['hazard_rate_active'] = (\\n attributes['hazard_rate_active'] * attributes['piTAPS'] *\\n attributes['piC'] * attributes['piR'] * attributes['piV'])\\n elif attributes['subcategory_id'] != 8:\\n attributes['hazard_rate_active'] = (\\n attributes['hazard_rate_active'] * attributes['piR'])\\n\\n return attributes, _msg\",\n \"def improve(factors):\\n factors = defaultdict(int, factors)\\n improvement = 0\\n for a, b in find_pairs(factors):\\n c = a*b\\n # If local improvement is possible, create remove the two\\n # old factors once and introduce a new one\\n if DR[c] >= DR[a] + DR[b]:\\n new_factors = factors.copy()\\n new_factors[a] -= 1\\n new_factors[b] -= 1\\n new_factors[c] += 1\\n improvement += 1\\n improve(new_factors)\\n\\n # If no more local improvements are possible then add\\n # to the pool of local optima as candidates for MDRS\\n if not improvement:\\n candidates.append(factors)\",\n \"def empirical( cliques, data, normalize=False):\\n factors = [None]*len(cliques)\\n for i,vs in enumerate(cliques):\\n vs_data = np.array([data[v] for v in vs])\\n if len(vs_data.shape)>1: vs_data = vs_data.T # data axis first, now\\n factors[i] = Factor(vs, 0.)\\n for xs in vs_data:\\n if np.any(np.isnan(xs)): continue # skip data with missing entries \\n factors[i].t[ tuple(xs.astype(int)) ] += 1.\\n if normalize: factors[i].t /= factors[i].sum()\\n return factors\",\n \"def test_two_qubit_weyl_decomposition_ab0(self, smallest=1e-18, factor=9.8, steps=11):\\n for aaa in (\\n [smallest * factor**i for i in range(steps)]\\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\\n ):\\n for bbb in np.linspace(0, aaa, 10):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(aaa, bbb, 0)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def test_two_qubit_weyl_decomposition_aaa(self, smallest=1e-18, factor=9.8, steps=11):\\n for aaa in (\\n [smallest * factor**i for i in range(steps)]\\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\\n ):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(aaa, aaa, aaa)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def _compute_mu_factor(*input_mols):\\n return np.sqrt(_compute_mu_factor2(*input_mols))\",\n \"def projective_factorization(x, max_iterations=1):\\n\\n n_views = len(x)\\n n_points = x[0].shape[1]\\n\\n iterations = 0\\n\\n #lambda matrix, approximate depths\\n l = np.ones((n_views, n_points))\\n\\n #normalization matrices\\n norm_matrices = []\\n\\n # normalize coordinates\\n xn = np.zeros((3*n_views, n_points))\\n for i in range(n_views):\\n\\n #find normalization matrix for projections i\\n x_norm, T = normalize_points(x[i], is_homogeneous=True)\\n xn[3*i:3*(i+1), :] = x_norm\\n norm_matrices.append(T)\\n\\n while iterations < max_iterations:\\n # normalize the lambda matrix\\n lr_norm = norm(l, axis=1)\\n ln = l / lr_norm[:, np.newaxis]\\n lc_norm = norm(ln, axis=0)\\n ln /= lc_norm\\n\\n # repeat the lambdas\\n ln = np.repeat(ln, 3, axis=0)\\n\\n #build the factorization matrix\\n fact_matrix = ln*xn\\n\\n u, d, vh = svd(fact_matrix)\\n\\n print(d[3] / d[4])\\n d = d[:4]/d[0]\\n\\n # from the svd decomposition we can find the projections and 3d points\\n p_matrices = u[:, :4]\\n x_3d = np.dot(np.diag(d), vh[:4, :])\\n\\n iterations += 1\\n if iterations != max_iterations:\\n\\n w_matrix = np.dot(p_matrices, x_3d)\\n\\n for i in range(n_views):\\n l[i, :] = w_matrix[3*i+2, :]\\n\\n cameras = []\\n\\n for i in range(n_views):\\n # denormalize camera matrices\\n c_matrix = np.dot(inv(norm_matrices[i]), p_matrices[3*i:3*(i+1), :])\\n\\n cameras.append(c_matrix)\\n\\n return cameras, x_3d\",\n \"def get_norm_factor(self, arr):\\r\\n\\r\\n\\t\\tif self.func == \\\"sigmoid\\\":\\r\\n\\t\\t\\tnorm_factor = sigmoid(arr, *self.popt) \\r\\n\\t\\telif self.func == \\\"constant\\\":\\r\\n\\t\\t\\tnorm_factor = arr*0 + self.popt\\t#ensures that output is the same size as arr\\r\\n\\t\\treturn(norm_factor)\",\n \"def test_two_qubit_weyl_decomposition_aa0(self, smallest=1e-18, factor=9.8, steps=11):\\n for aaa in (\\n [smallest * factor**i for i in range(steps)]\\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\\n ):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(aaa, aaa, 0)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def get_scale_factor(self, jets, passing_cut):\\n # First of all flatten everything to make it easier to handle\\n pt = ak.to_numpy(ak.flatten(jets.pt))\\n eta = ak.to_numpy(ak.flatten(jets.eta))\\n flav = ak.to_numpy(ak.flatten(jets.hadronFlavour))\\n pass_wp = ak.to_numpy(ak.flatten(jets[passing_cut]))\\n\\n # Get the MC efficiency\\n eff = self.efficiency_(pt, eta, flav)\\n # for each systematic/central value compute the proper SF\\n # cache the SF values as sometimes they are repeated, there \\n # might also be systematic combinations that are never accessed\\n # but pruning them at the beginning can be hard\\n # use schema to define combinations, lcb is a tuple with the sf keys\\n # for light, charm, bottom for each systematic\\n flavour_sf_cache = {}\\n scale_factors = {} # our final product\\n for key, lcb in self.schema_.items(): \\n # populate cache if needed\\n for i in range(3):\\n # protect against using prelim csv files that don't have UDSG wps\\n flavour_sf_cache[lcb[i]] = np.ones(eta.size) if lcb[i] not in self.sf_.keys() else flavour_sf_cache.get(lcb[i], self.sf_[lcb[i]](eta, pt, pass_wp))\\n \\n scale_factors[key] = eff * self.match_flav_(\\n flavour_sf_cache[lcb[0]],\\n flavour_sf_cache[lcb[1]],\\n flavour_sf_cache[lcb[2]],\\n flav\\n )\\n\\n # use SF and eff to compute p(data) and p(MC)\\n p_data = {key : np.where(pass_wp, val, 1 - val) \\n for key, val in scale_factors.items()}\\n p_mc = np.where(pass_wp, eff, 1 - eff)\\n\\n # return the unflattened version of the ratio\\n return {key : ak.unflatten(i/p_mc, ak.num(jets.pt))\\n for key, i in p_data.items()}\",\n \"def test_two_qubit_weyl_decomposition_a00(self, smallest=1e-18, factor=9.8, steps=11):\\n for aaa in (\\n [smallest * factor**i for i in range(steps)]\\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\\n ):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(aaa, 0, 0)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def update_factors(self,u,i,j,update_u=True,update_i=True):\\n #print(\\\"session run\\\")\\n loss_v = self.sess.run(self.train_step , feed_dict={\\n self.u: u,\\n self.i: i,\\n self.j: j})\\n\\n returnText = \\\"\\\"\\n\\n if self.alg_type == \\\"TFL\\\" or self.alg_type == \\\"TFLWM\\\":\\n sum_lambda = 0\\n for k in self.sim_matrix_names:\\n sum_lambda += abs(self.sim_lambda[k].eval())\\n #print(sum_lambda,self.sim_lambda)\\n for k in self.sim_matrix_names:\\n if math.isnan(sum_lambda):\\n print(\\\"sim_lambda overflow\\\")\\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\\n returnText = \\\"sim_lambda overflow\\\"\\n else:\\n tf.assign(self.sim_lambda[k], self.sim_lambda[k].eval()/sum_lambda).eval()\\n else:\\n for k in self.sim_matrix_names:\\n val = self.sim_lambda[k].eval()\\n if math.isnan(val[0]):\\n print(\\\"sim_lambda overflow\\\")\\n tf.assign(self.sim_lambda[k], [self.sim_lambda_zero], validate_shape=False).eval()\\n returnText = \\\"sim_lambda overflow\\\"\\n if val[0] <= 0.0:\\n tf.assign(self.sim_lambda[k], [self.delta], validate_shape=False).eval()\\n elif val[0] >= 1.0:\\n tf.assign(self.sim_lambda[k], [self.one - self.delta], validate_shape=False).eval()\\n\\n return returnText\",\n \"def factors(self, X):\\r\\n return (lambda fd: [X] if not fd else fd + self.factors(X // fd[0])) (self.firstdiv(X))\",\n \"def discount_factors(r,n,m):\\n return [1/((1+r/m)**i) for i in cashflow_times(n,m)]\",\n \"def original_factors(self):\\n self.assert_sampled()\\n # the original factors is the same for all samples set\\n return self._original_factors\",\n \"def test_two_qubit_weyl_decomposition_abc(self, smallest=1e-18, factor=9.8, steps=11):\\n for aaa in (\\n [smallest * factor**i for i in range(steps)]\\n + [np.pi / 4 - smallest * factor**i for i in range(steps)]\\n + [np.pi / 8, 0.113 * np.pi, 0.1972 * np.pi]\\n ):\\n for bbb in np.linspace(0, aaa, 4):\\n for ccc in np.linspace(-bbb, bbb, 4):\\n for k1l, k1r, k2l, k2r in K1K2S:\\n k1 = np.kron(k1l.data, k1r.data)\\n k2 = np.kron(k2l.data, k2r.data)\\n a = Ud(aaa, bbb, ccc)\\n self.check_two_qubit_weyl_decomposition(k1 @ a @ k2)\",\n \"def initiate_factors(Y, latent_dim):\\n\\tt = Y.shape[0]\\n\\tpca = PCA(n_components=latent_dim)\\n\\tcomponents = pca.fit_transform(Y)\\n\\tmu_0 = np.repeat(0, latent_dim) # prior mean 0 for regression coefficients\\n\\tSigma_0 = np.diag(np.repeat(1, latent_dim)) # prior variance 1\\n\\ta_0 = 1 # Inverse-Gamma(1, 1) is fairly diffused\\n\\tb_0 = 1\\n\\tloading_matrix, Y_variance = blr_mv(Y, components, mu_0, Sigma_0, a_0, b_0)\\n\\tX = np.linspace(0.1, t * 0.1, t).reshape((t, 1)) # create initial GP covariance matrices\\n\\tcov1 = sample_covariance_matern(X, 1.0, 1.0) # length scale 1.0 corresponds to 10 time points\\n\\tcov2 = sample_covariance_matern(X, 1.0, 1.0) # variance scale set to 1.0 as well\\n\\tS1, S2, S3, S4 = build_covariance_blocks([cov1, cov2], loading_matrix, Y_variance)\\n\\tF = sample_conditional_F(Y, S1, S2, S3, S4)\\n\\treturn F\",\n \"def compute_error(data, user_features, item_features, nz):\\n sum_err = 0\\n for d, n in nz:\\n err = data[d,n] - np.dot(item_features[d,:],user_features[:,n])\\n sum_err += err**2\\n rmse = 0.5*sum_err/len(nz)\\n return rmse\",\n \"def factor(n: int) -> List[Tuple[int, int]]:\\n if n <= 1:\\n raise ValueError\\n\\n factors = list()\\n\\n ml = 0\\n p = 2\\n while n % p == 0:\\n n //= p\\n ml += 1\\n if ml > 0:\\n factors.append((p, ml,))\\n\\n p = 3\\n while p ** 2 <= n:\\n ml = 0\\n while n % p == 0:\\n n //= p\\n ml += 1\\n if ml > 0:\\n factors.append((p, ml,))\\n p += 2\\n\\n if n > 2:\\n factors.append((n, 1,))\\n\\n return factors\",\n \"def _m_to_F_on_basis(self, la):\\n Sym = self._kBoundedRing.ambient()\\n kB = Sym.kBoundedSubspace(self.k, t=1)\\n h = kB.khomogeneous()\\n ks = kB.kschur()\\n return sum( h(ks(x)).coefficient(la) * self(x) for x in PartitionsGreatestLE(sum(la), self.k))\",\n \"def nonnegative_tensor_factorization(X, r, method='anls_bpp',\\n tol=1e-4, stop_criterion=1,\\n min_iter=20, max_iter=200, max_time=1e6,\\n init=None, orderWays=None):\\n\\n nWay = len(X.shape)\\n\\n if orderWays is None:\\n orderWays = np.arange(nWay)\\n\\n # set initial values\\n if init is not None:\\n F_cell = init\\n else:\\n Finit = [np.random.rand(X.shape[i], r) for i in range(nWay)]\\n F_cell = Finit\\n\\n grad = getGradient(X, F_cell, nWay, r)\\n\\n nr_X = X.norm()\\n nr_grad_all = np.sqrt(np.sum(np.linalg.norm(grad[i], 'fro') ** 2\\n for i in range(nWay)))\\n\\n if method == \\\"anls_bpp\\\":\\n method = anls_bpp()\\n elif method == \\\"anls_asgroup\\\":\\n method = anls_asgroup()\\n else:\\n raise Exception(\\\"Unknown method\\\")\\n\\n # Execute initializer\\n F_cell, FF_init = method.initializer(X, F_cell, nWay, orderWays)\\n\\n tStart = time.time()\\n\\n if stop_criterion == 2:\\n F_kten = ktensor(F_cell)\\n rel_Error = getRelError(X, ktensor(F_cell), nWay, nr_X)\\n\\n if stop_criterion == 1:\\n pGrad = getProjGradient(X, F_cell, nWay, r)\\n SC_PGRAD = getStopCriterion(pGrad, nWay, nr_grad_all)\\n\\n # main iterations\\n for iteration in range(max_iter):\\n cntu = True\\n\\n F_cell, FF_init = method.iterSolver(X, F_cell,\\n FF_init, nWay, r, orderWays)\\n F_kten = ktensor(F_cell)\\n\\n if iteration >= min_iter:\\n\\n if time.time() - tStart > max_time:\\n cntu = False\\n\\n else:\\n\\n if stop_criterion == 1:\\n pGrad = getProjGradient(X, F_cell, nWay, r)\\n SC_PGRAD = getStopCriterion(pGrad, nWay, nr_grad_all)\\n if SC_PGRAD < tol:\\n cntu = False\\n\\n elif stop_criterion == 2:\\n prev_rel_Error = rel_Error\\n rel_Error = getRelError(X, F_kten, nWay, nr_X)\\n SC_DIFF = np.abs(prev_rel_Error - rel_Error)\\n if SC_DIFF < tol:\\n cntu = False\\n else:\\n rel_Error = getRelError(X, F_kten, nWay, nr_X)\\n if rel_Error < 1:\\n cntu = False\\n\\n if not cntu:\\n break\\n\\n return F_kten\",\n \"def return_factors(self):\\n if self.global_rank==0:print([i.shape for i in self.factors])\\n return self.factors\",\n \"def stretch_factor(self):\\n p = self._pants_decomposition\\n\\n # pick a curve to iterate\\n c = PantsLamination.random(p)\\n # print(c)\\n\\n cc = (self**100) * c\\n # print(self**100)\\n # print(cc)\\n return float(sum(abs(x) for x in (self*cc).to_vector())) / \\\\\\n sum(abs(x) for x in cc.to_vector())\",\n \"def trifactor(a, d, c):\\n u, l = zeros_like(d), zeros_like(a)\\n u[0] = d[0]\\n for k in range(len(a)):\\n l[k] = a[k]/u[k]\\n u[k+1] = d[k+1] - l[k]*c[k]\\n return l, u\",\n \"def compute_pmf(X_inp, rank, c1, c2):\\n\\n X_arr = []\\n u_arr = []\\n v_arr = []\\n d_arr = []\\n\\n X = deepcopy(X_inp)\\n\\n v_init = np.ones((np.shape(X)[1],1))\\n\\n for i in range(rank):\\n X_arr.append(X)\\n (d,u,v) = compute_factor(X, v_init, c1, c2)\\n\\n\\n assert abs(npla.norm(u) - 1 ) < 1e-3\\n assert abs(npla.norm(v) - 1 ) < 1e-3\\n\\n d_arr.append(d)\\n u_arr.append(u)\\n v_arr.append(v)\\n\\n toSub = np.outer(u,v)\\n assert np.shape(toSub) == np.shape(X)\\n X -= d * toSub\\n\\n return (X_arr, u_arr, v_arr, d_arr)\",\n \"def problem3():\\n def _prime_factorization(n):\\n \\\"\\\"\\\"Returns the list of prime factors of a number n\\\"\\\"\\\"\\n factors = []\\n f = 2\\n # Use trial division to add factors\\n while f**2 <= n:\\n while (n % f) == 0:\\n factors.append(f)\\n n //= f\\n f += 1\\n\\n if n > 1:\\n factors.append(n)\\n\\n return factors\\n\\n return max(_prime_factorization(600851475143))\",\n \"def __det3x3__(a):\\r\\n # val = +a[0,0] * ( a[1,1] * a[2,2] - a[2,1] * a[1,2] )\\r\\n # val += -a[0,1] * ( a[1,0] * a[2,2] - a[2,0] * a[1,2] )\\r\\n # val += +a[0,2] * ( a[1,0] * a[2,1] - a[2,0] * a[1,1] )\\r\\n val = +a[0] * (a[4] * a[8] - a[7] * a[5])\\r\\n val += -a[1] * (a[3] * a[8] - a[6] * a[5])\\r\\n val += +a[2] * (a[3] * a[7] - a[6] * a[4])\\r\\n return val\",\n \"def addFactors(self, flist, copy=True, isLog=False):\\n row = np.zeros(2*len(flist),dtype=int)-1; col=row.copy(); data=np.zeros(2*len(flist));\\n for k,f in enumerate(flist):\\n if not isLog: \\n if np.any(f.t<=0): f = f+1e-10; # TODO: log nonzero tol\\n f = f.log()\\n if f.nvar == 1:\\n Xi = f.vars[0]\\n self.h[Xi] += .5*(f[1]-f[0])\\n self.c += .5*(f[1]+f[0])\\n else:\\n Xi,Xj = f.vars[0],f.vars[1]\\n row[2*k],col[2*k],data[2*k] = int(Xi),int(Xj), .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n row[2*k+1],col[2*k+1],data[2*k+1] = col[2*k],row[2*k],data[2*k] \\n #L[Xi,Xj] += .25*(f[1,1]+f[0,0]-f[0,1]-f[1,0])\\n self.h[Xi] += .5*(f[1,0]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.h[Xj] += .5*(f[0,1]-f[0,0])+data[2*k] #L[Xi,Xj]\\n self.c += .25*(f[1,1]+f[1,0]+f[0,1]+f[0,0])\\n self.L += csr((data[row>=0],(row[row>=0],col[row>=0])),shape=(self.nvar,self.nvar));\",\n \"def _fit(self):\\n I_mat = []\\n for i in range(self._num_bases):\\n temp = []\\n for j in range(self._num_bases):\\n v = 1.0 if i == j else 0.0\\n temp.append(v)\\n I_mat.append(temp)\\n I_mat = Mat(I_mat)\\n return (self._input.t() * self._input + self._lambda * I_mat).inv() * self._input.t() * self._label\",\n \"def solveForModeB1(X, M, n, maxInner, epsilon, tol,sita,Y1, lambta2):\\n # Pi(n) = [A(N) kr A(N-1) kr ... A(n+1) kr A(n-1) kr .. A(1)]^T\\n Pi = tensorTools.calculatePi(X, M, n)\\n #print 'Pi size', Pi.shape\\n #print 'pi='+str(Pi)\\n #print(M.U[n])\\n for iter in range(maxInner):\\n # Phi = (X(n) elem-div (B Pi)) Pi^T\\n #print X.vals.shape,X.shape\\n #print X.vals.flatten().shape\\n Phi = tensorTools.calculatePhi(X, M.U[n], Pi, n, epsilon=epsilon)\\n #print('phi'+str(Phi))\\n #print(Phi)\\n # check for convergence that min(B(n), E - Phi(n)) = 0 [or close]\\n kktModeViolation = np.max(np.abs(np.minimum(M.U[n], 1-Phi).flatten()))\\n if (kktModeViolation < tol):\\n break\\n\\n B=M.U[n]\\n #print B.shape\\n colNorm = np.apply_along_axis(np.linalg.norm, 0, B, 1)\\n zeroNorm = np.where(colNorm == 0)[0]\\n colNorm[zeroNorm] = 1\\n B = B / colNorm[np.newaxis, :]\\n tm=np.hstack((np.ones((B.shape[0],1)),B))\\n Y1=Y1.reshape((Y1.shape[0],1))\\n\\n derive=-1.0*lambta2/B.shape[0]*np.dot((Y1-np.dot(tm,sita)),sita.T)\\n #print derive.shape\\n #print np.multiply(M.U[n],derive[:,1:]).shape\\n #print np.multiply(M.U[n],Phi).shape\\n M.U[n] = np.array(np.multiply(M.U[n],Phi))-np.array((np.multiply(M.U[n],derive[:,1:])))\\n\\n #print 'after'\\n #print M.U[n][0]\\n #print(\\\" Mode={0}, Inner Iter={1}, KKT violation={2}\\\".format(n, iter, kktModeViolation))\\n return M, Phi, iter, kktModeViolation\",\n \"def rfactor(h,rmask):\\n\\n Lp, Mp = h.shape\\n L=Lp-1\\n M=Mp-1\\n\\n # Land/Sea mask on U-points.\\n umask = np.zeros((L,Mp))\\n for j in range(Mp):\\n for i in range(1,Lp):\\n umask[i-1,j] = rmask[i,j] * rmask[i-1,j]\\n\\n # Land/Sea mask on V-points.\\n vmask = np.zeros((Lp,M))\\n for j in range(1,Mp):\\n for i in range(Lp):\\n vmask[i,j-1] = rmask[i,j] * rmask[i,j-1]\\n\\n #-------------------------------------------------------------------\\n # Compute R-factor.\\n #-------------------------------------------------------------------\\n\\n hx = np.zeros((L,Mp))\\n hy = np.zeros((Lp,M))\\n\\n hx = abs(h[1:,:] - h[:-1,:]) / (h[1:,:] + h[:-1,:])\\n hy = abs(h[:,1:] - h[:,:-1]) / (h[:,1:] + h[:,:-1])\\n\\n hx = hx * umask\\n hy = hy * vmask\\n\\n r = np.zeros((L,M))\\n\\n r = np.maximum(np.maximum(hx[:,:-1],hx[:,1:]), np.maximum(hy[:-1,:],hy[1:,:]))\\n\\n rmin = r.min()\\n rmax = r.max()\\n ravg = r.mean()\\n rmed = np.median(r)\\n\\n print ' '\\n print 'Minimum r-value = ', rmin\\n print 'Maximum r-value = ', rmax\\n print 'Mean r-value = ', ravg\\n print 'Median r-value = ', rmed\\n\\n return r\",\n \"def factor_naive(n):\\n factors = []\\n\\n for factor in range(2, n // 2):\\n q, r = divmod(n, factor)\\n power = 0\\n while r == 0:\\n power += 1\\n n = q\\n q, r = divmod(q, factor)\\n if power != 0:\\n factors.append((factor, power))\\n\\n if factors == []:\\n factors = [(n, 1)]\\n\\n return factors\",\n \"def get_factors(val):\\n N = np.sqrt(val)\\n N = np.floor(N)\\n M = val/N\\n\\n while (val % N != 0):\\n N = N-1\\n M = val/N\\n\\n return int(M), int(N)\",\n \"def blueschist_felsic():\\n\\n rho = 2970.\\n\\n C = np.zeros((6,6), dtype=float)\\n C[0,0] = 149.85; C[0,1] = 38.7; C[0,2] = 32.59; C[0,3] = -0.15; C[0,4] = -1.; C[0,5] = -0.19\\n C[1,0] = C[0,1]; C[1,1] = 163.55; C[1,2] = 30.03; C[1,3] = 1.05; C[1,4] = -1.81; C[1,5] = -1.78\\n C[2,0] = C[0,2]; C[2,1] = C[1,2]; C[2,2] = 121.62; C[2,3] = 0.22; C[2,4] = -0.95; C[2,5] = -0.13\\n C[3,0] = C[0,3]; C[3,1] = C[1,3]; C[3,2] = C[2,3]; C[3,3] = 48.03; C[3,4] = -0.63; C[3,5] = -1.14\\n C[4,0] = C[0,4]; C[4,1] = C[1,4]; C[4,2] = C[2,4]; C[4,3] = C[3,4]; C[4,4] = 48.62; C[4,5] = -0.01\\n C[5,0] = C[0,5]; C[5,1] = C[1,5]; C[5,2] = C[2,5]; C[5,3] = C[3,5]; C[5,4] = C[4,5]; C[5,5] = 58.42\\n\\n return C, rho\",\n \"def als(matrix, n_factors=8,n_iterations=15, lambda_=10):\\r\\n\\tm, n = matrix.shape\\r\\n\\tQ = matrix\\r\\n\\tW = Q > 0.5\\r\\n\\tW = W.astype(int)\\r\\n\\tprint('X and Y randomly initialzied.')\\r\\n\\tX = 5 * np.random.rand(m, n_factors) \\r\\n\\tY = 5 * np.random.rand(n_factors, n)\\r\\n\\tfor ii in range(n_iterations):\\r\\n\\t\\tfor u, Wu in enumerate(W):\\r\\n\\t\\t\\tX[u] = np.linalg.solve(np.dot(Y, np.dot(np.diag(Wu), Y.T)) + lambda_ * np.eye(n_factors),\\r\\n\\t np.dot(Y, np.dot(np.diag(Wu), Q[u].T))).T\\r\\n\\t\\tfor i, Wi in enumerate(W.T):\\r\\n\\t\\t\\tY[:,i] = np.linalg.solve(np.dot(X.T, np.dot(np.diag(Wi), X)) + lambda_ * np.eye(n_factors),\\r\\n\\t np.dot(X.T, np.dot(np.diag(Wi), Q[:, i])))\\r\\n\\t\\tprint('{}th iteration is completed of {}'.format(ii + 1,n_iterations))\\r\\n\\tprediction = np.dot(X,Y)\\r\\n\\tprint('Done.')\\r\\n\\treturn prediction, X, Y\",\n \"def rf_prod(prime_factors: [int, ]):\\n return 1 if not prime_factors else reduce(mul, prime_factors, 1)\",\n \"def reciprocal_lattice_vectors(a):\\n b = np.zeros(shape=(3,3))\\n b[:,0] = 2 * np.pi * np.cross(a[:,1], a[:,2]) / triple_product(a[:,0], a[:,1], a[:,2])\\n b[:,1] = 2 * np.pi * np.cross(a[:,2], a[:,0]) / triple_product(a[:,1], a[:,2], a[:,0])\\n b[:,2] = 2 * np.pi * np.cross(a[:,0], a[:,1]) / triple_product(a[:,2], a[:,0], a[:,1])\\n return b\",\n \"def __truediv__(self, factor):\\n if type(factor) == Vector:\\n raise NotImplementedError\\n else:\\n return Vector([c / factor for c in self.components])\",\n \"def _factors(n):\\n gen = ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)\\n return set(sum(gen, []))\",\n \"def csrbf(r):\\n return num.power((num.maximum(0, 1-r)), 3)*(3*r+1)\",\n \"def auxminf1(x):\\n \\n# Sum over data points\\n f = 0.0\\n for m_ind in range(cfg.ntrain):\\n f += auxmin_f1_part_i(x,m_ind) \\n \\n return f\",\n \"def expand_factors(factor_components, factor_data):\\n logger.debug('Transforming input from %d x %d to full %d-dimensional feature space',\\n factor_data.shape[0], factor_data.shape[1], factor_components.shape[1])\\n return factor_data.dot(factor_components)\",\n \"def state_norm_opt(state):\\n fact_arr = np.array([factorial(x) for x in range(len(state))])\\n tf2 = np.tensordot(fact_arr, fact_arr, axes=0)\\n tf4 = np.tensordot(tf2, tf2, axes=0)\\n st_abs_quad = np.power(np.abs(state), 2)\\n mult = np.multiply(st_abs_quad, tf4)\\n return sqrt(np.sum(mult))\",\n \"def get_factors(number):\\n\\n factors = [1, number]\\n\\n for i in range(2, int(math.sqrt(number))):\\n if number % i == 0:\\n factors.extend([i, number / i])\\n\\n return(factors)\",\n \"def fit(self, y):\\n if isinstance(y, np.ndarray) and y.ndim == 2:\\n y = [y]\\n y_all = np.concatenate(y)\\n self.mean_ = y_all.mean(axis=0, keepdims=True)\\n y = [yi - self.mean_ for yi in y]\\n n = y[0].shape[1]\\n T = [yi.shape[0] for yi in y]\\n model = FA(self.n_factors, svd_method='lapack')\\n model.fit(y_all)\\n\\n self.R_ = np.diag(model.noise_variance_)\\n self.C_ = model.components_.T\\n self.d_ = np.zeros(n)\\n self.tau_ = self.tau_init + self.rng.rand(self.n_factors)\\n # Allocated and reuse these\\n C = self.C_\\n R = self.R_\\n big_K = {Ti: calc_big_K(Ti, self.n_factors, self.tau_, self.var_n) for Ti in set(T)}\\n y_cov = {Ti: block_dot_B(block_dot_A(C, big_K[Ti], Ti), C.T, Ti) + make_block_diag(R, Ti)\\n for Ti in set(T)}\\n big_d = {Ti: np.tile(self.d_, Ti) for Ti in set(T)}\\n big_y = [yi.ravel() for yi in y]\\n ll_pre = log_likelihood(big_d, y_cov, big_y, T)\\n if self.verbose:\\n print(\\\"FA log likelihood:\\\", ll_pre)\\n\\n converged = False\\n for ii in range(self.max_iter):\\n ll = self._em_iter(y, big_K)\\n if abs(ll - ll_pre) / np.amax([abs(ll), abs(ll_pre), 1.]) <= self.tol:\\n converged = True\\n break\\n ll_pre = ll\\n if not converged:\\n warnings.warn(\\\"EM max_iter reached.\\\", ConvergenceWarning)\\n return self\",\n \"def factor_list(f):\\n coeff, factors = dmp_factor_list(f.rep, f.lev, f.dom)\\n return coeff, [ (f.per(g), k) for g, k in factors ]\",\n \"def test_l1norm () :\\n n = 10\\n rfs = RewardFnSpace(list(range(n)))\\n for i in range(10): \\n b = rfs.bs[i]\\n rfs.lp += b == 0\\n rfs.lp.solve()\\n rfs._setCoeffs()\\n coeffs = np.array(rfs.coeffs)\\n assert(np.linalg.norm(coeffs - np.ones(n)) < 1e-4)\",\n \"def __solve_alternative_linear_problem(self, user):\\n result = [0] * self.layout_slots\\n de_rand_approach = \\\"greedy\\\"\\n bins_per_category = []\\n bins_cardinality = []\\n for _ in range(len(self.categories)):\\n bins_per_category.append([])\\n bins_cardinality.append([])\\n\\n for cat in range(len(self.categories)):\\n for _ in range(len(self.news_row_pivots) + 1):\\n bins_per_category[cat].append([])\\n bins_cardinality[cat].append([])\\n for _ in range(len(self.news_column_pivots) + 1):\\n bins_per_category[cat][-1].append([])\\n bins_cardinality[cat][-1].append(0)\\n\\n for news in self.news_pool:\\n category_index = self.categories.index(news.news_category)\\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\\n bins_per_category[category_index][x][y].append(news)\\n bins_cardinality[category_index][x][y] += 1\\n\\n index = 0\\n bin_samples = []\\n for cat in range(len(self.categories)):\\n for x in range(len(self.news_row_pivots) + 1):\\n for y in range(len(self.news_column_pivots) + 1):\\n if (y == 0) and (x != 0):\\n continue\\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\\n index += 1\\n try:\\n selected_news = np.random.choice(bins_per_category[cat][x][y])\\n self.sample_quality(selected_news, user, interest_decay=True)\\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\\n except ValueError:\\n bin_samples += [0] * self.layout_slots\\n\\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\\n\\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\\n slots_assegnation_probabilities = []\\n slot_counter = 0\\n tmp_slot_probabilities = []\\n while slot_counter < self.layout_slots:\\n i = slot_counter\\n while i < len(linear_problem.x):\\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\\n i += self.layout_slots\\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\\n tmp_slot_probabilities.clear()\\n slot_counter += 1\\n\\n slot_promenances = self.real_slot_promenances.copy()\\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\\n slots_nr = [s for s in range(0, self.layout_slots)]\\n for i in range(self.layout_slots):\\n if de_rand_approach == \\\"ordered\\\":\\n k = i\\n elif (de_rand_approach == \\\"greedy\\\") or (de_rand_approach == \\\"greedy_max\\\"):\\n k = np.argmax(slot_promenances)\\n slot_promenances[k] = 0\\n elif de_rand_approach == \\\"randomized\\\":\\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\\n slot_promenances[k] = 0\\n else:\\n raise RuntimeError(\\\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \\\"\\n \\\"'randomized' or 'greedy_max'.\\\")\\n\\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\\n if de_rand_approach == \\\"greedy_max\\\":\\n assigning_bin_index = np.argmax(target_slot_probabilities)\\n cat_index = int(assigning_bin_index / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin_index)][0]\\n y = self.bins_for_position[int(assigning_bin_index)][1]\\n\\n else:\\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\\n cat_index = int(assigning_bin / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin)][0]\\n y = self.bins_for_position[int(assigning_bin)][1]\\n\\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\\n\\n return result\",\n \"def kullback_leibler_dirichlet(m_true, alpha):\\n\\n alpha = alpha * (1 - m_true) + m_true\\n M = int(m_true.shape[1])\\n beta = tf.constant(np.ones((1, M)), dtype=tf.float32)\\n alpha0 = tf.reduce_sum(input_tensor=alpha, axis=1, keepdims=True)\\n \\n kl = tf.reduce_sum(input_tensor=(alpha - beta) * (tf.math.digamma(alpha) - tf.math.digamma(alpha0)), axis=1, keepdims=True) + \\\\\\n tf.math.lgamma(alpha0) - tf.reduce_sum(input_tensor=tf.math.lgamma(alpha), axis=1, keepdims=True) + \\\\\\n tf.reduce_sum(input_tensor=tf.math.lgamma(beta), axis=1, keepdims=True) - tf.math.lgamma(tf.reduce_sum(input_tensor=beta, axis=1, keepdims=True))\\n kl = tf.reduce_mean(input_tensor=kl)\\n return kl\",\n \"def exclusive_lasso5(X, n_clusters, gamma=0.5):\\n MAX_ITERS = 100\\n n_dims, n_samples = X.shape\\n\\n # Initialize indicaotr matrix F\\n F = np.zeros((n_samples, n_clusters), dtype=np.int8)\\n for i in xrange(n_samples):\\n F[i, randint(0, n_clusters-1)] = 1\\n\\n conv = False\\n iteration = 0\\n results = np.zeros(n_clusters, dtype=np.float64)\\n\\n while iteration < MAX_ITERS and not conv:\\n conv = True\\n # Calculate H = XF(F^TF)^-1\\n H = X.dot(sp.linalg.pinv(F.T))\\n\\n base_sum = ((X-H.dot(F.T))**2).sum(axis=0)\\n F_counts = F.sum(axis=0)\\n\\n # Caculate F\\n # For each row (sample)\\n for i in xrange(n_samples):\\n # Get current indicator\\n curr_ind = F[i].nonzero()[0][0]\\n F_counts[curr_ind] = F_counts[curr_ind] - 1\\n\\n # We want to find the indicator column that minimizes\\n # X-HF^T + gamma * Tr(F^T11^TF)\\n for j in xrange(n_clusters):\\n F_counts[j] = F_counts[j] + 1\\n tr = (F_counts**2).sum()\\n res = ((X[:, i]-H[:, j])**2).sum() - base_sum[i] + gamma * tr\\n results[j] = res\\n F_counts[j] = F_counts[j] - 1\\n new_ind = results.argmin()\\n\\n F_counts[new_ind] = F_counts[new_ind] + 1\\n\\n if (curr_ind != new_ind):\\n conv = False\\n F[i, curr_ind] = 0\\n F[i, new_ind] = 1\\n iteration = iteration + 1\\n print iteration\\n return map(lambda x: x.index(1), F.tolist())\",\n \"def V_fit(x, a, b, c, d, e, f):\\n x1 = x[0] # I\\n x2 = x[1] # dT\\n m = (a * x1 ** 2 + b * x1 + c)\\n b = (d * x1 ** 2 + e * x1 + f)\\n return m * x2 + b\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6412927","0.6364732","0.6273934","0.59649765","0.58943266","0.5739722","0.56869096","0.5642237","0.5588103","0.55404395","0.55167574","0.54780066","0.54257447","0.5419568","0.5391013","0.53886884","0.53792053","0.53650635","0.53555024","0.53386456","0.53257406","0.5323429","0.5294586","0.5292349","0.5272046","0.527183","0.52611107","0.5260819","0.52391315","0.52267504","0.5217867","0.5203884","0.51968634","0.5194007","0.5184397","0.5175547","0.5174155","0.5167332","0.51647","0.5160241","0.51588875","0.51511145","0.51492983","0.5143407","0.5143237","0.51316553","0.51206505","0.51188797","0.51183593","0.5116824","0.51140136","0.5097241","0.5094218","0.5091829","0.5089147","0.50843155","0.50814706","0.5080961","0.5074891","0.5069342","0.5068288","0.5068123","0.506794","0.50628144","0.5047817","0.5045847","0.503681","0.5036594","0.5033891","0.5032531","0.5024618","0.502404","0.5022142","0.5020027","0.50142956","0.50089747","0.49918312","0.49900314","0.49880186","0.49842826","0.49814063","0.4977382","0.49751285","0.4968745","0.49657407","0.49519876","0.494884","0.4948572","0.49375013","0.49347597","0.49285334","0.49267295","0.49255168","0.49186885","0.4915023","0.49099287","0.48995343","0.4898187","0.48966107","0.489111"],"string":"[\n \"0.6412927\",\n \"0.6364732\",\n \"0.6273934\",\n \"0.59649765\",\n \"0.58943266\",\n \"0.5739722\",\n \"0.56869096\",\n \"0.5642237\",\n \"0.5588103\",\n \"0.55404395\",\n \"0.55167574\",\n \"0.54780066\",\n \"0.54257447\",\n \"0.5419568\",\n \"0.5391013\",\n \"0.53886884\",\n \"0.53792053\",\n \"0.53650635\",\n \"0.53555024\",\n \"0.53386456\",\n \"0.53257406\",\n \"0.5323429\",\n \"0.5294586\",\n \"0.5292349\",\n \"0.5272046\",\n \"0.527183\",\n \"0.52611107\",\n \"0.5260819\",\n \"0.52391315\",\n \"0.52267504\",\n \"0.5217867\",\n \"0.5203884\",\n \"0.51968634\",\n \"0.5194007\",\n \"0.5184397\",\n \"0.5175547\",\n \"0.5174155\",\n \"0.5167332\",\n \"0.51647\",\n \"0.5160241\",\n \"0.51588875\",\n \"0.51511145\",\n \"0.51492983\",\n \"0.5143407\",\n \"0.5143237\",\n \"0.51316553\",\n \"0.51206505\",\n \"0.51188797\",\n \"0.51183593\",\n \"0.5116824\",\n \"0.51140136\",\n \"0.5097241\",\n \"0.5094218\",\n \"0.5091829\",\n \"0.5089147\",\n \"0.50843155\",\n \"0.50814706\",\n \"0.5080961\",\n \"0.5074891\",\n \"0.5069342\",\n \"0.5068288\",\n \"0.5068123\",\n \"0.506794\",\n \"0.50628144\",\n \"0.5047817\",\n \"0.5045847\",\n \"0.503681\",\n \"0.5036594\",\n \"0.5033891\",\n \"0.5032531\",\n \"0.5024618\",\n \"0.502404\",\n \"0.5022142\",\n \"0.5020027\",\n \"0.50142956\",\n \"0.50089747\",\n \"0.49918312\",\n \"0.49900314\",\n \"0.49880186\",\n \"0.49842826\",\n \"0.49814063\",\n \"0.4977382\",\n \"0.49751285\",\n \"0.4968745\",\n \"0.49657407\",\n \"0.49519876\",\n \"0.494884\",\n \"0.4948572\",\n \"0.49375013\",\n \"0.49347597\",\n \"0.49285334\",\n \"0.49267295\",\n \"0.49255168\",\n \"0.49186885\",\n \"0.4915023\",\n \"0.49099287\",\n \"0.48995343\",\n \"0.4898187\",\n \"0.48966107\",\n \"0.489111\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5874729"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":4997,"cells":{"query":{"kind":"string","value":"Get authorization header for GoDaddy Developer API."},"document":{"kind":"string","value":"def _get_headers() -> dict:\n api_key = API_KEY_CRED_LOADER.load_credentials()\n api_secret = API_SECRET_CRED_LOADER.load_credentials()\n return {\"Authorization\": \"sso-key {}:{}\".format(api_key, api_secret)}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def api_client_authz_header():\n return assemble_authorization_header(API_TOKEN)","def api_client_authz_header():\n return assemble_authorization_header(API_TOKEN)","def get_authorization_header(self):\n return {\"Authorization\": \"Bearer {}\".format(self.get_jwt())}","def get_authorization_header(client, user):\n # obtain authorization token\n response = client.post(\n reverse('token-obtain'),\n data={'username': user.username, 'password': user.raw_password},\n content_type='application/json'\n )\n token = response.json()['access']\n return {'HTTP_AUTHORIZATION': f'Bearer {token}'}","def get_api_header(token):\n return {\n 'Authorization': 'Token ' + str(token)}","def get_auth_header(self):\n if not self.verify():\n return None\n\n auth_val = self.encode_auth_header_val()\n if not auth_val:\n return None\n\n return {'Authorization': auth_val.replace('\\n', '')}","def build_header(self):\n authstring = \"Bearer \" + self.auth_token\n header = {\n \"Authorization\": authstring,\n \"Content-Type\": \"application/json\",\n \"User-Agent\": self.user_agent,\n \"Accept-Encoding\": \"gzip\"\n }\n return header","def _get_authorization_header(self):\n return f\"token {self._context.get_github_token()}\"","def get_token_auth_header():\n auth = request.headers.get(\"Authorization\", None)\n if not auth:\n return \"authorization_header_missing\"\n\n parts = auth.split()\n\n if parts[0].lower() != \"bearer\":\n return \"invalid_header\"\n elif len(parts) == 1:\n return \"invalid_header\"\n elif len(parts) > 2:\n return \"invalid_header\"\n\n token = parts[1]\n return token","def create_auth_header(api_token):\n return {'Authorization': f'token {api_token}'}","def getBasicAuthorization(self):\n header = self.request.getHeader(\"Authorization\")\n if header:\n try:\n if header.lower().startswith(\"basic \"):\n authstr = base64.b64decode(header[6:]).split(\":\")\n if len(authstr) == 1:\n return None\n return authstr[0], \":\".join(authstr[1:])\n except:\n return None\n return None","def get_auth(info) -> Tuple[Optional[str], Optional[str]]:\n auth = info.context[\"request\"].headers.get(\"Authorization\")\n if not auth:\n return None, None\n return auth.replace(\"Bearer \", \"\"), None","def authentication_request():\n # Get the access token from the header\n auth_header = request.headers.get('Authorization')\n if auth_header:\n try:\n access_token = auth_header.split(' ')[1]\n except IndexError:\n return {\"message\": \"Token is malformed\"}, status.HTTP_401_UNAUTHORIZED\n else:\n access_token = ''\n\n return access_token","def auth_header(self):\n return self._auth_header","def extract_bearer_token(request):\n return request.headers['Authorization'].split(\" \")[-1].strip()","def get_token_auth_header():\n # Get authorization form request header\n auth = request.headers.get('Authorization', None)\n # Check if authorization header exists\n if not auth:\n raise AuthError({\n 'code': 'authorization_header_missing',\n 'description': 'Authorization header is MISSING!'\n }, abort(401))\n # If bearer token, then first part of string = 'bearer'\n parts = auth.split()\n if parts[0].lower() != 'bearer':\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must start with \"Bearer\"'\n }, abort(401))\n # Authorization header string length must be 2\n elif len(parts) != 2:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must be a BEARER token'\n }, abort(401))\n\n token = parts[1]\n return token","def get_authorization(self):\n auth = get_authorization_header()\n\n if not auth:\n return None\n\n auth_type, auth_info = auth\n\n if auth_type != b'basic':\n return None\n\n try:\n username, password = base64.b64decode(auth_info).split(b':', 1)\n except Exception:\n return None\n\n return Authorization(\"basic\", username=bytes_to_wsgi(username), password=bytes_to_wsgi(password))","def request_http_header( self ) -> dict:\n return {'content-type': 'application/json','Authorization':f'NLAuth nlauth_account={self._acct_number},nlauth_email={self._auth_email},nlauth_signature={self._acct_signature},nlauth_role=1090'}","def get_auth_header(self) -> Mapping[str, Any]:\n return {}","def get_token_auth_header():\n auth = request.headers.get(\"Authorization\", None)\n print(auth)\n\n if not auth:\n raise AuthError({\"code\": \"authorization_header_missing\",\n \"description\":\n \"Authorization header is expected\"}, 401)\n \n parts = auth.split()\n \n if parts[0].lower() != \"bearer\":\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must start with\"\n \" Bearer\"}, 401)\n elif len(parts) == 1:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\": \"Token not found\"}, 401)\n elif len(parts) > 2:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must be\"\n \" Bearer token\"}, 401)\n\n token = parts[1]\n return token","def auth_key(event):\n headers = event.get('header')\n if not headers:\n raise RestException(\"Headers are missing\", 400)\n auth = headers.get('Authorization')\n if not auth:\n raise RestException('Header Authorization is missing', 400)\n if not auth.lower().startswith('bearer '):\n raise RestException(\"Authorization missing Bearer keyword\", 400)\n auth = auth.replace('Bearer ', '')\n auth = auth.replace('bearer ', '')\n return auth.strip()","def get_token_auth_header():\n auth = request.headers.get('Authorization', None)\n if not auth:\n raise AuthError({\n 'code': 'authorization_header_missing',\n 'description': 'Authorization header is expected.'\n }, 401)\n elif auth.split()[0].lower() != 'bearer':\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must start with \"Bearer\".'\n }, 401)\n elif len(auth.split()) == 1:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must be include type and token.'\n }, 401)\n elif len(auth.split()) > 2:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must be Bearer token.'\n }, 401)\n else:\n token = auth.split()[1]\n return token","def __header_base64(self):\n header_base64 = base64.b64encode(f'{self.client_id}:{self.client_secret}'.encode('ascii'))\n header_base64 = str(header_base64).split(\"'\")[1]\n return {'Authorization': f'Basic {header_base64}'}","def _request_token(self):\n params = {\n 'grant_type': 'client_credentials',\n 'client_id': self.client_id,\n 'client_secret': self.client_secret\n }\n\n response = self._http_request(\n method='POST',\n headers={'Content-Type': 'application/x-www-form-urlencoded'},\n full_url=self.auth_url,\n data=params\n )\n access_token = response.get('access_token')\n auth_header = {'Authorization': f'Bearer {access_token}'}\n return auth_header","def get_auth_headers(key):\n return {\n 'Content-Type': 'Application/JSON',\n 'Authorization': key\n }","def get_authenticate_header(self):\n pass","def get_token_auth_header():\n auth = request.headers.get('Authorization', None)\n if not auth:\n raise AuthError({\n 'code': 'authorization_header_missing',\n 'description': 'Authorization header is expected.'\n }, 401)\n\n parts = auth.split()\n if parts[0].lower() != 'bearer':\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must start with \"Bearer\".'\n }, 401)\n\n elif len(parts) == 1:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Token not found.'\n }, 401)\n\n elif len(parts) > 2:\n raise AuthError({\n 'code': 'invalid_header',\n 'description': 'Authorization header must be bearer token.'\n }, 401)\n\n token = parts[1]\n return token","def _auth_headers(self):\n if self.token_str:\n return {'Authorization': 'Bearer {}'.format(self.token_str)}\n else:\n return {}","def get_token_auth_header():\n auth = request.headers.get('Authorization', None)\n if not auth:\n raise AuthError({'code': 'authorization_header_missing',\n 'description': 'Authorization header is expected'}, 401)\n\n parts = auth.split()\n\n if parts[0].lower() != 'bearer':\n raise AuthError({'code': 'invalid_header',\n 'description': 'Authorization header must start with Bearer'}, 401)\n\n if len(parts) < 2:\n raise AuthError({'code': 'invalid_header',\n 'description': 'Token not found after Bearer'}, 401)\n\n if len(parts) > 2:\n raise AuthError({'code': 'invalid_header',\n 'description': 'Authorization header is an invalid token structure'}, 401)\n\n return parts[1]","def get_token_auth_header():\n auth = request.headers.get(\"Authorization\", None)\n if not auth:\n raise AuthError({\"code\": \"authorization_header_missing\",\n \"description\":\n \"Authorization header is expected\"}, 401)\n\n parts = auth.split()\n\n if parts[0].lower() != \"bearer\":\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must start with\"\n \" Bearer\"}, 401)\n elif len(parts) == 1:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\": \"Token not found\"}, 401)\n elif len(parts) > 2:\n raise AuthError({\"code\": \"invalid_header\",\n \"description\":\n \"Authorization header must be\"\n \" Bearer token\"}, 401)\n\n token = parts[1]\n return token","def get_authenticate_header(self):\n return f'Basic realm=\"{self.www_authenticate_realm}\"'","async def authorization(request):\n # Decode tokens, load/check users and etc\n # ...\n # in the example we just ensure that the authorization header exists\n return request.headers.get(\"authorization\", \"\")","def asterisk_in_header():\n auth_token = get_auth_token()\n\n headers = '{\"Host\":\"$host\",\"User-Agent\":\"$user_agent\",\"Date\":\"DATE\",'\n headers += '\"Accept\": \"*/*\",\"Accept-Encoding\": \"gzip\",'\n headers += '\"X-Project-ID\": \"$project_id\",'\n headers += '\"X-Auth-Token\": \"$token\"}'\n headers = string.Template(headers)\n\n return headers.substitute(host=CFG.host, user_agent=CFG.user_agent,\n project_id=CFG.project_id, token=auth_token)","def auth_header_value(self):\n return f\"token {self.API_TOKEN}\"","def getHeaders():\n userid = rhev_settings.USERNAME\n passwd = rhev_settings.PASSWORD\n # base64.encodestring adds trailing \\n. \n auth = base64.encodestring(\"%s:%s\" % (userid, passwd)).rstrip(\"\\n\")\n headers = {\"Content-Type\": \"application/xml\",\n \"Accept\": \"application/xml\",\n \"Accept-Charset\": \"utf-8\",\n \"Authorization\" : (\"Basic %s\" % auth)}\n return headers","def build_header(token: str = None):\n return {\n \"Content-Type\": \"application/json\",\n \"X-Auth-Token\": token or get_project_token(),\n }","def _retrieve_token(request):\n auth_string = request.headers.get('Authorization')\n try:\n match = re.match(\"Bearer (.+)\", auth_string)\n except TypeError:\n match = None\n if match:\n return match.groups()[0]","def get_headers():\n return {'Authorization': f'token {settings.GITHUB_AUTH_TOKEN}'}","def authentication_header():\n with open(KEY_FILE, \"r\") as file:\n header = json.load(file)\n return header","def auth_headers(current_user_token: str) -> Dict[str, str]:\n return {\"Authorization\": f\"Bearer {current_user_token}\"}","def get_headers():\n if not headers:\n headers[\"Content-Type\"] = \"application/json\"\n headers[\"Accept\"] = \"application/json\"\n headers[\"User-Agent\"] = constants.USER_AGENT\n headers[\"Authorization\"] = get_token(constants.AUTH_URL, cfg[\"key\"])\n\n return headers\n\n return headers","def authorization(self):\n return {'auth-token': '{token}'.format(token=self.token)}","def authorization(self):\n return {'auth-token': '{token}'.format(token=self.token)}","def get_headers(self):\n headers = {\n \"Content-Type\": \"application/json\",\n \"Authorization\": \"Basic %s\" % self.rest_auth_key\n }\n return headers","def get_token() -> str:\n try:\n bearer, authorization = request.headers['Authorization'].split()\n if 'bearer' not in bearer.lower():\n raise Forbidden('Invalid token. Please login!')\n return authorization\n\n except Exception:\n raise Forbidden('Token is required. Please login!')","def bearer_auth():\n authorization = request.headers.get(\"Authorization\")\n if not (authorization and authorization.startswith(\"Bearer \")):\n response = app.make_response(\"\")\n response.headers[\"WWW-Authenticate\"] = \"Bearer\"\n response.status_code = 401\n return response\n slice_start = len(\"Bearer \")\n token = authorization[slice_start:]\n\n return jsonify(authenticated=True, token=token)","def authenticate_header(self, request):\n return '{0} realm=\"{1}\"'.format(settings.JWT_AUTH_HEADER_PREFIX,\n self.www_authenticate_realm)","def _headers(self):\n auth = AuthenticationProvider.currentAuth()\n\n return {\n 'Authorization': '%s %s' % (auth.tokenType, auth.accessToken),\n 'Content-Type': 'application/json'}","def oauth_headers(oauth):\n import base64\n encoded_credentials = base64.b64encode(('{0}:{1}'.format(oauth.client_id, oauth.client_secret)).encode('utf-8'))\n headers = {\n 'Authorization': 'Basic {0}'.format(encoded_credentials.decode('utf-8')),\n 'Content-Type': 'application/x-www-form-urlencoded'\n }\n return headers","def get_headers(self):\n return {\n 'Authorization': 'JWT {}'.format(self.token)\n }","def header_token(token):\n return {'Authorization': '{0} {1}'.format('JWT', token)}","def get_headers() -> dict:\n headers = {}\n token = GoogleAuthService.get_report_api_token()\n if token:\n headers['Authorization'] = 'Bearer {}'.format(token)\n return headers","def get_headers(self):\r\n return {\r\n 'authenticate': {\r\n 'username': self.username,\r\n 'apiKey': self.api_key,\r\n }\r\n }","def get_headers():\n headers = {\n \"Authorization\": \"Token {}\".format(get_token()),\n }\n\n return headers","def get_auth(context):\n\n headers = context['headers']\n auth_info = {\n \"type\": \"basic\",\n \"basic\": {\n \"user\": headers['api_key'],\n \"password\": \"X\"\n }\n }\n auth = Auth().get_auth(auth_info)\n\n return auth","def create_authorization_header(self, **kwargs):\n return {\"Authorization\": \"Bearer {}\".format(self.create_jwt(**kwargs))}","def basic_header(self):\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\n', '')\n return { \n #\"Authorization\" : \"Basic %s\" % self.auth, \n \"Content-type\": \"text/plain\" }","def generate_oauth_headers(access_token: str) -> dict:\n return {'Authorization': 'Bearer ' + access_token}","def getToken(request):\n try:\n token = request.META['HTTP_AUTHORIZATION'].split()[1]\n except:\n token = \"\"\n return token","def add_header(response):\n response.headers['Authorization'] = response\n return response","def get_token():\n token = getpass.getpass('Paste in your RDR API token and press Enter:')\n return {'Authorization': 'token ' + token}","def get_auth_headers(self,email,passwd):\n #获取认证后的http头\n\n postdata = urllib.urlencode({'Email':email,'Passwd':passwd,'service':'reader','source':self.ClIENT})\n req = urllib2.Request(self.AUTH_URL,postdata)\n if self.host:\n req.set_proxy(self.host, self.type)\n f = urllib2.urlopen(req)\n auth_value = f.read().split()[2][5:]\n f.close()\n self.Author_Headers = {'Authorization':'GoogleLogin auth=%s'%auth_value}","def _headers(self):\n\n api_key_bytes = '{0}:'.format(self.api_key).encode()\n authorization = b64encode(api_key_bytes).decode()\n\n headers = {\n 'Authorization': 'Basic {0}'.format(authorization),\n 'User-Agent': USER_AGENT,\n }\n\n if self.config['api_version']:\n headers['X-Button-API-Version'] = self.config['api_version']\n\n return headers","def test_headers(self):\n token = 'abc123'\n requests.get(self.url, auth=BearerAuth(token))\n self.assertEqual(httpretty.last_request().headers['Authorization'], 'Bearer {}'.format(token))","def _create_auth_headers(self):\n auth_headers = {**self.get_headers()}\n auth_headers['Authorization'] = 'Bearer ' + self.get_access_token()\n return auth_headers","def get_request_headers(self):\n return {\n 'Authorization': 'JWT ' + self.get_authorization_token()\n }","def get_authorization_headers(access_keeper):\n access_token = access_keeper.get_access_token()\n headers = {\n 'Authorization': f'Bearer {access_token}'\n }\n return headers","def _get_oauth_headers(self, user):\n access_token = AccessTokenFactory.create(user=user, application=ApplicationFactory()).token\n headers = {\n 'HTTP_AUTHORIZATION': 'Bearer ' + access_token\n }\n return headers","def _get_oauth_headers(self, user):\n access_token = AccessTokenFactory.create(user=user, application=ApplicationFactory()).token\n headers = {\n 'HTTP_AUTHORIZATION': 'Bearer ' + access_token\n }\n return headers","def _headers(self):\n\n auth_token = SendbeeAuth(self.client.api_secret).get_auth_token()\n headers = {\n 'X-Auth-Token': auth_token,\n 'X-Api-Key': self.client.api_key,\n 'Accept': 'application/json',\n 'Content-Type': 'application/json',\n 'User-Agent': 'Sendbee Python API Client'\n }\n self.debug.ok('headers', headers)\n\n return headers","def get_auth_headers():\n\n auth_type = \"Basic\"\n if request.headers.get('UseXBasic'):\n auth_type = \"XBasic\"\n\n return {\n 'WWW-Authenticate': '%s realm=\"Login Required\"' % auth_type\n }","def __MakeHeaders(self, auth):\n\n headers = dict()\n headers[\"X-Blip-api\"] = BLIP_API_VERSION\n headers[\"Accept\"] = JSON\n if (auth and self.userName != None and self.password != None):\n credentials = self.userName + \":\" + self.password;\n headers[\"Authorization\"] = \"Basic \"+base64.b64encode(credentials)\n if (self.userAgent != None):\n headers[\"User-Agent\"] = self.userAgent\n\n return headers","def buildHeader(self):\n if self.key:\n userString = self.user+b\":\"+self.key\n else:\n userString = self.user+b\":\"\n \n encodedUserString = b64encode(userString)\n decodedUserString = encodedUserString.decode(\"ascii\")\n self.basicAuthHeader = {\"Authorization\": \"Basic \" + decodedUserString}","def get_jwt():\n\n try:\n scheme, token = request.headers['Authorization'].split()\n assert scheme.lower() == 'basic'\n return base64.b64decode(token).decode(\"UTF-8\")\n except (KeyError, ValueError, AssertionError):\n raise Forbidden('Invalid Bearer Token.')","def get_auth_headers(self) -> Dict:\n if self.__access_token:\n return {\n 'Authorization': self.__access_token,\n 'Api-Key': self.__api_key,\n 'X-Client-Name': __client_name__,\n 'X-Client-Version': __version__,\n 'X-Min-Version': __min_engine_version__\n }\n elif self.__license_key and self.__email and self.__password:\n return {\n 'Authorization': self.__calculate_basic_auth_value(),\n 'License-Key': self.__license_key,\n 'Api-Key': self.__api_key,\n 'X-Client-Name': __client_name__,\n 'X-Client-Version': __version__,\n 'X-Min-Version': __min_engine_version__\n }\n else:\n raise ValueError('Credentials are not configured')","def get_client_login_token_string(http_body):\n for response_line in http_body.splitlines():\n if response_line.startswith('Auth='):\n # Strip off the leading Auth= and return the Authorization value.\n return response_line[5:]\n return None","def get_jwt(self, request):\n auth_header_prefix = self.auth_header_prefix\n try:\n authorization = request.authorization\n except ValueError:\n return None\n if authorization is None:\n return None\n authtype, token = authorization\n if authtype.lower() != auth_header_prefix.lower():\n return None\n return token","def authenticate_header(self, request):\n return \"Api key authentication failed.\"","def get_token(self):\n self.register_user(self.user_data)\n result = self.login_user(self.login_data)\n header_access_token = json.loads(result.data.decode())['header_access_token']\n return header_access_token","def authorization(self):\n token = self.create_auth_token(\n self.api_key.user, self.api_key.key, self.api_key.secret\n )\n return f'JWT {token}'","def inv_headers(access_token):\n headers = {\n 'Content-Type': 'application/x-www-form-urlencoded',\n 'Authorization': 'Bearer ' + access_token,\n 'Accept': 'application/json',\n 'Accept-Encoding': 'application/json',\n }\n return headers","def decode_auth_headers(request: Request) -> Tuple[str, str]:\n authorization = request.headers.get(\"Authorization\", \"\")\n\n headers = CaseInsensitiveDict({\"WWW-Authenticate\": \"Basic\"})\n\n scheme, param = get_authorization_scheme_param(authorization)\n if not authorization or scheme.lower() != \"basic\":\n raise InvalidClientError(request=request, headers=headers)\n\n try:\n data = b64decode(param).decode(\"ascii\")\n except (ValueError, UnicodeDecodeError, binascii.Error):\n raise InvalidClientError(request=request, headers=headers)\n\n client_id, separator, client_secret = data.partition(\":\")\n\n if not separator:\n raise InvalidClientError(request=request, headers=headers)\n\n return client_id, client_secret","def polling_header(self):\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\n', '')\n return { \n #\"Authorization\" : \"Basic %s\" % self.cmd.auth,\n #\"X-Atmosphere-Transport\" : \"long-polling\",\n #\"X-Atmosphere-tracking-id\" : self.atmos_id,\n \"X-Atmosphere-Framework\" : \"1.0\",\n \"Accept\" : \"application/json\" }","def get_token_auth_header(params):\n auth = get_token(params)\n parts = auth.split()\n\n if parts[0].lower() != \"bearer\":\n raise AuthError({\"code\": \"invalid_header\", \"description\": \"Authorization header must start with Bearer\"}, 401)\n\n if len(parts) == 1:\n raise AuthError({\"code\": \"invalid_header\", \"description\": \"Token not found\"}, 401)\n\n if len(parts) > 2:\n raise AuthError({\"code\": \"invalid_header\", \"description\": \"Authorization header must be Bearer token\"}, 401)\n\n token = parts[1]\n return token","def http_headers(self) -> dict:\n return {\n \"x-api-key\": f\"{self.config.get('api_key')}_{self.config.get('secret_key')}\",\n \"Content-type\": \"application/json\",\n }","def test_get_auth_header_fresh(self, mocker):\n oauth = Oauth2Authenticator(\n TestOauth2Authenticator.refresh_endpoint,\n TestOauth2Authenticator.client_id,\n TestOauth2Authenticator.client_secret,\n TestOauth2Authenticator.refresh_token,\n )\n\n mocker.patch.object(Oauth2Authenticator, \"refresh_access_token\", return_value=(\"access_token\", 1000))\n header = oauth.get_auth_header()\n assert {\"Authorization\": \"Bearer access_token\"} == header","def _headers(helper):\n return {\n 'Authorization': 'Splunk {0}'.format(\n helper.context_meta['session_key'])}","def get_headers(self) -> Dict[str, str]:\n header_dict = self.generate_auth_dict()\n\n return {\n \"Authorization\": \"Basic \" + header_dict[\"signature\"],\n \"Content-Type\": 'application/json',\n }","def auth(self):\r\n basic = parse_auth(self.environ.get('HTTP_AUTHORIZATION',''))\r\n if basic: return basic\r\n ruser = self.environ.get('REMOTE_USER')\r\n if ruser: return (ruser, None)\r\n return None","def generate_headers_with_auth(self, token_type: str = 'access'):\n if re.search('access', token_type, re.I):\n bearer_token = self._access_token\n elif re.search('refresh', token_type, re.I):\n bearer_token = self._refresh_token\n else:\n raise (Exception('Please check docstrings and change token_type value'))\n\n return {\n 'accept': 'application/json',\n 'Content-Type': 'application/json',\n 'Authorization': 'Bearer ' + bearer_token\n }","def get_base_ecom_headers(access_token):\r\n headers = config['ecom'].copy()\r\n headers['authorization'] = \"Bearer {}\".format(access_token)\r\n return headers","def _getApiAuthToken(self):\n return settings.EBAY_API_AUTH_TOKEN","def get_token_header(cls, token):\n if token is EMPTY_KNOX_TOKEN:\n return {}\n else:\n return {'HTTP_AUTHORIZATION': 'token {}'.format(token)}","def _build_common_headers(apikey: str):\n return {\n \"Authorization\": f\"token {apikey}\",\n \"User-Agent\": \"sharing-api-fetcher\",\n \"Accept-Encoding\": \"gzip\",\n \"Accept\": \"application/json\",\n }","def get_auth_token():\n headers = {\n 'Content-Type': 'text/plain;charset=UTF-8', }\n data = '{ \\\n \"auth\": { \\\n \"identity\": { \\\n \"methods\": [ \\\n \"password\" \\\n ], \\\n \"password\": { \\\n \"user\": { \\\n \"name\": \"zheng_zhao\", \\\n \"password\": \"ZhaoZheng0426\", \\\n \"domain\": { \\\n \"name\": \"hwstaff_y00465251\" \\\n } \\\n } \\\n } \\\n }, \\\n \"scope\": { \\\n \"project\": { \\\n \"id\": \"454add6b26d04f53ae5c593551acf1ff\" \\\n } \\\n } \\\n } \\\n }'\n\n r = requests.post('https://iam.cn-north-1.myhuaweicloud.com/v3/auth/tokens',\n headers=headers, data=data)\n\n # print(r.status_code)\n # print(r.headers)\n token = r.headers.get('X-Subject-Token')\n\n return token","def api_key(request):\r\n user_acct = request.user\r\n return _api_response(request, {\r\n 'api_key': user_acct.api_key,\r\n 'username': user_acct.username\r\n })","def _make_header(self, token):\n header = HEADER.copy()\n header['Authorization'] = \"Bearer {}\".format(token)\n\n return header","def headers(group_id, token):\n return { \n \"active-group\": group_id,\n \"Authorization\" : \"Bearer: {}\".format(token) \n }","def _token_header(token=None):\n if not token:\n return None\n\n message = '{token}:Ignored'.format(token=token)\n headers = {'Authorization': 'Basic {code}'.format(\n code=base64.b64encode(message))}\n return headers","def get_auth_header(self, login, password):\n json = self.request('post',\n '/auth/login',\n json={'uid': login, 'password': password},\n msg='authenticating at {} with user {}'.format(self.admin_url, login),\n errorfatal=False,\n retfmt='json',\n autoauth=False\n )\n if json:\n return {'Authorization': 'token=%s' % json['token']}\n else:\n return None"],"string":"[\n \"def api_client_authz_header():\\n return assemble_authorization_header(API_TOKEN)\",\n \"def api_client_authz_header():\\n return assemble_authorization_header(API_TOKEN)\",\n \"def get_authorization_header(self):\\n return {\\\"Authorization\\\": \\\"Bearer {}\\\".format(self.get_jwt())}\",\n \"def get_authorization_header(client, user):\\n # obtain authorization token\\n response = client.post(\\n reverse('token-obtain'),\\n data={'username': user.username, 'password': user.raw_password},\\n content_type='application/json'\\n )\\n token = response.json()['access']\\n return {'HTTP_AUTHORIZATION': f'Bearer {token}'}\",\n \"def get_api_header(token):\\n return {\\n 'Authorization': 'Token ' + str(token)}\",\n \"def get_auth_header(self):\\n if not self.verify():\\n return None\\n\\n auth_val = self.encode_auth_header_val()\\n if not auth_val:\\n return None\\n\\n return {'Authorization': auth_val.replace('\\\\n', '')}\",\n \"def build_header(self):\\n authstring = \\\"Bearer \\\" + self.auth_token\\n header = {\\n \\\"Authorization\\\": authstring,\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"User-Agent\\\": self.user_agent,\\n \\\"Accept-Encoding\\\": \\\"gzip\\\"\\n }\\n return header\",\n \"def _get_authorization_header(self):\\n return f\\\"token {self._context.get_github_token()}\\\"\",\n \"def get_token_auth_header():\\n auth = request.headers.get(\\\"Authorization\\\", None)\\n if not auth:\\n return \\\"authorization_header_missing\\\"\\n\\n parts = auth.split()\\n\\n if parts[0].lower() != \\\"bearer\\\":\\n return \\\"invalid_header\\\"\\n elif len(parts) == 1:\\n return \\\"invalid_header\\\"\\n elif len(parts) > 2:\\n return \\\"invalid_header\\\"\\n\\n token = parts[1]\\n return token\",\n \"def create_auth_header(api_token):\\n return {'Authorization': f'token {api_token}'}\",\n \"def getBasicAuthorization(self):\\n header = self.request.getHeader(\\\"Authorization\\\")\\n if header:\\n try:\\n if header.lower().startswith(\\\"basic \\\"):\\n authstr = base64.b64decode(header[6:]).split(\\\":\\\")\\n if len(authstr) == 1:\\n return None\\n return authstr[0], \\\":\\\".join(authstr[1:])\\n except:\\n return None\\n return None\",\n \"def get_auth(info) -> Tuple[Optional[str], Optional[str]]:\\n auth = info.context[\\\"request\\\"].headers.get(\\\"Authorization\\\")\\n if not auth:\\n return None, None\\n return auth.replace(\\\"Bearer \\\", \\\"\\\"), None\",\n \"def authentication_request():\\n # Get the access token from the header\\n auth_header = request.headers.get('Authorization')\\n if auth_header:\\n try:\\n access_token = auth_header.split(' ')[1]\\n except IndexError:\\n return {\\\"message\\\": \\\"Token is malformed\\\"}, status.HTTP_401_UNAUTHORIZED\\n else:\\n access_token = ''\\n\\n return access_token\",\n \"def auth_header(self):\\n return self._auth_header\",\n \"def extract_bearer_token(request):\\n return request.headers['Authorization'].split(\\\" \\\")[-1].strip()\",\n \"def get_token_auth_header():\\n # Get authorization form request header\\n auth = request.headers.get('Authorization', None)\\n # Check if authorization header exists\\n if not auth:\\n raise AuthError({\\n 'code': 'authorization_header_missing',\\n 'description': 'Authorization header is MISSING!'\\n }, abort(401))\\n # If bearer token, then first part of string = 'bearer'\\n parts = auth.split()\\n if parts[0].lower() != 'bearer':\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must start with \\\"Bearer\\\"'\\n }, abort(401))\\n # Authorization header string length must be 2\\n elif len(parts) != 2:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must be a BEARER token'\\n }, abort(401))\\n\\n token = parts[1]\\n return token\",\n \"def get_authorization(self):\\n auth = get_authorization_header()\\n\\n if not auth:\\n return None\\n\\n auth_type, auth_info = auth\\n\\n if auth_type != b'basic':\\n return None\\n\\n try:\\n username, password = base64.b64decode(auth_info).split(b':', 1)\\n except Exception:\\n return None\\n\\n return Authorization(\\\"basic\\\", username=bytes_to_wsgi(username), password=bytes_to_wsgi(password))\",\n \"def request_http_header( self ) -> dict:\\n return {'content-type': 'application/json','Authorization':f'NLAuth nlauth_account={self._acct_number},nlauth_email={self._auth_email},nlauth_signature={self._acct_signature},nlauth_role=1090'}\",\n \"def get_auth_header(self) -> Mapping[str, Any]:\\n return {}\",\n \"def get_token_auth_header():\\n auth = request.headers.get(\\\"Authorization\\\", None)\\n print(auth)\\n\\n if not auth:\\n raise AuthError({\\\"code\\\": \\\"authorization_header_missing\\\",\\n \\\"description\\\":\\n \\\"Authorization header is expected\\\"}, 401)\\n \\n parts = auth.split()\\n \\n if parts[0].lower() != \\\"bearer\\\":\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must start with\\\"\\n \\\" Bearer\\\"}, 401)\\n elif len(parts) == 1:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\": \\\"Token not found\\\"}, 401)\\n elif len(parts) > 2:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must be\\\"\\n \\\" Bearer token\\\"}, 401)\\n\\n token = parts[1]\\n return token\",\n \"def auth_key(event):\\n headers = event.get('header')\\n if not headers:\\n raise RestException(\\\"Headers are missing\\\", 400)\\n auth = headers.get('Authorization')\\n if not auth:\\n raise RestException('Header Authorization is missing', 400)\\n if not auth.lower().startswith('bearer '):\\n raise RestException(\\\"Authorization missing Bearer keyword\\\", 400)\\n auth = auth.replace('Bearer ', '')\\n auth = auth.replace('bearer ', '')\\n return auth.strip()\",\n \"def get_token_auth_header():\\n auth = request.headers.get('Authorization', None)\\n if not auth:\\n raise AuthError({\\n 'code': 'authorization_header_missing',\\n 'description': 'Authorization header is expected.'\\n }, 401)\\n elif auth.split()[0].lower() != 'bearer':\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must start with \\\"Bearer\\\".'\\n }, 401)\\n elif len(auth.split()) == 1:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must be include type and token.'\\n }, 401)\\n elif len(auth.split()) > 2:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must be Bearer token.'\\n }, 401)\\n else:\\n token = auth.split()[1]\\n return token\",\n \"def __header_base64(self):\\n header_base64 = base64.b64encode(f'{self.client_id}:{self.client_secret}'.encode('ascii'))\\n header_base64 = str(header_base64).split(\\\"'\\\")[1]\\n return {'Authorization': f'Basic {header_base64}'}\",\n \"def _request_token(self):\\n params = {\\n 'grant_type': 'client_credentials',\\n 'client_id': self.client_id,\\n 'client_secret': self.client_secret\\n }\\n\\n response = self._http_request(\\n method='POST',\\n headers={'Content-Type': 'application/x-www-form-urlencoded'},\\n full_url=self.auth_url,\\n data=params\\n )\\n access_token = response.get('access_token')\\n auth_header = {'Authorization': f'Bearer {access_token}'}\\n return auth_header\",\n \"def get_auth_headers(key):\\n return {\\n 'Content-Type': 'Application/JSON',\\n 'Authorization': key\\n }\",\n \"def get_authenticate_header(self):\\n pass\",\n \"def get_token_auth_header():\\n auth = request.headers.get('Authorization', None)\\n if not auth:\\n raise AuthError({\\n 'code': 'authorization_header_missing',\\n 'description': 'Authorization header is expected.'\\n }, 401)\\n\\n parts = auth.split()\\n if parts[0].lower() != 'bearer':\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must start with \\\"Bearer\\\".'\\n }, 401)\\n\\n elif len(parts) == 1:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Token not found.'\\n }, 401)\\n\\n elif len(parts) > 2:\\n raise AuthError({\\n 'code': 'invalid_header',\\n 'description': 'Authorization header must be bearer token.'\\n }, 401)\\n\\n token = parts[1]\\n return token\",\n \"def _auth_headers(self):\\n if self.token_str:\\n return {'Authorization': 'Bearer {}'.format(self.token_str)}\\n else:\\n return {}\",\n \"def get_token_auth_header():\\n auth = request.headers.get('Authorization', None)\\n if not auth:\\n raise AuthError({'code': 'authorization_header_missing',\\n 'description': 'Authorization header is expected'}, 401)\\n\\n parts = auth.split()\\n\\n if parts[0].lower() != 'bearer':\\n raise AuthError({'code': 'invalid_header',\\n 'description': 'Authorization header must start with Bearer'}, 401)\\n\\n if len(parts) < 2:\\n raise AuthError({'code': 'invalid_header',\\n 'description': 'Token not found after Bearer'}, 401)\\n\\n if len(parts) > 2:\\n raise AuthError({'code': 'invalid_header',\\n 'description': 'Authorization header is an invalid token structure'}, 401)\\n\\n return parts[1]\",\n \"def get_token_auth_header():\\n auth = request.headers.get(\\\"Authorization\\\", None)\\n if not auth:\\n raise AuthError({\\\"code\\\": \\\"authorization_header_missing\\\",\\n \\\"description\\\":\\n \\\"Authorization header is expected\\\"}, 401)\\n\\n parts = auth.split()\\n\\n if parts[0].lower() != \\\"bearer\\\":\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must start with\\\"\\n \\\" Bearer\\\"}, 401)\\n elif len(parts) == 1:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\": \\\"Token not found\\\"}, 401)\\n elif len(parts) > 2:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\",\\n \\\"description\\\":\\n \\\"Authorization header must be\\\"\\n \\\" Bearer token\\\"}, 401)\\n\\n token = parts[1]\\n return token\",\n \"def get_authenticate_header(self):\\n return f'Basic realm=\\\"{self.www_authenticate_realm}\\\"'\",\n \"async def authorization(request):\\n # Decode tokens, load/check users and etc\\n # ...\\n # in the example we just ensure that the authorization header exists\\n return request.headers.get(\\\"authorization\\\", \\\"\\\")\",\n \"def asterisk_in_header():\\n auth_token = get_auth_token()\\n\\n headers = '{\\\"Host\\\":\\\"$host\\\",\\\"User-Agent\\\":\\\"$user_agent\\\",\\\"Date\\\":\\\"DATE\\\",'\\n headers += '\\\"Accept\\\": \\\"*/*\\\",\\\"Accept-Encoding\\\": \\\"gzip\\\",'\\n headers += '\\\"X-Project-ID\\\": \\\"$project_id\\\",'\\n headers += '\\\"X-Auth-Token\\\": \\\"$token\\\"}'\\n headers = string.Template(headers)\\n\\n return headers.substitute(host=CFG.host, user_agent=CFG.user_agent,\\n project_id=CFG.project_id, token=auth_token)\",\n \"def auth_header_value(self):\\n return f\\\"token {self.API_TOKEN}\\\"\",\n \"def getHeaders():\\n userid = rhev_settings.USERNAME\\n passwd = rhev_settings.PASSWORD\\n # base64.encodestring adds trailing \\\\n. \\n auth = base64.encodestring(\\\"%s:%s\\\" % (userid, passwd)).rstrip(\\\"\\\\n\\\")\\n headers = {\\\"Content-Type\\\": \\\"application/xml\\\",\\n \\\"Accept\\\": \\\"application/xml\\\",\\n \\\"Accept-Charset\\\": \\\"utf-8\\\",\\n \\\"Authorization\\\" : (\\\"Basic %s\\\" % auth)}\\n return headers\",\n \"def build_header(token: str = None):\\n return {\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"X-Auth-Token\\\": token or get_project_token(),\\n }\",\n \"def _retrieve_token(request):\\n auth_string = request.headers.get('Authorization')\\n try:\\n match = re.match(\\\"Bearer (.+)\\\", auth_string)\\n except TypeError:\\n match = None\\n if match:\\n return match.groups()[0]\",\n \"def get_headers():\\n return {'Authorization': f'token {settings.GITHUB_AUTH_TOKEN}'}\",\n \"def authentication_header():\\n with open(KEY_FILE, \\\"r\\\") as file:\\n header = json.load(file)\\n return header\",\n \"def auth_headers(current_user_token: str) -> Dict[str, str]:\\n return {\\\"Authorization\\\": f\\\"Bearer {current_user_token}\\\"}\",\n \"def get_headers():\\n if not headers:\\n headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n headers[\\\"Accept\\\"] = \\\"application/json\\\"\\n headers[\\\"User-Agent\\\"] = constants.USER_AGENT\\n headers[\\\"Authorization\\\"] = get_token(constants.AUTH_URL, cfg[\\\"key\\\"])\\n\\n return headers\\n\\n return headers\",\n \"def authorization(self):\\n return {'auth-token': '{token}'.format(token=self.token)}\",\n \"def authorization(self):\\n return {'auth-token': '{token}'.format(token=self.token)}\",\n \"def get_headers(self):\\n headers = {\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"Authorization\\\": \\\"Basic %s\\\" % self.rest_auth_key\\n }\\n return headers\",\n \"def get_token() -> str:\\n try:\\n bearer, authorization = request.headers['Authorization'].split()\\n if 'bearer' not in bearer.lower():\\n raise Forbidden('Invalid token. Please login!')\\n return authorization\\n\\n except Exception:\\n raise Forbidden('Token is required. Please login!')\",\n \"def bearer_auth():\\n authorization = request.headers.get(\\\"Authorization\\\")\\n if not (authorization and authorization.startswith(\\\"Bearer \\\")):\\n response = app.make_response(\\\"\\\")\\n response.headers[\\\"WWW-Authenticate\\\"] = \\\"Bearer\\\"\\n response.status_code = 401\\n return response\\n slice_start = len(\\\"Bearer \\\")\\n token = authorization[slice_start:]\\n\\n return jsonify(authenticated=True, token=token)\",\n \"def authenticate_header(self, request):\\n return '{0} realm=\\\"{1}\\\"'.format(settings.JWT_AUTH_HEADER_PREFIX,\\n self.www_authenticate_realm)\",\n \"def _headers(self):\\n auth = AuthenticationProvider.currentAuth()\\n\\n return {\\n 'Authorization': '%s %s' % (auth.tokenType, auth.accessToken),\\n 'Content-Type': 'application/json'}\",\n \"def oauth_headers(oauth):\\n import base64\\n encoded_credentials = base64.b64encode(('{0}:{1}'.format(oauth.client_id, oauth.client_secret)).encode('utf-8'))\\n headers = {\\n 'Authorization': 'Basic {0}'.format(encoded_credentials.decode('utf-8')),\\n 'Content-Type': 'application/x-www-form-urlencoded'\\n }\\n return headers\",\n \"def get_headers(self):\\n return {\\n 'Authorization': 'JWT {}'.format(self.token)\\n }\",\n \"def header_token(token):\\n return {'Authorization': '{0} {1}'.format('JWT', token)}\",\n \"def get_headers() -> dict:\\n headers = {}\\n token = GoogleAuthService.get_report_api_token()\\n if token:\\n headers['Authorization'] = 'Bearer {}'.format(token)\\n return headers\",\n \"def get_headers(self):\\r\\n return {\\r\\n 'authenticate': {\\r\\n 'username': self.username,\\r\\n 'apiKey': self.api_key,\\r\\n }\\r\\n }\",\n \"def get_headers():\\n headers = {\\n \\\"Authorization\\\": \\\"Token {}\\\".format(get_token()),\\n }\\n\\n return headers\",\n \"def get_auth(context):\\n\\n headers = context['headers']\\n auth_info = {\\n \\\"type\\\": \\\"basic\\\",\\n \\\"basic\\\": {\\n \\\"user\\\": headers['api_key'],\\n \\\"password\\\": \\\"X\\\"\\n }\\n }\\n auth = Auth().get_auth(auth_info)\\n\\n return auth\",\n \"def create_authorization_header(self, **kwargs):\\n return {\\\"Authorization\\\": \\\"Bearer {}\\\".format(self.create_jwt(**kwargs))}\",\n \"def basic_header(self):\\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\\\n', '')\\n return { \\n #\\\"Authorization\\\" : \\\"Basic %s\\\" % self.auth, \\n \\\"Content-type\\\": \\\"text/plain\\\" }\",\n \"def generate_oauth_headers(access_token: str) -> dict:\\n return {'Authorization': 'Bearer ' + access_token}\",\n \"def getToken(request):\\n try:\\n token = request.META['HTTP_AUTHORIZATION'].split()[1]\\n except:\\n token = \\\"\\\"\\n return token\",\n \"def add_header(response):\\n response.headers['Authorization'] = response\\n return response\",\n \"def get_token():\\n token = getpass.getpass('Paste in your RDR API token and press Enter:')\\n return {'Authorization': 'token ' + token}\",\n \"def get_auth_headers(self,email,passwd):\\n #获取认证后的http头\\n\\n postdata = urllib.urlencode({'Email':email,'Passwd':passwd,'service':'reader','source':self.ClIENT})\\n req = urllib2.Request(self.AUTH_URL,postdata)\\n if self.host:\\n req.set_proxy(self.host, self.type)\\n f = urllib2.urlopen(req)\\n auth_value = f.read().split()[2][5:]\\n f.close()\\n self.Author_Headers = {'Authorization':'GoogleLogin auth=%s'%auth_value}\",\n \"def _headers(self):\\n\\n api_key_bytes = '{0}:'.format(self.api_key).encode()\\n authorization = b64encode(api_key_bytes).decode()\\n\\n headers = {\\n 'Authorization': 'Basic {0}'.format(authorization),\\n 'User-Agent': USER_AGENT,\\n }\\n\\n if self.config['api_version']:\\n headers['X-Button-API-Version'] = self.config['api_version']\\n\\n return headers\",\n \"def test_headers(self):\\n token = 'abc123'\\n requests.get(self.url, auth=BearerAuth(token))\\n self.assertEqual(httpretty.last_request().headers['Authorization'], 'Bearer {}'.format(token))\",\n \"def _create_auth_headers(self):\\n auth_headers = {**self.get_headers()}\\n auth_headers['Authorization'] = 'Bearer ' + self.get_access_token()\\n return auth_headers\",\n \"def get_request_headers(self):\\n return {\\n 'Authorization': 'JWT ' + self.get_authorization_token()\\n }\",\n \"def get_authorization_headers(access_keeper):\\n access_token = access_keeper.get_access_token()\\n headers = {\\n 'Authorization': f'Bearer {access_token}'\\n }\\n return headers\",\n \"def _get_oauth_headers(self, user):\\n access_token = AccessTokenFactory.create(user=user, application=ApplicationFactory()).token\\n headers = {\\n 'HTTP_AUTHORIZATION': 'Bearer ' + access_token\\n }\\n return headers\",\n \"def _get_oauth_headers(self, user):\\n access_token = AccessTokenFactory.create(user=user, application=ApplicationFactory()).token\\n headers = {\\n 'HTTP_AUTHORIZATION': 'Bearer ' + access_token\\n }\\n return headers\",\n \"def _headers(self):\\n\\n auth_token = SendbeeAuth(self.client.api_secret).get_auth_token()\\n headers = {\\n 'X-Auth-Token': auth_token,\\n 'X-Api-Key': self.client.api_key,\\n 'Accept': 'application/json',\\n 'Content-Type': 'application/json',\\n 'User-Agent': 'Sendbee Python API Client'\\n }\\n self.debug.ok('headers', headers)\\n\\n return headers\",\n \"def get_auth_headers():\\n\\n auth_type = \\\"Basic\\\"\\n if request.headers.get('UseXBasic'):\\n auth_type = \\\"XBasic\\\"\\n\\n return {\\n 'WWW-Authenticate': '%s realm=\\\"Login Required\\\"' % auth_type\\n }\",\n \"def __MakeHeaders(self, auth):\\n\\n headers = dict()\\n headers[\\\"X-Blip-api\\\"] = BLIP_API_VERSION\\n headers[\\\"Accept\\\"] = JSON\\n if (auth and self.userName != None and self.password != None):\\n credentials = self.userName + \\\":\\\" + self.password;\\n headers[\\\"Authorization\\\"] = \\\"Basic \\\"+base64.b64encode(credentials)\\n if (self.userAgent != None):\\n headers[\\\"User-Agent\\\"] = self.userAgent\\n\\n return headers\",\n \"def buildHeader(self):\\n if self.key:\\n userString = self.user+b\\\":\\\"+self.key\\n else:\\n userString = self.user+b\\\":\\\"\\n \\n encodedUserString = b64encode(userString)\\n decodedUserString = encodedUserString.decode(\\\"ascii\\\")\\n self.basicAuthHeader = {\\\"Authorization\\\": \\\"Basic \\\" + decodedUserString}\",\n \"def get_jwt():\\n\\n try:\\n scheme, token = request.headers['Authorization'].split()\\n assert scheme.lower() == 'basic'\\n return base64.b64decode(token).decode(\\\"UTF-8\\\")\\n except (KeyError, ValueError, AssertionError):\\n raise Forbidden('Invalid Bearer Token.')\",\n \"def get_auth_headers(self) -> Dict:\\n if self.__access_token:\\n return {\\n 'Authorization': self.__access_token,\\n 'Api-Key': self.__api_key,\\n 'X-Client-Name': __client_name__,\\n 'X-Client-Version': __version__,\\n 'X-Min-Version': __min_engine_version__\\n }\\n elif self.__license_key and self.__email and self.__password:\\n return {\\n 'Authorization': self.__calculate_basic_auth_value(),\\n 'License-Key': self.__license_key,\\n 'Api-Key': self.__api_key,\\n 'X-Client-Name': __client_name__,\\n 'X-Client-Version': __version__,\\n 'X-Min-Version': __min_engine_version__\\n }\\n else:\\n raise ValueError('Credentials are not configured')\",\n \"def get_client_login_token_string(http_body):\\n for response_line in http_body.splitlines():\\n if response_line.startswith('Auth='):\\n # Strip off the leading Auth= and return the Authorization value.\\n return response_line[5:]\\n return None\",\n \"def get_jwt(self, request):\\n auth_header_prefix = self.auth_header_prefix\\n try:\\n authorization = request.authorization\\n except ValueError:\\n return None\\n if authorization is None:\\n return None\\n authtype, token = authorization\\n if authtype.lower() != auth_header_prefix.lower():\\n return None\\n return token\",\n \"def authenticate_header(self, request):\\n return \\\"Api key authentication failed.\\\"\",\n \"def get_token(self):\\n self.register_user(self.user_data)\\n result = self.login_user(self.login_data)\\n header_access_token = json.loads(result.data.decode())['header_access_token']\\n return header_access_token\",\n \"def authorization(self):\\n token = self.create_auth_token(\\n self.api_key.user, self.api_key.key, self.api_key.secret\\n )\\n return f'JWT {token}'\",\n \"def inv_headers(access_token):\\n headers = {\\n 'Content-Type': 'application/x-www-form-urlencoded',\\n 'Authorization': 'Bearer ' + access_token,\\n 'Accept': 'application/json',\\n 'Accept-Encoding': 'application/json',\\n }\\n return headers\",\n \"def decode_auth_headers(request: Request) -> Tuple[str, str]:\\n authorization = request.headers.get(\\\"Authorization\\\", \\\"\\\")\\n\\n headers = CaseInsensitiveDict({\\\"WWW-Authenticate\\\": \\\"Basic\\\"})\\n\\n scheme, param = get_authorization_scheme_param(authorization)\\n if not authorization or scheme.lower() != \\\"basic\\\":\\n raise InvalidClientError(request=request, headers=headers)\\n\\n try:\\n data = b64decode(param).decode(\\\"ascii\\\")\\n except (ValueError, UnicodeDecodeError, binascii.Error):\\n raise InvalidClientError(request=request, headers=headers)\\n\\n client_id, separator, client_secret = data.partition(\\\":\\\")\\n\\n if not separator:\\n raise InvalidClientError(request=request, headers=headers)\\n\\n return client_id, client_secret\",\n \"def polling_header(self):\\n self.auth = base64.encodestring('%s:%s' % (self.username, self.password)).replace('\\\\n', '')\\n return { \\n #\\\"Authorization\\\" : \\\"Basic %s\\\" % self.cmd.auth,\\n #\\\"X-Atmosphere-Transport\\\" : \\\"long-polling\\\",\\n #\\\"X-Atmosphere-tracking-id\\\" : self.atmos_id,\\n \\\"X-Atmosphere-Framework\\\" : \\\"1.0\\\",\\n \\\"Accept\\\" : \\\"application/json\\\" }\",\n \"def get_token_auth_header(params):\\n auth = get_token(params)\\n parts = auth.split()\\n\\n if parts[0].lower() != \\\"bearer\\\":\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\", \\\"description\\\": \\\"Authorization header must start with Bearer\\\"}, 401)\\n\\n if len(parts) == 1:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\", \\\"description\\\": \\\"Token not found\\\"}, 401)\\n\\n if len(parts) > 2:\\n raise AuthError({\\\"code\\\": \\\"invalid_header\\\", \\\"description\\\": \\\"Authorization header must be Bearer token\\\"}, 401)\\n\\n token = parts[1]\\n return token\",\n \"def http_headers(self) -> dict:\\n return {\\n \\\"x-api-key\\\": f\\\"{self.config.get('api_key')}_{self.config.get('secret_key')}\\\",\\n \\\"Content-type\\\": \\\"application/json\\\",\\n }\",\n \"def test_get_auth_header_fresh(self, mocker):\\n oauth = Oauth2Authenticator(\\n TestOauth2Authenticator.refresh_endpoint,\\n TestOauth2Authenticator.client_id,\\n TestOauth2Authenticator.client_secret,\\n TestOauth2Authenticator.refresh_token,\\n )\\n\\n mocker.patch.object(Oauth2Authenticator, \\\"refresh_access_token\\\", return_value=(\\\"access_token\\\", 1000))\\n header = oauth.get_auth_header()\\n assert {\\\"Authorization\\\": \\\"Bearer access_token\\\"} == header\",\n \"def _headers(helper):\\n return {\\n 'Authorization': 'Splunk {0}'.format(\\n helper.context_meta['session_key'])}\",\n \"def get_headers(self) -> Dict[str, str]:\\n header_dict = self.generate_auth_dict()\\n\\n return {\\n \\\"Authorization\\\": \\\"Basic \\\" + header_dict[\\\"signature\\\"],\\n \\\"Content-Type\\\": 'application/json',\\n }\",\n \"def auth(self):\\r\\n basic = parse_auth(self.environ.get('HTTP_AUTHORIZATION',''))\\r\\n if basic: return basic\\r\\n ruser = self.environ.get('REMOTE_USER')\\r\\n if ruser: return (ruser, None)\\r\\n return None\",\n \"def generate_headers_with_auth(self, token_type: str = 'access'):\\n if re.search('access', token_type, re.I):\\n bearer_token = self._access_token\\n elif re.search('refresh', token_type, re.I):\\n bearer_token = self._refresh_token\\n else:\\n raise (Exception('Please check docstrings and change token_type value'))\\n\\n return {\\n 'accept': 'application/json',\\n 'Content-Type': 'application/json',\\n 'Authorization': 'Bearer ' + bearer_token\\n }\",\n \"def get_base_ecom_headers(access_token):\\r\\n headers = config['ecom'].copy()\\r\\n headers['authorization'] = \\\"Bearer {}\\\".format(access_token)\\r\\n return headers\",\n \"def _getApiAuthToken(self):\\n return settings.EBAY_API_AUTH_TOKEN\",\n \"def get_token_header(cls, token):\\n if token is EMPTY_KNOX_TOKEN:\\n return {}\\n else:\\n return {'HTTP_AUTHORIZATION': 'token {}'.format(token)}\",\n \"def _build_common_headers(apikey: str):\\n return {\\n \\\"Authorization\\\": f\\\"token {apikey}\\\",\\n \\\"User-Agent\\\": \\\"sharing-api-fetcher\\\",\\n \\\"Accept-Encoding\\\": \\\"gzip\\\",\\n \\\"Accept\\\": \\\"application/json\\\",\\n }\",\n \"def get_auth_token():\\n headers = {\\n 'Content-Type': 'text/plain;charset=UTF-8', }\\n data = '{ \\\\\\n \\\"auth\\\": { \\\\\\n \\\"identity\\\": { \\\\\\n \\\"methods\\\": [ \\\\\\n \\\"password\\\" \\\\\\n ], \\\\\\n \\\"password\\\": { \\\\\\n \\\"user\\\": { \\\\\\n \\\"name\\\": \\\"zheng_zhao\\\", \\\\\\n \\\"password\\\": \\\"ZhaoZheng0426\\\", \\\\\\n \\\"domain\\\": { \\\\\\n \\\"name\\\": \\\"hwstaff_y00465251\\\" \\\\\\n } \\\\\\n } \\\\\\n } \\\\\\n }, \\\\\\n \\\"scope\\\": { \\\\\\n \\\"project\\\": { \\\\\\n \\\"id\\\": \\\"454add6b26d04f53ae5c593551acf1ff\\\" \\\\\\n } \\\\\\n } \\\\\\n } \\\\\\n }'\\n\\n r = requests.post('https://iam.cn-north-1.myhuaweicloud.com/v3/auth/tokens',\\n headers=headers, data=data)\\n\\n # print(r.status_code)\\n # print(r.headers)\\n token = r.headers.get('X-Subject-Token')\\n\\n return token\",\n \"def api_key(request):\\r\\n user_acct = request.user\\r\\n return _api_response(request, {\\r\\n 'api_key': user_acct.api_key,\\r\\n 'username': user_acct.username\\r\\n })\",\n \"def _make_header(self, token):\\n header = HEADER.copy()\\n header['Authorization'] = \\\"Bearer {}\\\".format(token)\\n\\n return header\",\n \"def headers(group_id, token):\\n return { \\n \\\"active-group\\\": group_id,\\n \\\"Authorization\\\" : \\\"Bearer: {}\\\".format(token) \\n }\",\n \"def _token_header(token=None):\\n if not token:\\n return None\\n\\n message = '{token}:Ignored'.format(token=token)\\n headers = {'Authorization': 'Basic {code}'.format(\\n code=base64.b64encode(message))}\\n return headers\",\n \"def get_auth_header(self, login, password):\\n json = self.request('post',\\n '/auth/login',\\n json={'uid': login, 'password': password},\\n msg='authenticating at {} with user {}'.format(self.admin_url, login),\\n errorfatal=False,\\n retfmt='json',\\n autoauth=False\\n )\\n if json:\\n return {'Authorization': 'token=%s' % json['token']}\\n else:\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.77325","0.77325","0.7386359","0.73046136","0.71326786","0.70995873","0.7064967","0.69181406","0.67679745","0.6723393","0.67186785","0.66517","0.66500354","0.66368353","0.6635809","0.6585172","0.6572229","0.6569699","0.65522623","0.65466243","0.65304196","0.6509508","0.6477137","0.64675003","0.64669615","0.6422462","0.6418191","0.63934374","0.6390747","0.6382785","0.63766855","0.63636583","0.63521415","0.63419616","0.63332254","0.63210744","0.6294615","0.62922484","0.62789834","0.6275267","0.6274332","0.6267784","0.6267784","0.6255235","0.62233526","0.6211367","0.61836326","0.6173208","0.61695576","0.61642355","0.6164117","0.6154562","0.6150091","0.61259437","0.6101547","0.61009836","0.61008537","0.6093743","0.60872734","0.60850525","0.6074983","0.60630244","0.6059984","0.60490835","0.60478127","0.60476834","0.6042372","0.6040074","0.6040074","0.60370815","0.6020954","0.60111666","0.6009826","0.5982999","0.59761596","0.596899","0.5955032","0.5952252","0.5941291","0.59349686","0.59327376","0.59323555","0.59267515","0.58809465","0.58788306","0.58632916","0.5862378","0.58435166","0.58385134","0.5836756","0.58284754","0.5827809","0.5819473","0.58189636","0.57989544","0.5790581","0.57896334","0.57849663","0.57589597","0.57469755"],"string":"[\n \"0.77325\",\n \"0.77325\",\n \"0.7386359\",\n \"0.73046136\",\n \"0.71326786\",\n \"0.70995873\",\n \"0.7064967\",\n \"0.69181406\",\n \"0.67679745\",\n \"0.6723393\",\n \"0.67186785\",\n \"0.66517\",\n \"0.66500354\",\n \"0.66368353\",\n \"0.6635809\",\n \"0.6585172\",\n \"0.6572229\",\n \"0.6569699\",\n \"0.65522623\",\n \"0.65466243\",\n \"0.65304196\",\n \"0.6509508\",\n \"0.6477137\",\n \"0.64675003\",\n \"0.64669615\",\n \"0.6422462\",\n \"0.6418191\",\n \"0.63934374\",\n \"0.6390747\",\n \"0.6382785\",\n \"0.63766855\",\n \"0.63636583\",\n \"0.63521415\",\n \"0.63419616\",\n \"0.63332254\",\n \"0.63210744\",\n \"0.6294615\",\n \"0.62922484\",\n \"0.62789834\",\n \"0.6275267\",\n \"0.6274332\",\n \"0.6267784\",\n \"0.6267784\",\n \"0.6255235\",\n \"0.62233526\",\n \"0.6211367\",\n \"0.61836326\",\n \"0.6173208\",\n \"0.61695576\",\n \"0.61642355\",\n \"0.6164117\",\n \"0.6154562\",\n \"0.6150091\",\n \"0.61259437\",\n \"0.6101547\",\n \"0.61009836\",\n \"0.61008537\",\n \"0.6093743\",\n \"0.60872734\",\n \"0.60850525\",\n \"0.6074983\",\n \"0.60630244\",\n \"0.6059984\",\n \"0.60490835\",\n \"0.60478127\",\n \"0.60476834\",\n \"0.6042372\",\n \"0.6040074\",\n \"0.6040074\",\n \"0.60370815\",\n \"0.6020954\",\n \"0.60111666\",\n \"0.6009826\",\n \"0.5982999\",\n \"0.59761596\",\n \"0.596899\",\n \"0.5955032\",\n \"0.5952252\",\n \"0.5941291\",\n \"0.59349686\",\n \"0.59327376\",\n \"0.59323555\",\n \"0.59267515\",\n \"0.58809465\",\n \"0.58788306\",\n \"0.58632916\",\n \"0.5862378\",\n \"0.58435166\",\n \"0.58385134\",\n \"0.5836756\",\n \"0.58284754\",\n \"0.5827809\",\n \"0.5819473\",\n \"0.58189636\",\n \"0.57989544\",\n \"0.5790581\",\n \"0.57896334\",\n \"0.57849663\",\n \"0.57589597\",\n \"0.57469755\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6833908"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":4998,"cells":{"query":{"kind":"string","value":"Call GoDaddy developer API endpoint. Only supports GET endpoints to keep access readonly."},"document":{"kind":"string","value":"def _call_endpoint(url_suffix: str, base_url: str = BASE_URL) -> dict:\n headers = _get_headers()\n url = os.path.join(base_url, url_suffix)\n resp = requests.get(url, headers=headers)\n return resp.json()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def api_call():\n\tresponse = requests.get(URL_API)\n\treturn response","def call_api(url):\n\n req = requests.get(url)\n return req","def call_api(url):\n\n req = requests.get(url)\n return req","def requester(get_args: dict) -> dict:\n get_args.update(dict(apikey = apikey))\n response = requests.get(URL, params = get_args)\n return response.json()","def _make_api_call(url, params=None):\n if params is None:\n params = {}\n\n # params['apikey'] = CONFIG.BIOPORTAL_API_KEY\n params['apikey'] = \"8316a8aa-ff8e-4d6e-aa95-faeabfc72d2a\"\n return requests.get(url, params=params)","def api():\n\treturn \"The API call\"","def api_endpoint():\n return 'localhost'","def request_endpoints(self):\n\n endpoints_url = self.std[\"api\"]\n endpoints_paramd = {\n \"access_token\": self.std[\"access_token\"]\n }\n\n endpoints_response = requests.get(url=endpoints_url, params=endpoints_paramd)\n print endpoints_response\n self.endpointd = endpoints_response.json()[0]","def request(host, path, api_key, url_params=None):\n url_params = url_params or {}\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n headers = {\n 'Authorization': 'Bearer %s' % api_key,\n }\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n return response.json()","def get():\n return jsonify({'doctor': 'Doctor API'}), 200","def get_rest_call(api_url, username, password):\n response = requests.get(api_url,\n auth=HTTPBasicAuth(username, password),\n verify=False,\n timeout=4)\n return response","def _api_call(self, **kwargs):\n params = {\n 'format': 'json',\n }\n params.update(kwargs)\n r = requests.get(self.api_base_url, params=params)\n return r.json()","def get_call_api(url, payload, headers):\n return requests.request(\"GET\", url, headers=headers, data=payload)","def request(host=API_HOST, path=SEARCH_PATH, api_key=API_KEY, url_params=params):\n url_params = url_params or {}\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n headers = {\n 'Authorization': 'Bearer %s' % api_key,\n }\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n return response.json()","def api_client(request):\n\n base_url = request.config.getoption(\"--url\")\n delay = request.config.getoption(\"--delay\")\n templates = CONF.ENDPOINT_TEMPLATES\n return client.APIClient(base_url=base_url, delay=delay, templates=templates)","def request(host, path, api_key, url_params=None):\n\n url_params = url_params or {}\n\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n\n headers = {\n\n 'Authorization': 'Bearer %s' % api_key,\n\n }\n\n\n print(u'Querying {0} ...'.format(url))\n\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n\n return response.json()","def request(host, path, api_key, url_params=None):\r\n url_params = url_params or {}\r\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\r\n headers = {\r\n 'Authorization': 'Bearer %s' % api_key,\r\n }\r\n\r\n print(u'Querying {0} ...'.format(url))\r\n \r\n response = requests.request('GET', url, headers=headers, params=url_params)\r\n\r\n return response.json()","def api():\n try:\n data = json.loads(request.data)\n except:\n return jsonify({\"jsonrpc\": \"2.0\", \"error\": {\"code\": -32700, \"message\": \"Parse error\"}, \"id\": None}), 500\n return jsonify(hwi.jsonrpc(data))","def ping_missing_api(request):\r\n return _api_response(request, {\r\n 'success': False,\r\n 'message': 'The API url should be /api/v1'\r\n })","def get(self, request, format=None):\n an_apiview = [\n 'Uses HTTP methods as functions(get, post, patch, put, delete)',\n 'Is similar to traditional Django view',\n 'Give you the most control over your app logic',\n 'Is mapped manually to URLs'\n ]\n return Response({'message':'Hello!', 'an_apiview':an_apiview})","def makeApiCall(url, endpointParams, type):\r\n\r\n if type == 'POST': # post request\r\n data = requests.post(url, endpointParams)\r\n else: # get request\r\n data = requests.get(url, endpointParams)\r\n\r\n response = dict() # hold response info\r\n response['url'] = url # url we are hitting\r\n response['endpoint_params'] = endpointParams # parameters for the endpoint\r\n response['endpoint_params_pretty'] = json.dumps(endpointParams, indent=4) # pretty print for cli\r\n response['json_data'] = json.loads(data.content) # response data from the api\r\n response['json_data_pretty'] = json.dumps(response['json_data'], indent=4) # pretty print for cli\r\n\r\n return response # get and return content\r","def _execApiCall(headers, params, method_name,\r\n domain='ma.gnolia.com',\r\n urlhead='/api/rest/1/'):\r\n \r\n if 'api_key' not in params and method_name not in ['echo', 'get_key']:\r\n raise MagnoliaException('Required API Key parameter missing')\r\n conn = httplib.HTTPConnection(domain)\r\n conn.request('POST', urlhead + method_name, params, headers)\r\n return conn.getresponse()","def api(self) -> str:","def get(self,request,format = None):\n an_apiview = [\n 'Uses HTTP methods as function (get,post,patch,put,delete)',\n 'Is similar to a traditional Django View',\n 'Gives you the most control over your appliction logic',\n 'Is mapped manually to URLs'\n ]\n return Response({'message':'Hello!','an_apiview': an_apiview})","def __request(self,endpoint):\n apiRequest = requests.get(\"%s/%s\" % (self.baseurl,endpoint), \n auth=requests.auth.HTTPBasicAuth(self.api_id, self.api_secret))\n try:\n json = apiRequest.json()\n return json\n except JSONDecodeError:\n print(\"Failed to download or failed to parse JSON.\")\n print(apiRequest)\n return None","def request(host, path, api_key, url_params=None):\n url_params = url_params or {}\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n headers = {\n 'Authorization': 'Bearer %s' % api_key,\n }\n\n print(u'Querying {0} ...'.format(url))\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n return response.json()","def request(host, path, api_key, url_params=None):\n url_params = url_params or {}\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n headers = {\n 'Authorization': 'Bearer %s' % api_key,\n }\n\n print(u'Querying {0} ...'.format(url))\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n return response.json()","def call_api(payload):\n data = requests.get(weatherbit_url, params=payload)\n assert data.status_code == 200, f\"Something wrong. Error details: {data.json()['error']}\"\n assert 'error' not in data.json().keys(), f'Problem: {data.json()}'\n return data.json()","def send_api_request(self, url, **kwargs):\n\n params = self._params.copy()\n dct = {k: kwargs[k] for k in kwargs if kwargs[k] is not None}\n params.update(dct)\n\n res = requests.get(url, params=params)\n if res.status_code != 200:\n try:\n error = res.json()['error']\n except ValueError:\n error = None\n raise SwrveApiException(error, res.status_code, url, params)\n\n return res.json()","async def test_dev_fetch_api_key(client):\n params = [('username', 'iago@zulip.com')]\n headers = { \n 'Accept': 'application/json',\n }\n response = await client.request(\n method='POST',\n path='/api/v1/dev_fetch_api_key',\n headers=headers,\n params=params,\n )\n assert response.status == 200, 'Response body is : ' + (await response.read()).decode('utf-8')","def httpapi_request(client, **params) -> 'Response':\n return requests.get(\n _HTTPAPI,\n params={\n 'client': client.name,\n 'clientver': client.version,\n 'protover': 1,\n **params\n })","def view_get():\n\n return jsonify(get_dict(\"url\", \"args\", \"headers\", \"origin\"))","def _query_api(\n master_url=settings.OPENSHIFT_API['NP']['OPENSHIFT_MASTER'],\n api_token=settings.OPENSHIFT_API['NP']['API_TOKEN'],\n endpoint='/oapi/v1/buildconfigs'):\n\n openshift_api_url = 'https://' + master_url\n openshift_api_get_endpoint = openshift_api_url + endpoint\n bearer_token_header = {'Authorization': 'Bearer ' + api_token }\n\n try:\n response = requests.get(openshift_api_get_endpoint,headers=bearer_token_header, timeout=2.0)\n except requests.ConnectTimeout as e:\n logger.error(e)\n return None\n except requests.ConnectionError as e:\n logger.error(e)\n return None\n\n if not response.ok:\n logger.error(response.status_code)\n return None\n else:\n return response","def request(host, path, api_key, url_params=None):\n url_params = url_params or {}\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n headers = {\n 'Authorization': 'Bearer %s' % api_key,\n }\n\n print(u'Querying {0} ...'.format(url))\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n return response","def base_request(url_path):\n response = requests.get(settings.URL_API + url_path)\n if response.status_code != 200:\n return response\n else:\n return response.json()","def get(self, request, format=None):\n an_apiview = [\n \"User HTTp methods get, put, post, delete method\",\n \"very similar to previous Django view\",\n \"gives you more control on api logic\",\n 'Is mapped to manually to urls'\n ]\n\n return Response({'message':\"hello\", \"an_apiview\": an_apiview} )","def _public_request(self, path, querystring):\n\n url = '{}/{}?{}'.format(self.api_server, path, querystring)\n return self._request(self.HTTP_GET, url, request_type=self.PUBLIC)","def api(self, url, response_checker=default_checker.default_checker):\n return self._api_call(url, response_checker)","def GET(self, path, params={}):\n request_url = 'https://{0}:{1}/rest/{2}'.format(\n self.settings.api_host,\n self.settings.api_port,\n path\n )\n\n # Make the API request\n response = requests.get(request_url,\n auth = (self.settings.api_user, self.settings.api_password),\n verify = self.settings.verify_ssl,\n headers = self.settings.headers,\n params = params\n )\n\n # Request failed\n if not int(response.status_code) == 200:\n raise Exception('Failed to GET {0}: {1}'.format(request_url, response.json()))\n return response.json()","def cli(ctx, base_url, token, debug, watch):\n connection = ctx.obj.connection\n ctx.obj.debug = debug\n ctx.obj.watch = watch\n if debug:\n logging.basicConfig(level=logging.DEBUG)\n import httplib\n httplib.HTTPConnection.debuglevel = 1\n if base_url:\n connection.api_url = base_url\n\n if token:\n connection.credentials.token = token\n elif not connection.credentials.token:\n click.secho('Token not provided', fg='red')\n return\n if base_url:\n connection.api_url = base_url","def _api_call(self, method: str, endpoint: str, data: dict = None) -> requests.Response:\n\n headers = {\n \"Content-Type\": \"text/plain; charset=uft-8\"\n }\n\n auth = {\n \"usr\": self.user,\n \"key\": self.api_key\n }\n\n payload = {\"auth\": auth, \"data\": data}\n\n response = requests.request(method=method,\n url=self.api_url + endpoint,\n headers=headers,\n data=json.dumps(payload))\n return response","def api():\n api_routes = [\n \"/api/v1.0/beer\",\n \"/api/v1.0/breweries\",\n ]\n return render_template(\"api.html\", api_routes = api_routes)","def __apiRequest(self, url, parms={}):\n authparms = self.__addAuthParms(parms);\n request = self.http.request('GET', url, fields=authparms)\n if request.status != 200:\n raise ApiCommunicationError('Failed to retrieve data from Marvel, HTTP Status {}'.format(request.status))\n else:\n return json.loads( request.data.decode('utf-8') )","def protect_endpoint():\n pass","def test_00_api_get(self):\r\n # GET as Anonymous\r\n url = '/api/'\r\n action = 'get'\r\n self.check_limit(url, action, 'app')","def api_key(request):\r\n user_acct = request.user\r\n return _api_response(request, {\r\n 'api_key': user_acct.api_key,\r\n 'username': user_acct.username\r\n })","def request(self, verb, address, params=None, data=None):\n return BWUser.bare_request(verb=verb, address_root=self.api_url,\n address_suffix=address,\n access_token=self.token,\n params=params or dict(),\n data=data or dict())","def status_api(request):\n if request.method == 'GET':\n return JsonResponse({\n 'status': 'OK',\n 'version': __version__\n }, status=200)","def do_GET(self):\n self.http_method = 'GET'\n self.response()","def request_gateway_api(url, payload=None):\n if is_url_validated(url):\n response = requests.get(url, params=payload)\n return response\n # Logs\n logger.info('{} is not validated'.format(url))\n return None","def api_call(endpoint, params, headers):\n\n api_response = get(BASE_URL.format(endpoint=endpoint), params=params,\n headers=headers)\n\n api_response.raise_for_status()\n json_resp = api_response.json()\n\n api_response.close()\n return json_resp","def send_get(self, api_url, query=None):\n resp = requests.get(self.base_url + api_url, params=query)\n\n return resp","def url(vmanage_host,vmanage_port,api):\r\n \"\"\" function to get the url provide api endpoint \"\"\"\r\n \r\n return f\"https://{vmanage_host}:{vmanage_port}{api}\"","def _get_request(url_root,api_key,path,response_type,params, ssl_verify):\n url = _url_builder(url_root,api_key,path,params)\n content = _fetch(url, ssl_verify)\n response = _dispatch(response_type)(content)\n return response","def index():\n response = jsonify(\n {'message':'Hello, RESTful API development!'}\n )\n \n return response, 200","def index():\n # curl -k -X POST https://127.0.0.1:43210/api/v1.0 -H 'content-type: application/json' -d '{\"data\": \"exhaust\"}'\n return jsonify({'meta': {'success': True, 'code': 200}, 'result': {\"message\": request.get_json()}}), 200","def bare_request(verb, address_root, address_suffix, access_token=\"\",\n params=None, data=None):\n params = params or dict()\n data = data or dict()\n url = \"%s%s\" % (address_root, address_suffix)\n\n if access_token:\n params[\"access_token\"] = access_token\n\n try:\n if data:\n response = verb(url,\n params=params,\n data=data,\n headers={\"Content-type\": \"application/json\"})\n else:\n response = verb(url, params=params)\n response_json = response.json()\n except Exception as e:\n logger.error(\"Something was wrong getting a response from \"\n \"URL %s\" % url)\n raise exc.BrandwatchApiException(str(e))\n else:\n errors = response_json.get('errors')\n if errors:\n _raise_bw_exception(response, data, errors)\n return response_json","def api_request(method, url, **kwargs):\n if not settings.BLOCKSTORE_API_AUTH_TOKEN:\n raise ImproperlyConfigured(\"Cannot use Blockstore unless BLOCKSTORE_API_AUTH_TOKEN is set.\")\n kwargs.setdefault('headers', {})['Authorization'] = f\"Token {settings.BLOCKSTORE_API_AUTH_TOKEN}\"\n response = requests.request(method, url, **kwargs)\n if response.status_code == 404:\n raise NotFound\n response.raise_for_status()\n if response.status_code == 204:\n return None # No content\n return response.json()","def test_doGet(self) -> None:\n\n status_code = apicall.doGet(URL, self._browserheader)\n print(\"in do get:\", status_code)\n assert status_code == API_SUCCESS","def get(self, request, format=None):\n an_apiview = [\n 'Uses HTTP methods as functions (get,post,patch,put,delete)',\n 'Is similar to a traditional django view',\n 'Gives you the most control over the applicaton logic',\n 'Is mapped manually to the URLs',\n ]\n return Response({'message': 'get method', 'an_apiview': an_apiview})","def get(self, request, format=None):\n\n an_apiview= [\n 'Uses HTTP methods as functions (get, post, patch, put, delete)',\n 'Is similar to a traditional Django View',\n 'Gives you the most control over your logic',\n 'Is mapped manually to URLs',\n 'Douki mohamed',\n ]\n\n return Response({'message': 'Hello Douki!', 'an_apiview': an_apiview})","def test_GET_call_api_and_return_200Ok(client):\n\n url = '/api/v1/calls/'\n\n response = client.get(url)\n\n assert response.status_code == status.HTTP_200_OK","def call_api(\n self,\n endpoint,\n method='GET',\n payload=None,\n params=None,\n deadline=None,\n version='v1',\n service='compute'):\n assert service in ('compute', 'replicapool')\n assert endpoint.startswith('/'), endpoint\n url = 'https://www.googleapis.com/%s/%s/projects/%s%s' % (\n service, version, self._project_id, endpoint)\n return net.json_request(\n url=url,\n method=method,\n payload=payload,\n params=params,\n scopes=AUTH_SCOPES,\n service_account_key=self._service_account_key,\n deadline=30 if deadline is None else deadline)","def index():\n\n return redirect(api)","def get(self, request, format=None):\n an_apiview = [\n 'Uses HTTP methos as function (get, post, patch, put, delete)',\n 'Is similar to a traditional Django View',\n 'Gives you the most control over your application logic',\n 'Is mapped manually to URLs',\n ]\n\n return Response({'message': 'Hello', 'an_apiview': an_apiview}) # Dictionary or List only","def test_anything_else_is_accessible(api_client):\n\n assert api_client().get(\"/anything/else\").status_code == 200","def do_GET(self): # pylint:disable=invalid-name\n if not self.is_log_path_valid():\n self.report_404()\n return\n scheme = \"https\" if self.server.cert is not None else \"http\"\n resp = '<html>'\n resp += '<head>\\n'\n resp += ' <title>{0}</title>\\n'.format(self.app_name)\n resp += '</head>\\n'\n resp += '<body>\\n'\n resp += ' <center>\\n'\n resp += ' <h2>{0} is working via {1}</h2>\\n'.format(self.app_name,\n scheme.upper())\n resp += ' </center>\\n'\n resp += ' <p>Please point your APIC at:<br /><br />'\n ip_add = [(s.connect((self.client_address[0], 80)), s.getsockname()[0],\n s.close()) for s in [socket.socket(socket.AF_INET,\n socket.SOCK_DGRAM)]][0][1]\n resp += ' {0}://{1}:{2}{3}</p>'.format(scheme, ip_add,\n self.server.server_address[\n 1],\n self.path)\n resp += '</body>\\n'\n resp += '</html>'\n self.send_200_resp(resp, \"text/html\")","def ping(request):\r\n rdict = request.matchdict\r\n params = request.params\r\n username = rdict.get('username', None)\r\n api_key = params.get('api_key', None)\r\n user = UserMgr.get(username=username)\r\n # Check if user provided the correct api_key\r\n if api_key == user.api_key:\r\n return _api_response(request, {\r\n 'success': True,\r\n 'message': 'Looks good'\r\n })\r\n else:\r\n return _api_response(request, {\r\n 'success': False,\r\n 'message': 'API key is invalid.'\r\n })","def get_admin(self, path):\n req_url = self.normalize_admin_url(path)\n headers = {\"user-agent\": self.u_agent}\n res = requests.get(req_url, headers=headers, auth=self.auth, verify=False)\n if res.status_code in [400, 401, 403, 404, 406]:\n return Response(res.status_code, res)\n try:\n return Response(0, res.json())\n except ValueError:\n # The API does not appear to return valid JSON\n # It is probably not a CDMI API - this will be a problem!\n return Response(500, \"Invalid response format\")","def get_api(self):\n from geoffrey.utils import get_api\n return get_api(self.app.routes, prefix='/api')","async def get(self) -> web.Response:\n response = {\n \"status\": \"success\",\n \"Data\": \"No current tools supported\",\n }\n\n return web.json_response(data=response, status=200)","def get(self, request, format=None):\n an_apiview = [\n 'Uses HTTP methods as function (get, post, put, delete)',\n 'Is similar to a traditional Django view',\n 'Gives you the most control over you application logic',\n 'Is mapped manually to URLs',\n ]\n\n return Response({'message':'Hello', 'an_view':an_apiview})","def getAPI(self):\n return self.api_url","def probe_api():\n\n info = loads(get(url).text)\n return info","def request_external(host, path, api_key, url_params=None) -> Dict:\n url_params = url_params or {}\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\n headers = {\n 'Authorization': 'Bearer %s' % api_key,\n }\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n return response.json()","def call_api(page_num=0):\n base_url = \"http://data.sfgov.org/resource/jjew-r69b.json\"\n query_string = SoQL_query(page_num=page_num).generate_query()\n url = base_url+query_string\n response = requests.get(url)\n return response","def api_endpoint(self) -> str:\n return pulumi.get(self, \"api_endpoint\")","def live_url_request(url, arg):\n if arg == \"-m\":\n json_response = requests.get(url)\n\n elif arg == \"-l\":\n live_token= get_live_token()\n json_response = requests.get(url, headers={\"PRIVATE-TOKEN\": live_token})\n return json_response","def access_url(context, url):\n context.response = requests.get(context.coreapi_url + url)","def get(self, *args, **kwargs):\n self.request(\"get\", *args, **kwargs)","async def _api_request(self,\n method: str,\n path_url: str,\n params: Dict[str, Any] = {}) -> Dict[str, Any]:\n base_url = f\"https://{global_config_map['gateway_api_host'].value}:\" \\\n f\"{global_config_map['gateway_api_port'].value}\"\n url = f\"{base_url}/{path_url}\"\n client = await self._http_client()\n if method == \"get\":\n if len(params) > 0:\n response = await client.get(url, params=params)\n else:\n response = await client.get(url)\n elif method == \"post\":\n response = await client.post(url, data=params)\n\n parsed_response = json.loads(await response.text())\n if response.status != 200:\n err_msg = \"\"\n if \"error\" in parsed_response:\n err_msg = f\" Message: {parsed_response['error']}\"\n raise IOError(f\"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}\")\n if \"error\" in parsed_response:\n raise Exception(f\"Error: {parsed_response['error']}\")\n\n return parsed_response","def home(request):\n response_status = {'text': \"API is up\"}\n return JsonResponse(response_status, status=200)","def opt_engine_rest_api():\n request_json = request.get_json()\n return process_request(request_json)","def _do_call(cls, method, url, params={}):\n headers = {\n 'User-Agent': 'py-retain/' + __version__,\n 'content-type': 'application/json'\n }\n try:\n r = cls.request_map[method.lower()]\n except KeyError:\n raise ValueError(\"Unknow HTTP Method\")\n response = r(\n url,\n auth=(cls.app_id, cls.api_key),\n headers=headers,\n data=json.dumps(params),\n timeout=cls.timeout)\n return response.json()","def api_call(url, method, debug, **kwargs):\n resp = None\n attempt = 0\n maxattempts = 3\n req = Request(method.upper(), url, **kwargs)\n\n if debug:\n print(\"DEBUG: Request ({}) {}\".format(method.upper(), url))\n\n while True:\n try:\n attempt += 1\n resp = Session().send(\n Session().prepare_request(req), verify=True)\n resp.raise_for_status()\n break\n except (HTTPError, ConnectionError, Timeout) as ex:\n if attempt >= maxattempts:\n abort(ex.message)\n else:\n time.sleep(1)\n continue\n except RequestException as ex:\n abort(ex.message)\n\n if resp is not None:\n return resp\n else:\n abort(\"Error making API call to URL: \" % url)","def call_api_endpoint(url, data):\n try:\n \n req = urllib2.Request(url, data, {'Content-Type': 'application/json'})\n \n f = urllib2.urlopen(req)\n response = f.read()\n f.close()\n return response\n\n \n except urllib2.HTTPError, e:\n if e.code == 400:\n return -1","def http_request(endpoint, data, method='POST'):\n url = BASE_API + endpoint\n data['authkey'] = AUTH_KEY\n\n response = requests.request(method, url=url, data=data, timeout=300, verify=VERIFY)\n if response.status_code == 200:\n try:\n return response.json()\n except Exception as e:\n return_error('Response JSON decoding failed due to {}'.format(str(e)))\n\n else:\n return_error('API Returned, {}:{}'.format(response.status_code, response.reason))","def _issue_api_request(self, resource_url, method='get', body=None,\n sensitive=False, conflict_ok=False):\n host = self.configuration.san_ip\n port = self.configuration.datera_api_port\n api_token = self.datera_api_token\n api_version = self.configuration.datera_api_version\n\n payload = json.dumps(body, ensure_ascii=False)\n payload.encode('utf-8')\n\n header = {'Content-Type': 'application/json; charset=utf-8',\n 'Datera-Driver': 'OpenStack-Cinder-{}'.format(self.VERSION)}\n\n protocol = 'http'\n if self.configuration.driver_use_ssl:\n protocol = 'https'\n\n if api_token:\n header['Auth-Token'] = api_token\n\n client_cert = self.configuration.driver_client_cert\n client_cert_key = self.configuration.driver_client_cert_key\n cert_data = None\n\n if client_cert:\n protocol = 'https'\n cert_data = (client_cert, client_cert_key)\n\n connection_string = '%s://%s:%s/v%s/%s' % (protocol, host, port,\n api_version, resource_url)\n\n response = self._request(connection_string,\n method,\n payload,\n header,\n cert_data)\n\n data = response.json()\n\n if not response.ok:\n self._handle_bad_status(response,\n connection_string,\n method,\n payload,\n header,\n cert_data,\n conflict_ok=conflict_ok)\n\n return data","def _api_call(self, api_call, method=\"GET\", payload=None):\n # type: (str, str, Dict[str, str]) -> requests.Response\n\n headers = {\n \"accept\" : \"application/json\",\n \"Authorization\" : f\"Bearer {self.access_token}\",\n \"x-ibm-client-id\" : self.client_id,\n }\n self.__log.debug(headers)\n api_url = f\"{self.base_url}/{api_call}\"\n\n self.__log.debug(f\"Calling {api_url} with method {method}\")\n if method == \"GET\":\n resp = requests.get(api_url, headers=headers)\n elif method == \"POST\":\n resp = requests.post(api_url, headers=header, data=payload)\n elif method == \"PUT\":\n resp = requests.put(api_url, headers=header, data=payload)\n elif method == \"DELETE\":\n resp = requests.delete(api_url, headers=headers)\n elif method == \"HEAD\":\n resp = requests.head(api_url, headers=headers)\n elif method == \"OPTIONS\":\n resp = requests.options(api_url, headers=headers)\n else:\n raise Exception(f\"The method {method} is unsupported\")\n \n if (resp.ok):\n return resp\n else:\n self.__log.debug(resp.status_code)\n self.__log.debug(resp.text)\n return resp","def post(self):\n\n if config.logging:\n logfile.info(\"Request to /rest/broadsoft recieved\")\n if config.verbose:\n logconsole.info(\"Request to /rest/broadsoft recieved\")\n\n # Ensure that the user has sent a jwt to the endpoint.\n try:\n verify_jwt_in_request()\n except Exception as error:\n return make_response(\"<error>Unauthorized</error>\", 401)\n\n # Create a user object from the JWT identity object.\n user = User().from_identity(get_jwt_identity())\n\n # Check if a user was able to be created.\n if user is None:\n return \"<ErrorInfo><message>Not logged in</message><error>true</error></ErrorInfo>\", 401\n\n # Create a request parser to parse arguments\n parser = reqparse.RequestParser()\n\n # Configure endpoint arguments.\n parser.add_argument(\n name='endpoint',\n help='Missing the required broadsoft endpoint to connect to.',\n required=True)\n\n parser.add_argument(\n name='data',\n type=str,\n help='JSON data needs to be a string')\n\n parser.add_argument(\n name='method',\n help='Missing method type. ex) method:GET/PUT/POST...',\n required=True)\n\n # Check if the arguments passed were valid.\n try:\n args = parser.parse_args()\n except reqparse.exceptions.BadRequest as e:\n # If there are any errors, ensure that login=False is sent.\n message = \"<error>true</error>\"\n return message, 400\n\n # Get the data sent from the request.\n url = self.url + args['endpoint'].replace(\"<user>\", user.username)\n data = \"\"\n method = args['method']\n\n # Check if any data was sent\n if(args['data']):\n data = args['data']\n\n if config.logging:\n logfile.info(\"Sending data: \" + method + \" \" + url + \" \" + data)\n if config.verbose:\n logconsole.info(\"Sending data: \" + method + \" \" + url + \" \" + data)\n\n # Get the user's broadsoft token from the JWT and send a request to broadsoft.\n response = Proxy().to_broadsoft(method, url, data, user)\n\n # Check if a valid response was returned.\n if response.status_code == 200 or response.status_code == 201:\n\n # Output a response to the console and log files.\n if config.logging:\n logfile.info(\"Recieved:\" + str(response.status_code) + \" \" + str(response.content) if response.content else \"Recieved: \" + str(response.status_code))\n if config.verbose:\n logconsole.info(\"Recieved:\" + str(response.status_code) + \" \" + str(response.content) if response.content else \"Recieved: \" + str(response.status_code))\n\n # Format a response\n if response.content:\n return make_response(str(response.content.decode('ISO-8859-1')), 200)\n else:\n return make_response(\"\", 200)\n else:\n if config.logging:\n logfile.info(\"Recieved:\" + str(response.status_code) + \" \" + response.content.decode('ISO-8859-1') if response.content else \"\")\n if config.verbose:\n logconsole.info(\"Recieved:\" + str(response.status_code) + \" \" + response.content.decode('ISO-8859-1') if response.content else \"\")\n\n if response.content:\n return make_response(response.content.decode('ISO-8859-1'), response.status_code)\n else:\n return make_response(\"\", response.status_code)","def get():\n return jsonify(baby='knight2'), 200","def make_get_request(client, endpoint):\n return client.get(endpoint)","def api_req(dev, api_call):\r\n import xmltodict\r\n import logging\r\n try:\r\n r = requests.get(dev + ':8060' + api_call, timeout=5)\r\n except Exception as exc:\r\n response = [\"ERR\", exc]\r\n return response[0]\r\n except ConnectionError as connerr:\r\n response = [\"ERR\", connerr]\r\n return response[0]\r\n except TimeoutError as toerr:\r\n response = [\"ERR\", toerr]\r\n return response[0], toerr\r\n r_code = r.status_code\r\n if r_code == 200:\r\n print(\"REQUEST WAS A SUCCESS. DEVICE RETURNED: {} \".format(str(r)))\r\n r2 = r.text\r\n response = xmltodict.parse(r2, xml_attribs=False)\r\n return response\r\n else:\r\n response = \"UnknownERR\"\r\n dev.state(DISABLED)\r\n return msg_box(response)","def request(host, path, api_key, url_params=None):\n url_params = url_params or {}\n url = '{0}{1}'.format(host, path)\n headers = {\n 'x-rapidapi-host': \"us-restaurant-menus.p.rapidapi.com\",\n 'x-rapidapi-key': api_key,\n }\n\n print(u'Querying {0} ...'.format(url))\n\n response = requests.request('GET', url, headers=headers, params=url_params)\n\n data = json.loads(response.text)\n if 'error' in data:\n raise Exception(str(data))\n return data","def cci_api():\n\n\n\t\t\treturn render_template( 'api.html' )","def get_api(self):\n from geoffrey.utils import get_api\n return get_api(self.app.routes, prefix=\"/\")","def test_GET(self):\n if not self.url:\n return\n response = self.client.get(self.url, {}, format='json')\n self.assertIn(response.status_code, [status.HTTP_405_METHOD_NOT_ALLOWED,\n status.HTTP_401_UNAUTHORIZED])","def _get_good_request(self):\r\n prms = {\r\n 'url': u'http://google.com',\r\n 'description': u'This is my google desc',\r\n 'extended': u'And some extended notes about it in full form',\r\n 'tags': u'python search',\r\n }\r\n\r\n req_params = urllib.urlencode(prms)\r\n res = self.app.post(\r\n '/api/v1/admin/bmark?api_key={0}'.format(self.api_key),\r\n params=req_params,\r\n )\r\n return res","def request(self, apiurl, caller, mode=\"get\", data=None):\n\n token = self._getToken(caller)\n # print(self._tokenstore)\n headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': f'Bearer {token}'}\n if mode == \"get\":\n return self._oauth.getRequester().get(self._baseurl + apiurl, headers=headers)\n elif mode == \"post\":\n return self._oauth.getRequester().post(self._baseurl + apiurl, data=data, headers=headers)\n elif mode == \"delete\":\n return self._oauth.getRequester().delete(self._baseurl + apiurl, headers=headers)","def api_get(self, name):\n try:\n r = self._get(['apis', name])\n except requests.HTTPError:\n return None\n else:\n return r"],"string":"[\n \"def api_call():\\n\\tresponse = requests.get(URL_API)\\n\\treturn response\",\n \"def call_api(url):\\n\\n req = requests.get(url)\\n return req\",\n \"def call_api(url):\\n\\n req = requests.get(url)\\n return req\",\n \"def requester(get_args: dict) -> dict:\\n get_args.update(dict(apikey = apikey))\\n response = requests.get(URL, params = get_args)\\n return response.json()\",\n \"def _make_api_call(url, params=None):\\n if params is None:\\n params = {}\\n\\n # params['apikey'] = CONFIG.BIOPORTAL_API_KEY\\n params['apikey'] = \\\"8316a8aa-ff8e-4d6e-aa95-faeabfc72d2a\\\"\\n return requests.get(url, params=params)\",\n \"def api():\\n\\treturn \\\"The API call\\\"\",\n \"def api_endpoint():\\n return 'localhost'\",\n \"def request_endpoints(self):\\n\\n endpoints_url = self.std[\\\"api\\\"]\\n endpoints_paramd = {\\n \\\"access_token\\\": self.std[\\\"access_token\\\"]\\n }\\n\\n endpoints_response = requests.get(url=endpoints_url, params=endpoints_paramd)\\n print endpoints_response\\n self.endpointd = endpoints_response.json()[0]\",\n \"def request(host, path, api_key, url_params=None):\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n headers = {\\n 'Authorization': 'Bearer %s' % api_key,\\n }\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n return response.json()\",\n \"def get():\\n return jsonify({'doctor': 'Doctor API'}), 200\",\n \"def get_rest_call(api_url, username, password):\\n response = requests.get(api_url,\\n auth=HTTPBasicAuth(username, password),\\n verify=False,\\n timeout=4)\\n return response\",\n \"def _api_call(self, **kwargs):\\n params = {\\n 'format': 'json',\\n }\\n params.update(kwargs)\\n r = requests.get(self.api_base_url, params=params)\\n return r.json()\",\n \"def get_call_api(url, payload, headers):\\n return requests.request(\\\"GET\\\", url, headers=headers, data=payload)\",\n \"def request(host=API_HOST, path=SEARCH_PATH, api_key=API_KEY, url_params=params):\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n headers = {\\n 'Authorization': 'Bearer %s' % api_key,\\n }\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n return response.json()\",\n \"def api_client(request):\\n\\n base_url = request.config.getoption(\\\"--url\\\")\\n delay = request.config.getoption(\\\"--delay\\\")\\n templates = CONF.ENDPOINT_TEMPLATES\\n return client.APIClient(base_url=base_url, delay=delay, templates=templates)\",\n \"def request(host, path, api_key, url_params=None):\\n\\n url_params = url_params or {}\\n\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n\\n headers = {\\n\\n 'Authorization': 'Bearer %s' % api_key,\\n\\n }\\n\\n\\n print(u'Querying {0} ...'.format(url))\\n\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n\\n return response.json()\",\n \"def request(host, path, api_key, url_params=None):\\r\\n url_params = url_params or {}\\r\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\r\\n headers = {\\r\\n 'Authorization': 'Bearer %s' % api_key,\\r\\n }\\r\\n\\r\\n print(u'Querying {0} ...'.format(url))\\r\\n \\r\\n response = requests.request('GET', url, headers=headers, params=url_params)\\r\\n\\r\\n return response.json()\",\n \"def api():\\n try:\\n data = json.loads(request.data)\\n except:\\n return jsonify({\\\"jsonrpc\\\": \\\"2.0\\\", \\\"error\\\": {\\\"code\\\": -32700, \\\"message\\\": \\\"Parse error\\\"}, \\\"id\\\": None}), 500\\n return jsonify(hwi.jsonrpc(data))\",\n \"def ping_missing_api(request):\\r\\n return _api_response(request, {\\r\\n 'success': False,\\r\\n 'message': 'The API url should be /api/v1'\\r\\n })\",\n \"def get(self, request, format=None):\\n an_apiview = [\\n 'Uses HTTP methods as functions(get, post, patch, put, delete)',\\n 'Is similar to traditional Django view',\\n 'Give you the most control over your app logic',\\n 'Is mapped manually to URLs'\\n ]\\n return Response({'message':'Hello!', 'an_apiview':an_apiview})\",\n \"def makeApiCall(url, endpointParams, type):\\r\\n\\r\\n if type == 'POST': # post request\\r\\n data = requests.post(url, endpointParams)\\r\\n else: # get request\\r\\n data = requests.get(url, endpointParams)\\r\\n\\r\\n response = dict() # hold response info\\r\\n response['url'] = url # url we are hitting\\r\\n response['endpoint_params'] = endpointParams # parameters for the endpoint\\r\\n response['endpoint_params_pretty'] = json.dumps(endpointParams, indent=4) # pretty print for cli\\r\\n response['json_data'] = json.loads(data.content) # response data from the api\\r\\n response['json_data_pretty'] = json.dumps(response['json_data'], indent=4) # pretty print for cli\\r\\n\\r\\n return response # get and return content\\r\",\n \"def _execApiCall(headers, params, method_name,\\r\\n domain='ma.gnolia.com',\\r\\n urlhead='/api/rest/1/'):\\r\\n \\r\\n if 'api_key' not in params and method_name not in ['echo', 'get_key']:\\r\\n raise MagnoliaException('Required API Key parameter missing')\\r\\n conn = httplib.HTTPConnection(domain)\\r\\n conn.request('POST', urlhead + method_name, params, headers)\\r\\n return conn.getresponse()\",\n \"def api(self) -> str:\",\n \"def get(self,request,format = None):\\n an_apiview = [\\n 'Uses HTTP methods as function (get,post,patch,put,delete)',\\n 'Is similar to a traditional Django View',\\n 'Gives you the most control over your appliction logic',\\n 'Is mapped manually to URLs'\\n ]\\n return Response({'message':'Hello!','an_apiview': an_apiview})\",\n \"def __request(self,endpoint):\\n apiRequest = requests.get(\\\"%s/%s\\\" % (self.baseurl,endpoint), \\n auth=requests.auth.HTTPBasicAuth(self.api_id, self.api_secret))\\n try:\\n json = apiRequest.json()\\n return json\\n except JSONDecodeError:\\n print(\\\"Failed to download or failed to parse JSON.\\\")\\n print(apiRequest)\\n return None\",\n \"def request(host, path, api_key, url_params=None):\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n headers = {\\n 'Authorization': 'Bearer %s' % api_key,\\n }\\n\\n print(u'Querying {0} ...'.format(url))\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n return response.json()\",\n \"def request(host, path, api_key, url_params=None):\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n headers = {\\n 'Authorization': 'Bearer %s' % api_key,\\n }\\n\\n print(u'Querying {0} ...'.format(url))\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n return response.json()\",\n \"def call_api(payload):\\n data = requests.get(weatherbit_url, params=payload)\\n assert data.status_code == 200, f\\\"Something wrong. Error details: {data.json()['error']}\\\"\\n assert 'error' not in data.json().keys(), f'Problem: {data.json()}'\\n return data.json()\",\n \"def send_api_request(self, url, **kwargs):\\n\\n params = self._params.copy()\\n dct = {k: kwargs[k] for k in kwargs if kwargs[k] is not None}\\n params.update(dct)\\n\\n res = requests.get(url, params=params)\\n if res.status_code != 200:\\n try:\\n error = res.json()['error']\\n except ValueError:\\n error = None\\n raise SwrveApiException(error, res.status_code, url, params)\\n\\n return res.json()\",\n \"async def test_dev_fetch_api_key(client):\\n params = [('username', 'iago@zulip.com')]\\n headers = { \\n 'Accept': 'application/json',\\n }\\n response = await client.request(\\n method='POST',\\n path='/api/v1/dev_fetch_api_key',\\n headers=headers,\\n params=params,\\n )\\n assert response.status == 200, 'Response body is : ' + (await response.read()).decode('utf-8')\",\n \"def httpapi_request(client, **params) -> 'Response':\\n return requests.get(\\n _HTTPAPI,\\n params={\\n 'client': client.name,\\n 'clientver': client.version,\\n 'protover': 1,\\n **params\\n })\",\n \"def view_get():\\n\\n return jsonify(get_dict(\\\"url\\\", \\\"args\\\", \\\"headers\\\", \\\"origin\\\"))\",\n \"def _query_api(\\n master_url=settings.OPENSHIFT_API['NP']['OPENSHIFT_MASTER'],\\n api_token=settings.OPENSHIFT_API['NP']['API_TOKEN'],\\n endpoint='/oapi/v1/buildconfigs'):\\n\\n openshift_api_url = 'https://' + master_url\\n openshift_api_get_endpoint = openshift_api_url + endpoint\\n bearer_token_header = {'Authorization': 'Bearer ' + api_token }\\n\\n try:\\n response = requests.get(openshift_api_get_endpoint,headers=bearer_token_header, timeout=2.0)\\n except requests.ConnectTimeout as e:\\n logger.error(e)\\n return None\\n except requests.ConnectionError as e:\\n logger.error(e)\\n return None\\n\\n if not response.ok:\\n logger.error(response.status_code)\\n return None\\n else:\\n return response\",\n \"def request(host, path, api_key, url_params=None):\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n headers = {\\n 'Authorization': 'Bearer %s' % api_key,\\n }\\n\\n print(u'Querying {0} ...'.format(url))\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n return response\",\n \"def base_request(url_path):\\n response = requests.get(settings.URL_API + url_path)\\n if response.status_code != 200:\\n return response\\n else:\\n return response.json()\",\n \"def get(self, request, format=None):\\n an_apiview = [\\n \\\"User HTTp methods get, put, post, delete method\\\",\\n \\\"very similar to previous Django view\\\",\\n \\\"gives you more control on api logic\\\",\\n 'Is mapped to manually to urls'\\n ]\\n\\n return Response({'message':\\\"hello\\\", \\\"an_apiview\\\": an_apiview} )\",\n \"def _public_request(self, path, querystring):\\n\\n url = '{}/{}?{}'.format(self.api_server, path, querystring)\\n return self._request(self.HTTP_GET, url, request_type=self.PUBLIC)\",\n \"def api(self, url, response_checker=default_checker.default_checker):\\n return self._api_call(url, response_checker)\",\n \"def GET(self, path, params={}):\\n request_url = 'https://{0}:{1}/rest/{2}'.format(\\n self.settings.api_host,\\n self.settings.api_port,\\n path\\n )\\n\\n # Make the API request\\n response = requests.get(request_url,\\n auth = (self.settings.api_user, self.settings.api_password),\\n verify = self.settings.verify_ssl,\\n headers = self.settings.headers,\\n params = params\\n )\\n\\n # Request failed\\n if not int(response.status_code) == 200:\\n raise Exception('Failed to GET {0}: {1}'.format(request_url, response.json()))\\n return response.json()\",\n \"def cli(ctx, base_url, token, debug, watch):\\n connection = ctx.obj.connection\\n ctx.obj.debug = debug\\n ctx.obj.watch = watch\\n if debug:\\n logging.basicConfig(level=logging.DEBUG)\\n import httplib\\n httplib.HTTPConnection.debuglevel = 1\\n if base_url:\\n connection.api_url = base_url\\n\\n if token:\\n connection.credentials.token = token\\n elif not connection.credentials.token:\\n click.secho('Token not provided', fg='red')\\n return\\n if base_url:\\n connection.api_url = base_url\",\n \"def _api_call(self, method: str, endpoint: str, data: dict = None) -> requests.Response:\\n\\n headers = {\\n \\\"Content-Type\\\": \\\"text/plain; charset=uft-8\\\"\\n }\\n\\n auth = {\\n \\\"usr\\\": self.user,\\n \\\"key\\\": self.api_key\\n }\\n\\n payload = {\\\"auth\\\": auth, \\\"data\\\": data}\\n\\n response = requests.request(method=method,\\n url=self.api_url + endpoint,\\n headers=headers,\\n data=json.dumps(payload))\\n return response\",\n \"def api():\\n api_routes = [\\n \\\"/api/v1.0/beer\\\",\\n \\\"/api/v1.0/breweries\\\",\\n ]\\n return render_template(\\\"api.html\\\", api_routes = api_routes)\",\n \"def __apiRequest(self, url, parms={}):\\n authparms = self.__addAuthParms(parms);\\n request = self.http.request('GET', url, fields=authparms)\\n if request.status != 200:\\n raise ApiCommunicationError('Failed to retrieve data from Marvel, HTTP Status {}'.format(request.status))\\n else:\\n return json.loads( request.data.decode('utf-8') )\",\n \"def protect_endpoint():\\n pass\",\n \"def test_00_api_get(self):\\r\\n # GET as Anonymous\\r\\n url = '/api/'\\r\\n action = 'get'\\r\\n self.check_limit(url, action, 'app')\",\n \"def api_key(request):\\r\\n user_acct = request.user\\r\\n return _api_response(request, {\\r\\n 'api_key': user_acct.api_key,\\r\\n 'username': user_acct.username\\r\\n })\",\n \"def request(self, verb, address, params=None, data=None):\\n return BWUser.bare_request(verb=verb, address_root=self.api_url,\\n address_suffix=address,\\n access_token=self.token,\\n params=params or dict(),\\n data=data or dict())\",\n \"def status_api(request):\\n if request.method == 'GET':\\n return JsonResponse({\\n 'status': 'OK',\\n 'version': __version__\\n }, status=200)\",\n \"def do_GET(self):\\n self.http_method = 'GET'\\n self.response()\",\n \"def request_gateway_api(url, payload=None):\\n if is_url_validated(url):\\n response = requests.get(url, params=payload)\\n return response\\n # Logs\\n logger.info('{} is not validated'.format(url))\\n return None\",\n \"def api_call(endpoint, params, headers):\\n\\n api_response = get(BASE_URL.format(endpoint=endpoint), params=params,\\n headers=headers)\\n\\n api_response.raise_for_status()\\n json_resp = api_response.json()\\n\\n api_response.close()\\n return json_resp\",\n \"def send_get(self, api_url, query=None):\\n resp = requests.get(self.base_url + api_url, params=query)\\n\\n return resp\",\n \"def url(vmanage_host,vmanage_port,api):\\r\\n \\\"\\\"\\\" function to get the url provide api endpoint \\\"\\\"\\\"\\r\\n \\r\\n return f\\\"https://{vmanage_host}:{vmanage_port}{api}\\\"\",\n \"def _get_request(url_root,api_key,path,response_type,params, ssl_verify):\\n url = _url_builder(url_root,api_key,path,params)\\n content = _fetch(url, ssl_verify)\\n response = _dispatch(response_type)(content)\\n return response\",\n \"def index():\\n response = jsonify(\\n {'message':'Hello, RESTful API development!'}\\n )\\n \\n return response, 200\",\n \"def index():\\n # curl -k -X POST https://127.0.0.1:43210/api/v1.0 -H 'content-type: application/json' -d '{\\\"data\\\": \\\"exhaust\\\"}'\\n return jsonify({'meta': {'success': True, 'code': 200}, 'result': {\\\"message\\\": request.get_json()}}), 200\",\n \"def bare_request(verb, address_root, address_suffix, access_token=\\\"\\\",\\n params=None, data=None):\\n params = params or dict()\\n data = data or dict()\\n url = \\\"%s%s\\\" % (address_root, address_suffix)\\n\\n if access_token:\\n params[\\\"access_token\\\"] = access_token\\n\\n try:\\n if data:\\n response = verb(url,\\n params=params,\\n data=data,\\n headers={\\\"Content-type\\\": \\\"application/json\\\"})\\n else:\\n response = verb(url, params=params)\\n response_json = response.json()\\n except Exception as e:\\n logger.error(\\\"Something was wrong getting a response from \\\"\\n \\\"URL %s\\\" % url)\\n raise exc.BrandwatchApiException(str(e))\\n else:\\n errors = response_json.get('errors')\\n if errors:\\n _raise_bw_exception(response, data, errors)\\n return response_json\",\n \"def api_request(method, url, **kwargs):\\n if not settings.BLOCKSTORE_API_AUTH_TOKEN:\\n raise ImproperlyConfigured(\\\"Cannot use Blockstore unless BLOCKSTORE_API_AUTH_TOKEN is set.\\\")\\n kwargs.setdefault('headers', {})['Authorization'] = f\\\"Token {settings.BLOCKSTORE_API_AUTH_TOKEN}\\\"\\n response = requests.request(method, url, **kwargs)\\n if response.status_code == 404:\\n raise NotFound\\n response.raise_for_status()\\n if response.status_code == 204:\\n return None # No content\\n return response.json()\",\n \"def test_doGet(self) -> None:\\n\\n status_code = apicall.doGet(URL, self._browserheader)\\n print(\\\"in do get:\\\", status_code)\\n assert status_code == API_SUCCESS\",\n \"def get(self, request, format=None):\\n an_apiview = [\\n 'Uses HTTP methods as functions (get,post,patch,put,delete)',\\n 'Is similar to a traditional django view',\\n 'Gives you the most control over the applicaton logic',\\n 'Is mapped manually to the URLs',\\n ]\\n return Response({'message': 'get method', 'an_apiview': an_apiview})\",\n \"def get(self, request, format=None):\\n\\n an_apiview= [\\n 'Uses HTTP methods as functions (get, post, patch, put, delete)',\\n 'Is similar to a traditional Django View',\\n 'Gives you the most control over your logic',\\n 'Is mapped manually to URLs',\\n 'Douki mohamed',\\n ]\\n\\n return Response({'message': 'Hello Douki!', 'an_apiview': an_apiview})\",\n \"def test_GET_call_api_and_return_200Ok(client):\\n\\n url = '/api/v1/calls/'\\n\\n response = client.get(url)\\n\\n assert response.status_code == status.HTTP_200_OK\",\n \"def call_api(\\n self,\\n endpoint,\\n method='GET',\\n payload=None,\\n params=None,\\n deadline=None,\\n version='v1',\\n service='compute'):\\n assert service in ('compute', 'replicapool')\\n assert endpoint.startswith('/'), endpoint\\n url = 'https://www.googleapis.com/%s/%s/projects/%s%s' % (\\n service, version, self._project_id, endpoint)\\n return net.json_request(\\n url=url,\\n method=method,\\n payload=payload,\\n params=params,\\n scopes=AUTH_SCOPES,\\n service_account_key=self._service_account_key,\\n deadline=30 if deadline is None else deadline)\",\n \"def index():\\n\\n return redirect(api)\",\n \"def get(self, request, format=None):\\n an_apiview = [\\n 'Uses HTTP methos as function (get, post, patch, put, delete)',\\n 'Is similar to a traditional Django View',\\n 'Gives you the most control over your application logic',\\n 'Is mapped manually to URLs',\\n ]\\n\\n return Response({'message': 'Hello', 'an_apiview': an_apiview}) # Dictionary or List only\",\n \"def test_anything_else_is_accessible(api_client):\\n\\n assert api_client().get(\\\"/anything/else\\\").status_code == 200\",\n \"def do_GET(self): # pylint:disable=invalid-name\\n if not self.is_log_path_valid():\\n self.report_404()\\n return\\n scheme = \\\"https\\\" if self.server.cert is not None else \\\"http\\\"\\n resp = '<html>'\\n resp += '<head>\\\\n'\\n resp += ' <title>{0}</title>\\\\n'.format(self.app_name)\\n resp += '</head>\\\\n'\\n resp += '<body>\\\\n'\\n resp += ' <center>\\\\n'\\n resp += ' <h2>{0} is working via {1}</h2>\\\\n'.format(self.app_name,\\n scheme.upper())\\n resp += ' </center>\\\\n'\\n resp += ' <p>Please point your APIC at:<br /><br />'\\n ip_add = [(s.connect((self.client_address[0], 80)), s.getsockname()[0],\\n s.close()) for s in [socket.socket(socket.AF_INET,\\n socket.SOCK_DGRAM)]][0][1]\\n resp += ' {0}://{1}:{2}{3}</p>'.format(scheme, ip_add,\\n self.server.server_address[\\n 1],\\n self.path)\\n resp += '</body>\\\\n'\\n resp += '</html>'\\n self.send_200_resp(resp, \\\"text/html\\\")\",\n \"def ping(request):\\r\\n rdict = request.matchdict\\r\\n params = request.params\\r\\n username = rdict.get('username', None)\\r\\n api_key = params.get('api_key', None)\\r\\n user = UserMgr.get(username=username)\\r\\n # Check if user provided the correct api_key\\r\\n if api_key == user.api_key:\\r\\n return _api_response(request, {\\r\\n 'success': True,\\r\\n 'message': 'Looks good'\\r\\n })\\r\\n else:\\r\\n return _api_response(request, {\\r\\n 'success': False,\\r\\n 'message': 'API key is invalid.'\\r\\n })\",\n \"def get_admin(self, path):\\n req_url = self.normalize_admin_url(path)\\n headers = {\\\"user-agent\\\": self.u_agent}\\n res = requests.get(req_url, headers=headers, auth=self.auth, verify=False)\\n if res.status_code in [400, 401, 403, 404, 406]:\\n return Response(res.status_code, res)\\n try:\\n return Response(0, res.json())\\n except ValueError:\\n # The API does not appear to return valid JSON\\n # It is probably not a CDMI API - this will be a problem!\\n return Response(500, \\\"Invalid response format\\\")\",\n \"def get_api(self):\\n from geoffrey.utils import get_api\\n return get_api(self.app.routes, prefix='/api')\",\n \"async def get(self) -> web.Response:\\n response = {\\n \\\"status\\\": \\\"success\\\",\\n \\\"Data\\\": \\\"No current tools supported\\\",\\n }\\n\\n return web.json_response(data=response, status=200)\",\n \"def get(self, request, format=None):\\n an_apiview = [\\n 'Uses HTTP methods as function (get, post, put, delete)',\\n 'Is similar to a traditional Django view',\\n 'Gives you the most control over you application logic',\\n 'Is mapped manually to URLs',\\n ]\\n\\n return Response({'message':'Hello', 'an_view':an_apiview})\",\n \"def getAPI(self):\\n return self.api_url\",\n \"def probe_api():\\n\\n info = loads(get(url).text)\\n return info\",\n \"def request_external(host, path, api_key, url_params=None) -> Dict:\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, quote(path.encode('utf8')))\\n headers = {\\n 'Authorization': 'Bearer %s' % api_key,\\n }\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n return response.json()\",\n \"def call_api(page_num=0):\\n base_url = \\\"http://data.sfgov.org/resource/jjew-r69b.json\\\"\\n query_string = SoQL_query(page_num=page_num).generate_query()\\n url = base_url+query_string\\n response = requests.get(url)\\n return response\",\n \"def api_endpoint(self) -> str:\\n return pulumi.get(self, \\\"api_endpoint\\\")\",\n \"def live_url_request(url, arg):\\n if arg == \\\"-m\\\":\\n json_response = requests.get(url)\\n\\n elif arg == \\\"-l\\\":\\n live_token= get_live_token()\\n json_response = requests.get(url, headers={\\\"PRIVATE-TOKEN\\\": live_token})\\n return json_response\",\n \"def access_url(context, url):\\n context.response = requests.get(context.coreapi_url + url)\",\n \"def get(self, *args, **kwargs):\\n self.request(\\\"get\\\", *args, **kwargs)\",\n \"async def _api_request(self,\\n method: str,\\n path_url: str,\\n params: Dict[str, Any] = {}) -> Dict[str, Any]:\\n base_url = f\\\"https://{global_config_map['gateway_api_host'].value}:\\\" \\\\\\n f\\\"{global_config_map['gateway_api_port'].value}\\\"\\n url = f\\\"{base_url}/{path_url}\\\"\\n client = await self._http_client()\\n if method == \\\"get\\\":\\n if len(params) > 0:\\n response = await client.get(url, params=params)\\n else:\\n response = await client.get(url)\\n elif method == \\\"post\\\":\\n response = await client.post(url, data=params)\\n\\n parsed_response = json.loads(await response.text())\\n if response.status != 200:\\n err_msg = \\\"\\\"\\n if \\\"error\\\" in parsed_response:\\n err_msg = f\\\" Message: {parsed_response['error']}\\\"\\n raise IOError(f\\\"Error fetching data from {url}. HTTP status is {response.status}.{err_msg}\\\")\\n if \\\"error\\\" in parsed_response:\\n raise Exception(f\\\"Error: {parsed_response['error']}\\\")\\n\\n return parsed_response\",\n \"def home(request):\\n response_status = {'text': \\\"API is up\\\"}\\n return JsonResponse(response_status, status=200)\",\n \"def opt_engine_rest_api():\\n request_json = request.get_json()\\n return process_request(request_json)\",\n \"def _do_call(cls, method, url, params={}):\\n headers = {\\n 'User-Agent': 'py-retain/' + __version__,\\n 'content-type': 'application/json'\\n }\\n try:\\n r = cls.request_map[method.lower()]\\n except KeyError:\\n raise ValueError(\\\"Unknow HTTP Method\\\")\\n response = r(\\n url,\\n auth=(cls.app_id, cls.api_key),\\n headers=headers,\\n data=json.dumps(params),\\n timeout=cls.timeout)\\n return response.json()\",\n \"def api_call(url, method, debug, **kwargs):\\n resp = None\\n attempt = 0\\n maxattempts = 3\\n req = Request(method.upper(), url, **kwargs)\\n\\n if debug:\\n print(\\\"DEBUG: Request ({}) {}\\\".format(method.upper(), url))\\n\\n while True:\\n try:\\n attempt += 1\\n resp = Session().send(\\n Session().prepare_request(req), verify=True)\\n resp.raise_for_status()\\n break\\n except (HTTPError, ConnectionError, Timeout) as ex:\\n if attempt >= maxattempts:\\n abort(ex.message)\\n else:\\n time.sleep(1)\\n continue\\n except RequestException as ex:\\n abort(ex.message)\\n\\n if resp is not None:\\n return resp\\n else:\\n abort(\\\"Error making API call to URL: \\\" % url)\",\n \"def call_api_endpoint(url, data):\\n try:\\n \\n req = urllib2.Request(url, data, {'Content-Type': 'application/json'})\\n \\n f = urllib2.urlopen(req)\\n response = f.read()\\n f.close()\\n return response\\n\\n \\n except urllib2.HTTPError, e:\\n if e.code == 400:\\n return -1\",\n \"def http_request(endpoint, data, method='POST'):\\n url = BASE_API + endpoint\\n data['authkey'] = AUTH_KEY\\n\\n response = requests.request(method, url=url, data=data, timeout=300, verify=VERIFY)\\n if response.status_code == 200:\\n try:\\n return response.json()\\n except Exception as e:\\n return_error('Response JSON decoding failed due to {}'.format(str(e)))\\n\\n else:\\n return_error('API Returned, {}:{}'.format(response.status_code, response.reason))\",\n \"def _issue_api_request(self, resource_url, method='get', body=None,\\n sensitive=False, conflict_ok=False):\\n host = self.configuration.san_ip\\n port = self.configuration.datera_api_port\\n api_token = self.datera_api_token\\n api_version = self.configuration.datera_api_version\\n\\n payload = json.dumps(body, ensure_ascii=False)\\n payload.encode('utf-8')\\n\\n header = {'Content-Type': 'application/json; charset=utf-8',\\n 'Datera-Driver': 'OpenStack-Cinder-{}'.format(self.VERSION)}\\n\\n protocol = 'http'\\n if self.configuration.driver_use_ssl:\\n protocol = 'https'\\n\\n if api_token:\\n header['Auth-Token'] = api_token\\n\\n client_cert = self.configuration.driver_client_cert\\n client_cert_key = self.configuration.driver_client_cert_key\\n cert_data = None\\n\\n if client_cert:\\n protocol = 'https'\\n cert_data = (client_cert, client_cert_key)\\n\\n connection_string = '%s://%s:%s/v%s/%s' % (protocol, host, port,\\n api_version, resource_url)\\n\\n response = self._request(connection_string,\\n method,\\n payload,\\n header,\\n cert_data)\\n\\n data = response.json()\\n\\n if not response.ok:\\n self._handle_bad_status(response,\\n connection_string,\\n method,\\n payload,\\n header,\\n cert_data,\\n conflict_ok=conflict_ok)\\n\\n return data\",\n \"def _api_call(self, api_call, method=\\\"GET\\\", payload=None):\\n # type: (str, str, Dict[str, str]) -> requests.Response\\n\\n headers = {\\n \\\"accept\\\" : \\\"application/json\\\",\\n \\\"Authorization\\\" : f\\\"Bearer {self.access_token}\\\",\\n \\\"x-ibm-client-id\\\" : self.client_id,\\n }\\n self.__log.debug(headers)\\n api_url = f\\\"{self.base_url}/{api_call}\\\"\\n\\n self.__log.debug(f\\\"Calling {api_url} with method {method}\\\")\\n if method == \\\"GET\\\":\\n resp = requests.get(api_url, headers=headers)\\n elif method == \\\"POST\\\":\\n resp = requests.post(api_url, headers=header, data=payload)\\n elif method == \\\"PUT\\\":\\n resp = requests.put(api_url, headers=header, data=payload)\\n elif method == \\\"DELETE\\\":\\n resp = requests.delete(api_url, headers=headers)\\n elif method == \\\"HEAD\\\":\\n resp = requests.head(api_url, headers=headers)\\n elif method == \\\"OPTIONS\\\":\\n resp = requests.options(api_url, headers=headers)\\n else:\\n raise Exception(f\\\"The method {method} is unsupported\\\")\\n \\n if (resp.ok):\\n return resp\\n else:\\n self.__log.debug(resp.status_code)\\n self.__log.debug(resp.text)\\n return resp\",\n \"def post(self):\\n\\n if config.logging:\\n logfile.info(\\\"Request to /rest/broadsoft recieved\\\")\\n if config.verbose:\\n logconsole.info(\\\"Request to /rest/broadsoft recieved\\\")\\n\\n # Ensure that the user has sent a jwt to the endpoint.\\n try:\\n verify_jwt_in_request()\\n except Exception as error:\\n return make_response(\\\"<error>Unauthorized</error>\\\", 401)\\n\\n # Create a user object from the JWT identity object.\\n user = User().from_identity(get_jwt_identity())\\n\\n # Check if a user was able to be created.\\n if user is None:\\n return \\\"<ErrorInfo><message>Not logged in</message><error>true</error></ErrorInfo>\\\", 401\\n\\n # Create a request parser to parse arguments\\n parser = reqparse.RequestParser()\\n\\n # Configure endpoint arguments.\\n parser.add_argument(\\n name='endpoint',\\n help='Missing the required broadsoft endpoint to connect to.',\\n required=True)\\n\\n parser.add_argument(\\n name='data',\\n type=str,\\n help='JSON data needs to be a string')\\n\\n parser.add_argument(\\n name='method',\\n help='Missing method type. ex) method:GET/PUT/POST...',\\n required=True)\\n\\n # Check if the arguments passed were valid.\\n try:\\n args = parser.parse_args()\\n except reqparse.exceptions.BadRequest as e:\\n # If there are any errors, ensure that login=False is sent.\\n message = \\\"<error>true</error>\\\"\\n return message, 400\\n\\n # Get the data sent from the request.\\n url = self.url + args['endpoint'].replace(\\\"<user>\\\", user.username)\\n data = \\\"\\\"\\n method = args['method']\\n\\n # Check if any data was sent\\n if(args['data']):\\n data = args['data']\\n\\n if config.logging:\\n logfile.info(\\\"Sending data: \\\" + method + \\\" \\\" + url + \\\" \\\" + data)\\n if config.verbose:\\n logconsole.info(\\\"Sending data: \\\" + method + \\\" \\\" + url + \\\" \\\" + data)\\n\\n # Get the user's broadsoft token from the JWT and send a request to broadsoft.\\n response = Proxy().to_broadsoft(method, url, data, user)\\n\\n # Check if a valid response was returned.\\n if response.status_code == 200 or response.status_code == 201:\\n\\n # Output a response to the console and log files.\\n if config.logging:\\n logfile.info(\\\"Recieved:\\\" + str(response.status_code) + \\\" \\\" + str(response.content) if response.content else \\\"Recieved: \\\" + str(response.status_code))\\n if config.verbose:\\n logconsole.info(\\\"Recieved:\\\" + str(response.status_code) + \\\" \\\" + str(response.content) if response.content else \\\"Recieved: \\\" + str(response.status_code))\\n\\n # Format a response\\n if response.content:\\n return make_response(str(response.content.decode('ISO-8859-1')), 200)\\n else:\\n return make_response(\\\"\\\", 200)\\n else:\\n if config.logging:\\n logfile.info(\\\"Recieved:\\\" + str(response.status_code) + \\\" \\\" + response.content.decode('ISO-8859-1') if response.content else \\\"\\\")\\n if config.verbose:\\n logconsole.info(\\\"Recieved:\\\" + str(response.status_code) + \\\" \\\" + response.content.decode('ISO-8859-1') if response.content else \\\"\\\")\\n\\n if response.content:\\n return make_response(response.content.decode('ISO-8859-1'), response.status_code)\\n else:\\n return make_response(\\\"\\\", response.status_code)\",\n \"def get():\\n return jsonify(baby='knight2'), 200\",\n \"def make_get_request(client, endpoint):\\n return client.get(endpoint)\",\n \"def api_req(dev, api_call):\\r\\n import xmltodict\\r\\n import logging\\r\\n try:\\r\\n r = requests.get(dev + ':8060' + api_call, timeout=5)\\r\\n except Exception as exc:\\r\\n response = [\\\"ERR\\\", exc]\\r\\n return response[0]\\r\\n except ConnectionError as connerr:\\r\\n response = [\\\"ERR\\\", connerr]\\r\\n return response[0]\\r\\n except TimeoutError as toerr:\\r\\n response = [\\\"ERR\\\", toerr]\\r\\n return response[0], toerr\\r\\n r_code = r.status_code\\r\\n if r_code == 200:\\r\\n print(\\\"REQUEST WAS A SUCCESS. DEVICE RETURNED: {} \\\".format(str(r)))\\r\\n r2 = r.text\\r\\n response = xmltodict.parse(r2, xml_attribs=False)\\r\\n return response\\r\\n else:\\r\\n response = \\\"UnknownERR\\\"\\r\\n dev.state(DISABLED)\\r\\n return msg_box(response)\",\n \"def request(host, path, api_key, url_params=None):\\n url_params = url_params or {}\\n url = '{0}{1}'.format(host, path)\\n headers = {\\n 'x-rapidapi-host': \\\"us-restaurant-menus.p.rapidapi.com\\\",\\n 'x-rapidapi-key': api_key,\\n }\\n\\n print(u'Querying {0} ...'.format(url))\\n\\n response = requests.request('GET', url, headers=headers, params=url_params)\\n\\n data = json.loads(response.text)\\n if 'error' in data:\\n raise Exception(str(data))\\n return data\",\n \"def cci_api():\\n\\n\\n\\t\\t\\treturn render_template( 'api.html' )\",\n \"def get_api(self):\\n from geoffrey.utils import get_api\\n return get_api(self.app.routes, prefix=\\\"/\\\")\",\n \"def test_GET(self):\\n if not self.url:\\n return\\n response = self.client.get(self.url, {}, format='json')\\n self.assertIn(response.status_code, [status.HTTP_405_METHOD_NOT_ALLOWED,\\n status.HTTP_401_UNAUTHORIZED])\",\n \"def _get_good_request(self):\\r\\n prms = {\\r\\n 'url': u'http://google.com',\\r\\n 'description': u'This is my google desc',\\r\\n 'extended': u'And some extended notes about it in full form',\\r\\n 'tags': u'python search',\\r\\n }\\r\\n\\r\\n req_params = urllib.urlencode(prms)\\r\\n res = self.app.post(\\r\\n '/api/v1/admin/bmark?api_key={0}'.format(self.api_key),\\r\\n params=req_params,\\r\\n )\\r\\n return res\",\n \"def request(self, apiurl, caller, mode=\\\"get\\\", data=None):\\n\\n token = self._getToken(caller)\\n # print(self._tokenstore)\\n headers = {'Content-Type': 'application/json', 'Accept': 'application/json', 'Authorization': f'Bearer {token}'}\\n if mode == \\\"get\\\":\\n return self._oauth.getRequester().get(self._baseurl + apiurl, headers=headers)\\n elif mode == \\\"post\\\":\\n return self._oauth.getRequester().post(self._baseurl + apiurl, data=data, headers=headers)\\n elif mode == \\\"delete\\\":\\n return self._oauth.getRequester().delete(self._baseurl + apiurl, headers=headers)\",\n \"def api_get(self, name):\\n try:\\n r = self._get(['apis', name])\\n except requests.HTTPError:\\n return None\\n else:\\n return r\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6853146","0.6268339","0.6268339","0.62518954","0.62271094","0.605959","0.60268193","0.60259753","0.59603226","0.59556425","0.59494823","0.5872682","0.5860177","0.58262163","0.57653207","0.5758254","0.57468194","0.57456577","0.5684184","0.567575","0.56635946","0.5656675","0.5651085","0.5647359","0.56392694","0.56391686","0.56391686","0.5632862","0.562787","0.5627653","0.5625221","0.56197697","0.56016237","0.5599405","0.5590814","0.5586176","0.55841845","0.55772984","0.55477506","0.5545348","0.55429727","0.5537563","0.5522704","0.55185765","0.5509818","0.55092716","0.55069166","0.5506516","0.5498339","0.5483691","0.54830843","0.5474672","0.5473069","0.54709125","0.5470688","0.54578346","0.54551625","0.5443743","0.54424244","0.5430492","0.5427966","0.5427574","0.54144806","0.5408867","0.5392876","0.5388418","0.5387187","0.5385353","0.5382121","0.5382091","0.53740984","0.5364051","0.5361647","0.5360928","0.5360908","0.53561306","0.5349043","0.5347934","0.5346842","0.5344333","0.5343733","0.5342094","0.53402144","0.5338128","0.53373086","0.53369176","0.53287756","0.532161","0.5318225","0.531762","0.53121775","0.53059155","0.53044295","0.5299869","0.52979577","0.52901024","0.52894956","0.5284227","0.52823293","0.5281704"],"string":"[\n \"0.6853146\",\n \"0.6268339\",\n \"0.6268339\",\n \"0.62518954\",\n \"0.62271094\",\n \"0.605959\",\n \"0.60268193\",\n \"0.60259753\",\n \"0.59603226\",\n \"0.59556425\",\n \"0.59494823\",\n \"0.5872682\",\n \"0.5860177\",\n \"0.58262163\",\n \"0.57653207\",\n \"0.5758254\",\n \"0.57468194\",\n \"0.57456577\",\n \"0.5684184\",\n \"0.567575\",\n \"0.56635946\",\n \"0.5656675\",\n \"0.5651085\",\n \"0.5647359\",\n \"0.56392694\",\n \"0.56391686\",\n \"0.56391686\",\n \"0.5632862\",\n \"0.562787\",\n \"0.5627653\",\n \"0.5625221\",\n \"0.56197697\",\n \"0.56016237\",\n \"0.5599405\",\n \"0.5590814\",\n \"0.5586176\",\n \"0.55841845\",\n \"0.55772984\",\n \"0.55477506\",\n \"0.5545348\",\n \"0.55429727\",\n \"0.5537563\",\n \"0.5522704\",\n \"0.55185765\",\n \"0.5509818\",\n \"0.55092716\",\n \"0.55069166\",\n \"0.5506516\",\n \"0.5498339\",\n \"0.5483691\",\n \"0.54830843\",\n \"0.5474672\",\n \"0.5473069\",\n \"0.54709125\",\n \"0.5470688\",\n \"0.54578346\",\n \"0.54551625\",\n \"0.5443743\",\n \"0.54424244\",\n \"0.5430492\",\n \"0.5427966\",\n \"0.5427574\",\n \"0.54144806\",\n \"0.5408867\",\n \"0.5392876\",\n \"0.5388418\",\n \"0.5387187\",\n \"0.5385353\",\n \"0.5382121\",\n \"0.5382091\",\n \"0.53740984\",\n \"0.5364051\",\n \"0.5361647\",\n \"0.5360928\",\n \"0.5360908\",\n \"0.53561306\",\n \"0.5349043\",\n \"0.5347934\",\n \"0.5346842\",\n \"0.5344333\",\n \"0.5343733\",\n \"0.5342094\",\n \"0.53402144\",\n \"0.5338128\",\n \"0.53373086\",\n \"0.53369176\",\n \"0.53287756\",\n \"0.532161\",\n \"0.5318225\",\n \"0.531762\",\n \"0.53121775\",\n \"0.53059155\",\n \"0.53044295\",\n \"0.5299869\",\n \"0.52979577\",\n \"0.52901024\",\n \"0.52894956\",\n \"0.5284227\",\n \"0.52823293\",\n \"0.5281704\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55546147"},"document_rank":{"kind":"string","value":"38"}}},{"rowIdx":4999,"cells":{"query":{"kind":"string","value":"Get list of Domains for this API key."},"document":{"kind":"string","value":"def get_domains() -> List[str]:\n ret = _call_endpoint(\"v1/domains\")\n # Example response:\n # [{'createdAt': '2016-06-25T03:08:44.000Z',\n # 'domain': 'mydomain.com',\n # 'domainId': 12345678,\n # 'expirationProtected': False,\n # 'expires': '2020-06-25T03:08:44.000Z',\n # 'holdRegistrar': False,\n # 'locked': True,\n # 'nameServers': None,\n # 'privacy': False,\n # 'renewAuto': True,\n # 'renewDeadline': '2020-08-09T03:08:44.000Z',\n # 'renewable': True,\n # 'status': 'ACTIVE',\n # 'transferProtected': False},]\n domains = [d[\"domain\"] for d in ret]\n return domains"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_domains(self):\n\n response = self.call(method='getDomains')\n domains = []\n for d in response:\n domain = self.domain(domain=d['domain'])\n domains.append(domain)\n return domains","def listDomains(self):\n reply = self.rpc.getDomains(self.username,\n self.password)\n if reply[0] == 'UNKNOWN_ERROR':\n raise Exception(\"RPC returned error: \" + reply[0])\n return reply","def domains(self):\n return DomainCollection(self.request)","def list_domain_names(self) -> Dict:\n pass","def tracking_domain_list(self):\r\n params = base.get_params(None, locals())\r\n return self._get('tracking_domain_list', params)","def ListDomains(self, perPage=0, page=1):\n\n class Result(Model):\n domains = ListField(ModelField(Domain))\n\n if perPage != 0:\n headers = {\"perPage\": perPage, \"page\": page}\n response = self.client.http_get(\"/v4/domains\", headers)\n else:\n response = self.client.http_get(\"/v4/domains\")\n\n return parse_response(response, Result)","def getDomains(self, company):\n return self.db.getDomains(company)","def list_domain(self, feed_id=None):\n resources = self.list_resource(feed_id=feed_id, resource_type_id='Host Controller')\n domains = []\n if resources:\n for resource in resources:\n resource_data = self.get_config_data(\n feed_id=resource.path.feed_id, resource_id=resource.id)\n domain_data = resource_data.value\n domains.append(Domain(resource.id, resource.name, resource.path, domain_data))\n return domains","def list_domain(self, feed_id=None):\n domains = self.list_resource(feed_id=feed_id,\n resource_type_id='Domain Host',\n cls=Domain,\n list_children=True,\n include_data=True)\n return domains","def domains(self) -> pulumi.Output[Sequence[str]]:\n return pulumi.get(self, \"domains\")","def list_keystone_v3_domains(self):\n LOG_OBJ.debug(\"List the domains.\")\n\n _url = \"http://\" + self.host_ip + \":35357/v3/domains\"\n _headers = {'x-auth-token': self.cloud_admin_info[\"token_domain\"],\n 'content-type': 'application/json'}\n _body = None\n\n response = self.request(\"GET\", _url, _headers, _body)\n\n if response is None:\n LOG_OBJ.error(\"No response from Server while creating domain\")\n print (\"No response from Server while creating domain\")\n return response\n\n if response.status not in [200, 201, 202, 203, 204]:\n LOG_OBJ.error(\" Listing domains Failed with status %s \"\n \"and error : %s\" % response.status, response.data)\n print (\" Listing domains Failed with status %s and error : %s\" %\n response.status, response.data)\n return response.status\n\n output = json.loads(response.data)\n LOG_OBJ.info(\"Domains list : %s \" % output)\n print (\"Domains list : %s \" % output)\n return output['domains']","def domains(cls):\n return [cls.domain]","def list_zones(self, **kwargs):\r\n return self.client['Account'].getDomains(**kwargs)","def domains(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"domains\")","def domain_list_all(self):\n page = 1\n on_page = 100\n ret = []\n while True:\n r = self.domain_list(page=page, on_page=on_page)\n ret += r['domains']\n if len(ret) >= r['total']:\n break\n page += 1\n return ret","def domain(self):\n return self.keys()","def get_search_domains(self):\n\t\treturn handle_to_object(call_sdk_function('PrlSrvCfg_GetSearchDomains', self.handle))","def domains(self) -> pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationRoute53DomainArgs']]]:\n return pulumi.get(self, \"domains\")","def list_domain_names():\n pass","def list(self, domain):\n return request(\n API_LIST.DNS_LIST.value,\n {\n 'email': self.email,\n 'token': self.token,\n 'domain': domain\n }\n )","def cb_listdomains(self, cmd):\n for cur in sorted(self.d.listDomains(),\n key=lambda x: _domreverse(x['domain'])):\n print \"%(domain)60s %(expiration_date)15s\" % cur","def get_subdomains(self):\n\n response = self.call(method='getSubdomains', args=[self.domainname])\n subdomains = []\n for s in response:\n subdomain = self.subdomain(domain=self.domainname, subdomain=s)\n subdomains.append(subdomain)\n return subdomains","def list_all():\n\n return (_conn.listDefinedDomains() +\n [_conn.lookupByID(id).name() for id in _conn.listDomainsID()])","def get(self, api_key):\n\n try:\n mailgun.list_domains(api_key)\n return {\"api_key\": api_key, \"valid\": True}\n except:\n return {\"api_key\": api_key, \"valid\": False}","def get_search_domains(self):\n\t\treturn handle_to_object(call_sdk_function('PrlSrvCfgNet_GetSearchDomains', self.handle))","def AllowedDomains(self)->list:\n return self._allowedDomains","def _get_domain(self):\n self.ensure_one()\n domain = []\n return domain","def domains(cls):\n return (cls.domain, )","def domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"domains\")","def get_dns_list(self):\n return self.get_ipv4_dns_list()","def get_search_domains(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmDevNet_GetSearchDomains', self.handle))","def get_dns_records_from_godaddy(self) -> list:\n\n headers = {\"Authorization\": \"sso-key {}:{}\".format(self.api_key, self.secret_key)}\n dns_records = []\n for dns_record in self.dns_records:\n url = \"https://api.godaddy.com/v1/domains/{}/records/{}/{}\".format(dns_record[\"domain\"],\n dns_record[\"dns_record_type\"],\n dns_record[\"name\"])\n dns_records.append(get(url, headers=headers).text)\n return dns_records","def get_search_domains(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetSearchDomains', self.handle))","def check_domains(self, service_id, service_version):\n domain_list = self.fastly_cache[service_id]['domain_list']\n\n return domain_list","def extract_domains(self, resp):\n return","def get_delta_domains():\n url = os.getenv('DELTAS_URL')\n if url is None:\n raise Exception('Delta report URL configuration not set!')\n\n json = requests.get(url, timeout=10).json()\n return [domain\n for (domain,)\n in json['values']\n if dnstwist.is_valid_domain(domain)]","def case_search_enabled_domains():\n return CaseSearchConfig.objects.filter(enabled=True).values_list('domain', flat=True)","def list_zones(self):\n data = self._paginated_request(\"/v2/domains\", \"domains\")\n return list(map(self._to_zone, data))","def get_domain(id):\n return query(WEB_EXAMPLE_BASE + f\"/classical/domain/{id}\")","def get_domains(filename):\n with open(filename, 'r') as file:\n result = []\n for line in file.readlines():\n domain = line.strip()[1:]\n result.append(domain)\n return result","def get_dns(self):\n dns = []\n for id, user in self.users_by_id.items():\n if not user.dns:\n continue\n for dn in user.dns:\n dns.append(dn)\n return dns","def domainlist_reversewhois(self, response):\n data = response.json()\n for domain in data['response']['domains']:\n yield(domain.lower())","def domains(self):\n ctx = stack.top\n if ctx is not None:\n if not hasattr(ctx, 'simple_domains'):\n ctx.simple_domains = {}\n for domain in self.app.config['SIMPLE_DOMAINS']:\n ctx.simple_domains[domain] = Domain(\n connection = self.connection,\n name = domain,\n )\n\n if not hasattr(ctx, 'simple_domain_%s' % domain):\n setattr(ctx, 'simple_domain_%s' % domain, ctx.simple_domains[domain])\n\n return ctx.simple_domains","def getlist(self):\n self.__domainlist.sort()\n\n outstr = \"{ \"\n for index, domain in enumerate(self.__domainlist):\n outstr += domain + \" \"\n if (index % 50 == 0) and index > 0:\n outstr += \"}\\n{ \"\n\n outstr += \"}\"\n\n return outstr","def get_domains_by_provider_url(self, provider_url):\n\n domains = \\\n self.storage_controller.get_domains_by_provider_url(provider_url)\n\n return domains","def info(self):\n\n return self.call(method='getDomain', args=[self.domainname])","def get_urls(self, queries):\n domains = defaultdict(list)\n for q in queries:\n q = \"\\\"\" + q + \"\\\"\"\n results = self.engine.search(q)\n\n for result in results: \n url = result.url\n domain = self.get_domain(url)\n domains[domain].append(q) \n return domains","def get_domain_names(self, MaxResults: str = None, NextToken: str = None) -> Dict:\n pass","def get_domain_dns_records(domain):\n url_suffix = \"v1/domains/{}/records\".format(domain)\n ret = _call_endpoint(url_suffix)\n if isinstance(ret, dict) and ret.get('code', None) == \"UNKNOWN_DOMAIN\":\n # e.g. {'code': 'UNKNOWN_DOMAIN', 'message': 'The given domain is not registered, or does not have a zone file'}\n raise Exception(f\"Can't find domain {domain}. Are you sure your API key and secret are correct?: {ret}\")\n return ret","def domainlist_reversens(self, response):\n data = response.json()\n for domain in itertools.chain(data['response']['primary_domains'], data['response']['primary_domains']):\n yield(domain.lower())","def _list(self, account, page):\n response = self.client.get(self.get_url(account), data={\"page\": page})\n return [\n DomainResource(**item) for item in response['data']\n ], response['pagination']","def domain(self):\n return self._get('domain', '/domain/', self.DOMAIN_DATA)","def show_domains(self):\n show_domains(self.system.cavity_gri)","def items_by_domain(self, domain: str) -> List[dict]:\n if not self.connected:\n raise NotConnected(\"Please call connect first.\")\n return [value for key, value in self._states.items() if key.startswith(domain)]","def cookieDomains(self):\n domains = []\n for cookie in self.cookies():\n domain = cookie.domain()\n if domain not in domains:\n domains.append(domain)\n \n return domains","def get_storage_domains(cohesity_client):\n storage_domain_list = cohesity_client.view_boxes.get_view_boxes()\n for domain in storage_domain_list:\n exported_res_dict[\"Storage Domains\"].append(domain.name)\n return storage_domain_list","def allowed_domains(self):\n if self._allowed_domains is None:\n uri = \"/loadbalancers/alloweddomains\"\n resp, body = self.method_get(uri)\n dom_list = body[\"allowedDomains\"]\n self._allowed_domains = [itm[\"allowedDomain\"][\"name\"]\n for itm in dom_list]\n return self._allowed_domains","def allowed_domains(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"allowed_domains\")","def public_domain_names(self) -> pulumi.Output[Optional[Sequence['outputs.ContainerPublicDomainName']]]:\n return pulumi.get(self, \"public_domain_names\")","def get_botnet_domains():\n\n fw = \"<HTTPS://YOUR_FORTIGATE_IP:YOUR_FORTIGATE_PORT>\"\n\n path = \"/api/v2/monitor/system/botnet-domains/hits/?access_token=\"\n\n token = \"<YOUR_API_KEY>\"\n\n content_filter = \"\"\n\n if content_filter != \"\":\n url = fw + path + token + content_filter\n else:\n url = fw + path + token\n\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\")\n \n try:\n r = requests.get(url, verify=False).json()\n except Exception:\n print(\"Something went wrong. Is the url correct? Exiting...\")\n sys.exit()\n\n for key in r['results']:\n print()\n for k,v in key.items():\n print(\"{0:6} : {1}\".format(k.upper(), str(v)))","def get_domains(filters: Optional[Sequence[pulumi.InputType['GetDomainsFilterArgs']]] = None,\n sorts: Optional[Sequence[pulumi.InputType['GetDomainsSortArgs']]] = None,\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDomainsResult:\n __args__ = dict()\n __args__['filters'] = filters\n __args__['sorts'] = sorts\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\n __ret__ = pulumi.runtime.invoke('digitalocean:index/getDomains:getDomains', __args__, opts=opts, typ=GetDomainsResult).value\n\n return AwaitableGetDomainsResult(\n domains=pulumi.get(__ret__, 'domains'),\n filters=pulumi.get(__ret__, 'filters'),\n id=pulumi.get(__ret__, 'id'),\n sorts=pulumi.get(__ret__, 'sorts'))","def parse(domains):\n subdomains = []\n for domain in domains:\n url = 'https://urlscan.io/api/v1/search/?q=domain:{}'.format(domain)\n json_resp = json.loads(requests.get(url).text)\n subdomains += list(set(find('domain', json_resp)))\n return list(set(subdomains))","def get_dns_servers(self):\n\t\treturn handle_to_object(call_sdk_function('PrlSrvCfg_GetDnsServers', self.handle))","def load_private_domains(self):\n url = self.lookup(\"private_domains_url\")\n p_domains = self._fetcher.get_entities(url)\n domains = []\n for domain in p_domains:\n if 'name' in domain:\n domains.append({'name': domain['name']})\n self._domains_private = domains","def getIpv4DnsList(self):\n with self.status._dhcp_status_mutex:\n if self.status.ipv4_lease_valid is None:\n return [None]\n else:\n return self.status.ipv4_dnslist","def get_all_courses(self) -> List[str]:\n\n print(\"Downloading all Courses from all Domains...\")\n all_courses_url = []\n for domain in DOMAINS:\n print(\"Selected Domain: \", domain)\n selected_domain_url = ROOT_URL + \"/\" + domain\n courses, courses_url = self.get_courses(selected_domain_url)\n all_courses_url += courses_url\n\n return all_courses_url","def get_ipv4_dns_list(self):\n \n ipv4_dns_list = self._dhcp_client_ctrl.getIpv4DnsList()\n if ipv4_dns_list is None:\n return [None]\n else:\n return map(unicode, ipv4_dns_list)","def get_domain_whitelist(self):\n whitelist = self.charm_config[\"federation-domain-whitelist\"]\n return list(filter(None, whitelist.split(\",\")))","def domains(cls) -> Set[str]:\n return set(cls.langs.values())","def listRR(self):\n reply = self.rpc.getSubdomains(self.username,\n self.password,\n self.domain)\n\n if len(reply) and reply[0] in ('UNKNOWN_ERROR',\n 'RATE_LIMITED'):\n raise Exception(\"RPC returned error: \" + reply[0])\n return reply","def get_domains(self, ID, domain_type):\n \n try:\n record = self.database[ID]\n except KeyError:\n return -1\n domain_type = domain_type.lower()\n if domain_type == 'pfam':\n doms = record[\"pfam_domains\"]\n elif domain_type == 'uniprot':\n doms = record[\"uniprot_domains\"]\n else:\n print \"%s is an unrecognized domain type. Use 'pfam' or 'uniprot'\"%(domain_type)\n return -2\n \n doms_raw=doms.split(\";\")\n doms_clean =[]\n for i in doms_raw:\n if i:\n tmp = i.strip()\n tmp = tmp.split(\":\")\n if len(tmp)>=2:\n name, sites = tmp\n tmp = sites.split(\"-\")\n doms_clean.append((name, tmp[0], tmp[1]))\n else:\n print \"ERROR: the domain did not match expected %s\"%(i)\n #doms_clean.append((tmp, -1, -1))\n return doms_clean","def __parse_domains(self, lines):\n domain_list = []\n for line in lines:\n if len(line) == 0:\n continue\n if line[0] == \"!\":\n continue\n if line[0] == \"|\":\n continue\n if line[0] == \"@\":\n continue\n if line[0] == \"[\":\n continue\n if line.find('zh.wikipedia.org') == 0:\n continue\n line = string.replace(line, \"||\", \"\").lstrip(\".\")\n # strip everything from \"/\" to the end\n if line.find(\"/\") != -1:\n line = line[0:line.find(\"/\")]\n if line.find(\"*\") != -1:\n continue\n if line.find(\".\") == -1:\n continue\n # if line in oklist:\n # \tcontinue\n domain_list.append(line)\n\n return domain_list","def disable_all_domains_always_in_scope(self, apikey=''):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/disableAllDomainsAlwaysInScope/', {'apikey': apikey})))","def enable_all_domains_always_in_scope(self, apikey=''):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/enableAllDomainsAlwaysInScope/', {'apikey': apikey})))","def domainlist_reverseip(self, response):\n data = response.json()\n for ip in data['response']['ip_addresses']:\n for domain in ip['domain_names']:\n yield(domain.lower())","def domain(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"domain\")","def test_client_get_domains(mocker, client_all_domains_input):\n mocker.patch(\"tracker_client.client.get_auth_token\")\n mocker.patch(\"tracker_client.client.create_client\")\n test_client = Client()\n test_client.execute_query = mocker.MagicMock(return_value=client_all_domains_input)\n\n domain_list = test_client.get_domains()\n\n test_client.execute_query.assert_called_once_with(\n queries.GET_ALL_DOMAINS, {\"after\": \"abc\", \"search\": \"\"}\n )\n assert domain_list[0].domain_name == \"foo.bar\"\n assert domain_list[1].dmarc_phase == \"not implemented\"\n assert domain_list[2].last_ran == \"2021-01-27 23:24:26.911236\"\n assert domain_list[0].dkim_selectors == []","def fetch_domain_certs(domain):\n url = BASE_URL.format(domain)\n result = requests.get(url)\n if result.status_code != 200:\n result.raise_for_status()\n return result.json()","def get_dns_servers(self):\n\t\treturn handle_to_object(call_sdk_function('PrlSrvCfgNet_GetDnsServers', self.handle))","def domain(self, id_or_name):\n return DomainCollection(self.request).find(id_or_name)","def domain(self):\n return self['domain']","def list_zones(self):\n action = \"/api_dns_list.asp\"\n if self.reseller_id is not None:\n action = \"/api_dns_list_reseller.asp\"\n zones = self.connection.request(action)\n if len(zones.body) == 0:\n return []\n else:\n return self._to_zones(zones.body)","def dict_of_domains(fc):\r\n # need to find root database (GDB or SDE)\r\n db_root = os.path.dirname(fc)\r\n while db_root[-4:].lower() != '.gdb' and db_root[-4:].lower() != '.sde':\r\n old_db_root = db_root # protect against infinite loop\r\n db_root = os.path.dirname(db_root)\r\n if old_db_root == db_root: # protect against infinite loop\r\n break\r\n arcpy.AddMessage(\"Retrieving Domains from \" + str(db_root))\r\n return {domain.name: domain.codedValues for domain in arcpy.da.ListDomains(db_root)}","def list_availability_domains(self, compartment_id, **kwargs):\n resource_path = \"/availabilityDomains\"\n method = \"GET\"\n\n expected_kwargs = [\"retry_strategy\"]\n extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]\n if extra_kwargs:\n raise ValueError(\n \"list_availability_domains got unknown kwargs: {!r}\".format(extra_kwargs))\n\n query_params = {\n \"compartmentId\": compartment_id\n }\n query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}\n\n header_params = {\n \"accept\": \"application/json\",\n \"content-type\": \"application/json\"\n }\n\n retry_strategy = self.retry_strategy\n if kwargs.get('retry_strategy'):\n retry_strategy = kwargs.get('retry_strategy')\n\n if retry_strategy:\n return retry_strategy.make_retrying_call(\n self.base_client.call_api,\n resource_path=resource_path,\n method=method,\n query_params=query_params,\n header_params=header_params,\n response_type=\"list[AvailabilityDomain]\")\n else:\n return self.base_client.call_api(\n resource_path=resource_path,\n method=method,\n query_params=query_params,\n header_params=header_params,\n response_type=\"list[AvailabilityDomain]\")","def get_dns(self) -> Set:\n if self.dn_set.should_update():\n contacts_data = self.get_contacts_data()\n self.dn_set.update(set(contacts_data.get_dns()))\n return self.dn_set.data","def public_domain_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPublicDomainNameArgs']]]]:\n return pulumi.get(self, \"public_domain_names\")","def getIPs(self, domain = \"localhost\"):\n # convert 'domain' to string, in case of erroneous type being passed\n domain = str(domain)\n\n # Kind warning for those who entered an IP address instead of a domain\n try: \n inet_aton(domain)\n print(\"Warning: an IP address was given instead of a domain name.\")\n except:\n pass\n\n # Try to query DNS records to populate A-Record IP list\n # Prints errors and returns None if exceptions found\n try:\n iplist = gethost(domain)[2]\n except gaierror as ge:\n if ge.errno == -2:\n print(\"Error: Domain '{}' invalid, or unknown. \"\\\n \"Please check proper spelling and format.\\n\"\\\n \"(e.g.: python dns_get_A_record_IPs.py google.com )\".format(domain))\n elif ge.errno == -3:\n print(\"Error: Domain '{}' unreachable. Please check your connection.\".format(domain))\n return None\n except timeout:\n print(\"Error: Connection to {} timed out.\".format(domain))\n return None\n\n return iplist","def domain(self) -> str:\n return pulumi.get(self, \"domain\")","def domain(self) -> str:\n return pulumi.get(self, \"domain\")","def print_all_dns_records():\n for domain in sorted(get_domains()):\n dns_records = get_domain_dns_records(domain)\n print(domain)\n pprint(dns_records)\n print(\"*\" * 50)\n # TODO: poor man's rate limiter. improve?\n time.sleep(2)","def get_layer_urls(self):\n urls = []\n\n if getattr(self, 'additional_domains'):\n map(urls.append, (domain for domain in self.additional_domains.split(\";\") if domain))\n\n return urls","def get_dns_servers(self):\n\t\treturn handle_to_object(call_sdk_function('PrlVmDevNet_GetDnsServers', self.handle))","def get_input_domains():\n df = pandas.read_excel(\"AutoScrapy/files/EBE21 - Top 100 Onlineshops to scrapp.ods\", engine=\"odf\")\n list_of_addresses = df['Domain'].to_list()\n list_of_addresses = [(\"http://\" + address) for address in list_of_addresses]\n print(list_of_addresses)\n return list_of_addresses","def get(self):\r\n url = '{0}/subdomains/{1}'.format(self.parent.get_url(),\r\n port.to_u(self.object_id))\r\n return http.Request('GET', url), parsers.parse_json","def fusion_api_get_login_domains_login_certificates(self, api=None, headers=None, param=''):\n return self.login_certificates.get(api, headers, param)","def option_domains_always_in_scope(self):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/optionDomainsAlwaysInScope/')))","def domains_v2():\n # Is this public?\n configs = get_configs()\n if configs['api_requests'] == 'auth':\n # Auth token in headers\n try:\n auth_token = Token.query.filter_by(auth_token=request.headers.get('Authorization')).first()\n except:\n return {\"alternatives\" : \"Database Error with token!\"}\n if not auth_token:\n return {\"alternatives\": \"Unauthorized!\"}\n\n req_data = request.get_json()\n url = req_data['url']\n if not url:\n return {\"alternatives\" : 'None'}\n \n domain_data = check(url)\n alternatives = {\"alternatives\": domain_data['available_alternatives']}\n return alternatives","def by_domains(self):\n\t\t\n\t\t# TODO: use urllib instead\n\t\turl_format = r'^\\s*(?:(?P<protocol>\\w+)://)?(?P<domain>[\\w\\d\\-\\.]+)(?::(?P<port>\\d+))?/?(?P<everything_else>.*)$'\n\t\tsites = {}\n\t\tfor line in self.source.lines:\n\t\t\ttry:\n\t\t\t\tif self.filter(line):\n\t\t\t\t\tresult = re.match(url_format, line.content.url)\n\t\t\t\t\tif result.group('domain') not in sites.keys():\n\t\t\t\t\t\tsites[result.group('domain')] = 0\n\t\t\t\t\tsites[result.group('domain')] += int(line.content.size)\n\t\t\texcept AttributeError:\n\t\t\t\tpass\n\t\t\n\t\t# TODO: sort; convert to lists is even better\n\t\t\n\t\treturn sites","def list_websites(self):\r\n\r\n # Fetch websites\r\n self.fetch_website_list()\r\n\r\n # Print website data\r\n for website in self.website_list:\r\n print(\"ID: {0} | Domain: {1} | Name: {2}\".format(\r\n website['id'], website['domain'], website['name']))","def get_domains_from_cert(cert_file):\n proc = subprocess.Popen([\"openssl\", \"x509\", \"-in\", cert_file, \"-noout\", \"-text\"],\n stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n out, err = proc.communicate()\n if proc.returncode != 0:\n raise IOError(\"Error loading {0}: {1}\".format(cert_file, err))\n return ACMEClient._parse_domains_from_openssl_output(out.decode('utf8'))"],"string":"[\n \"def get_domains(self):\\n\\n response = self.call(method='getDomains')\\n domains = []\\n for d in response:\\n domain = self.domain(domain=d['domain'])\\n domains.append(domain)\\n return domains\",\n \"def listDomains(self):\\n reply = self.rpc.getDomains(self.username,\\n self.password)\\n if reply[0] == 'UNKNOWN_ERROR':\\n raise Exception(\\\"RPC returned error: \\\" + reply[0])\\n return reply\",\n \"def domains(self):\\n return DomainCollection(self.request)\",\n \"def list_domain_names(self) -> Dict:\\n pass\",\n \"def tracking_domain_list(self):\\r\\n params = base.get_params(None, locals())\\r\\n return self._get('tracking_domain_list', params)\",\n \"def ListDomains(self, perPage=0, page=1):\\n\\n class Result(Model):\\n domains = ListField(ModelField(Domain))\\n\\n if perPage != 0:\\n headers = {\\\"perPage\\\": perPage, \\\"page\\\": page}\\n response = self.client.http_get(\\\"/v4/domains\\\", headers)\\n else:\\n response = self.client.http_get(\\\"/v4/domains\\\")\\n\\n return parse_response(response, Result)\",\n \"def getDomains(self, company):\\n return self.db.getDomains(company)\",\n \"def list_domain(self, feed_id=None):\\n resources = self.list_resource(feed_id=feed_id, resource_type_id='Host Controller')\\n domains = []\\n if resources:\\n for resource in resources:\\n resource_data = self.get_config_data(\\n feed_id=resource.path.feed_id, resource_id=resource.id)\\n domain_data = resource_data.value\\n domains.append(Domain(resource.id, resource.name, resource.path, domain_data))\\n return domains\",\n \"def list_domain(self, feed_id=None):\\n domains = self.list_resource(feed_id=feed_id,\\n resource_type_id='Domain Host',\\n cls=Domain,\\n list_children=True,\\n include_data=True)\\n return domains\",\n \"def domains(self) -> pulumi.Output[Sequence[str]]:\\n return pulumi.get(self, \\\"domains\\\")\",\n \"def list_keystone_v3_domains(self):\\n LOG_OBJ.debug(\\\"List the domains.\\\")\\n\\n _url = \\\"http://\\\" + self.host_ip + \\\":35357/v3/domains\\\"\\n _headers = {'x-auth-token': self.cloud_admin_info[\\\"token_domain\\\"],\\n 'content-type': 'application/json'}\\n _body = None\\n\\n response = self.request(\\\"GET\\\", _url, _headers, _body)\\n\\n if response is None:\\n LOG_OBJ.error(\\\"No response from Server while creating domain\\\")\\n print (\\\"No response from Server while creating domain\\\")\\n return response\\n\\n if response.status not in [200, 201, 202, 203, 204]:\\n LOG_OBJ.error(\\\" Listing domains Failed with status %s \\\"\\n \\\"and error : %s\\\" % response.status, response.data)\\n print (\\\" Listing domains Failed with status %s and error : %s\\\" %\\n response.status, response.data)\\n return response.status\\n\\n output = json.loads(response.data)\\n LOG_OBJ.info(\\\"Domains list : %s \\\" % output)\\n print (\\\"Domains list : %s \\\" % output)\\n return output['domains']\",\n \"def domains(cls):\\n return [cls.domain]\",\n \"def list_zones(self, **kwargs):\\r\\n return self.client['Account'].getDomains(**kwargs)\",\n \"def domains(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"domains\\\")\",\n \"def domain_list_all(self):\\n page = 1\\n on_page = 100\\n ret = []\\n while True:\\n r = self.domain_list(page=page, on_page=on_page)\\n ret += r['domains']\\n if len(ret) >= r['total']:\\n break\\n page += 1\\n return ret\",\n \"def domain(self):\\n return self.keys()\",\n \"def get_search_domains(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlSrvCfg_GetSearchDomains', self.handle))\",\n \"def domains(self) -> pulumi.Input[Sequence[pulumi.Input['ElastigroupIntegrationRoute53DomainArgs']]]:\\n return pulumi.get(self, \\\"domains\\\")\",\n \"def list_domain_names():\\n pass\",\n \"def list(self, domain):\\n return request(\\n API_LIST.DNS_LIST.value,\\n {\\n 'email': self.email,\\n 'token': self.token,\\n 'domain': domain\\n }\\n )\",\n \"def cb_listdomains(self, cmd):\\n for cur in sorted(self.d.listDomains(),\\n key=lambda x: _domreverse(x['domain'])):\\n print \\\"%(domain)60s %(expiration_date)15s\\\" % cur\",\n \"def get_subdomains(self):\\n\\n response = self.call(method='getSubdomains', args=[self.domainname])\\n subdomains = []\\n for s in response:\\n subdomain = self.subdomain(domain=self.domainname, subdomain=s)\\n subdomains.append(subdomain)\\n return subdomains\",\n \"def list_all():\\n\\n return (_conn.listDefinedDomains() +\\n [_conn.lookupByID(id).name() for id in _conn.listDomainsID()])\",\n \"def get(self, api_key):\\n\\n try:\\n mailgun.list_domains(api_key)\\n return {\\\"api_key\\\": api_key, \\\"valid\\\": True}\\n except:\\n return {\\\"api_key\\\": api_key, \\\"valid\\\": False}\",\n \"def get_search_domains(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlSrvCfgNet_GetSearchDomains', self.handle))\",\n \"def AllowedDomains(self)->list:\\n return self._allowedDomains\",\n \"def _get_domain(self):\\n self.ensure_one()\\n domain = []\\n return domain\",\n \"def domains(cls):\\n return (cls.domain, )\",\n \"def domains(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"domains\\\")\",\n \"def get_dns_list(self):\\n return self.get_ipv4_dns_list()\",\n \"def get_search_domains(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmDevNet_GetSearchDomains', self.handle))\",\n \"def get_dns_records_from_godaddy(self) -> list:\\n\\n headers = {\\\"Authorization\\\": \\\"sso-key {}:{}\\\".format(self.api_key, self.secret_key)}\\n dns_records = []\\n for dns_record in self.dns_records:\\n url = \\\"https://api.godaddy.com/v1/domains/{}/records/{}/{}\\\".format(dns_record[\\\"domain\\\"],\\n dns_record[\\\"dns_record_type\\\"],\\n dns_record[\\\"name\\\"])\\n dns_records.append(get(url, headers=headers).text)\\n return dns_records\",\n \"def get_search_domains(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmCfg_GetSearchDomains', self.handle))\",\n \"def check_domains(self, service_id, service_version):\\n domain_list = self.fastly_cache[service_id]['domain_list']\\n\\n return domain_list\",\n \"def extract_domains(self, resp):\\n return\",\n \"def get_delta_domains():\\n url = os.getenv('DELTAS_URL')\\n if url is None:\\n raise Exception('Delta report URL configuration not set!')\\n\\n json = requests.get(url, timeout=10).json()\\n return [domain\\n for (domain,)\\n in json['values']\\n if dnstwist.is_valid_domain(domain)]\",\n \"def case_search_enabled_domains():\\n return CaseSearchConfig.objects.filter(enabled=True).values_list('domain', flat=True)\",\n \"def list_zones(self):\\n data = self._paginated_request(\\\"/v2/domains\\\", \\\"domains\\\")\\n return list(map(self._to_zone, data))\",\n \"def get_domain(id):\\n return query(WEB_EXAMPLE_BASE + f\\\"/classical/domain/{id}\\\")\",\n \"def get_domains(filename):\\n with open(filename, 'r') as file:\\n result = []\\n for line in file.readlines():\\n domain = line.strip()[1:]\\n result.append(domain)\\n return result\",\n \"def get_dns(self):\\n dns = []\\n for id, user in self.users_by_id.items():\\n if not user.dns:\\n continue\\n for dn in user.dns:\\n dns.append(dn)\\n return dns\",\n \"def domainlist_reversewhois(self, response):\\n data = response.json()\\n for domain in data['response']['domains']:\\n yield(domain.lower())\",\n \"def domains(self):\\n ctx = stack.top\\n if ctx is not None:\\n if not hasattr(ctx, 'simple_domains'):\\n ctx.simple_domains = {}\\n for domain in self.app.config['SIMPLE_DOMAINS']:\\n ctx.simple_domains[domain] = Domain(\\n connection = self.connection,\\n name = domain,\\n )\\n\\n if not hasattr(ctx, 'simple_domain_%s' % domain):\\n setattr(ctx, 'simple_domain_%s' % domain, ctx.simple_domains[domain])\\n\\n return ctx.simple_domains\",\n \"def getlist(self):\\n self.__domainlist.sort()\\n\\n outstr = \\\"{ \\\"\\n for index, domain in enumerate(self.__domainlist):\\n outstr += domain + \\\" \\\"\\n if (index % 50 == 0) and index > 0:\\n outstr += \\\"}\\\\n{ \\\"\\n\\n outstr += \\\"}\\\"\\n\\n return outstr\",\n \"def get_domains_by_provider_url(self, provider_url):\\n\\n domains = \\\\\\n self.storage_controller.get_domains_by_provider_url(provider_url)\\n\\n return domains\",\n \"def info(self):\\n\\n return self.call(method='getDomain', args=[self.domainname])\",\n \"def get_urls(self, queries):\\n domains = defaultdict(list)\\n for q in queries:\\n q = \\\"\\\\\\\"\\\" + q + \\\"\\\\\\\"\\\"\\n results = self.engine.search(q)\\n\\n for result in results: \\n url = result.url\\n domain = self.get_domain(url)\\n domains[domain].append(q) \\n return domains\",\n \"def get_domain_names(self, MaxResults: str = None, NextToken: str = None) -> Dict:\\n pass\",\n \"def get_domain_dns_records(domain):\\n url_suffix = \\\"v1/domains/{}/records\\\".format(domain)\\n ret = _call_endpoint(url_suffix)\\n if isinstance(ret, dict) and ret.get('code', None) == \\\"UNKNOWN_DOMAIN\\\":\\n # e.g. {'code': 'UNKNOWN_DOMAIN', 'message': 'The given domain is not registered, or does not have a zone file'}\\n raise Exception(f\\\"Can't find domain {domain}. Are you sure your API key and secret are correct?: {ret}\\\")\\n return ret\",\n \"def domainlist_reversens(self, response):\\n data = response.json()\\n for domain in itertools.chain(data['response']['primary_domains'], data['response']['primary_domains']):\\n yield(domain.lower())\",\n \"def _list(self, account, page):\\n response = self.client.get(self.get_url(account), data={\\\"page\\\": page})\\n return [\\n DomainResource(**item) for item in response['data']\\n ], response['pagination']\",\n \"def domain(self):\\n return self._get('domain', '/domain/', self.DOMAIN_DATA)\",\n \"def show_domains(self):\\n show_domains(self.system.cavity_gri)\",\n \"def items_by_domain(self, domain: str) -> List[dict]:\\n if not self.connected:\\n raise NotConnected(\\\"Please call connect first.\\\")\\n return [value for key, value in self._states.items() if key.startswith(domain)]\",\n \"def cookieDomains(self):\\n domains = []\\n for cookie in self.cookies():\\n domain = cookie.domain()\\n if domain not in domains:\\n domains.append(domain)\\n \\n return domains\",\n \"def get_storage_domains(cohesity_client):\\n storage_domain_list = cohesity_client.view_boxes.get_view_boxes()\\n for domain in storage_domain_list:\\n exported_res_dict[\\\"Storage Domains\\\"].append(domain.name)\\n return storage_domain_list\",\n \"def allowed_domains(self):\\n if self._allowed_domains is None:\\n uri = \\\"/loadbalancers/alloweddomains\\\"\\n resp, body = self.method_get(uri)\\n dom_list = body[\\\"allowedDomains\\\"]\\n self._allowed_domains = [itm[\\\"allowedDomain\\\"][\\\"name\\\"]\\n for itm in dom_list]\\n return self._allowed_domains\",\n \"def allowed_domains(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"allowed_domains\\\")\",\n \"def public_domain_names(self) -> pulumi.Output[Optional[Sequence['outputs.ContainerPublicDomainName']]]:\\n return pulumi.get(self, \\\"public_domain_names\\\")\",\n \"def get_botnet_domains():\\n\\n fw = \\\"<HTTPS://YOUR_FORTIGATE_IP:YOUR_FORTIGATE_PORT>\\\"\\n\\n path = \\\"/api/v2/monitor/system/botnet-domains/hits/?access_token=\\\"\\n\\n token = \\\"<YOUR_API_KEY>\\\"\\n\\n content_filter = \\\"\\\"\\n\\n if content_filter != \\\"\\\":\\n url = fw + path + token + content_filter\\n else:\\n url = fw + path + token\\n\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\")\\n \\n try:\\n r = requests.get(url, verify=False).json()\\n except Exception:\\n print(\\\"Something went wrong. Is the url correct? Exiting...\\\")\\n sys.exit()\\n\\n for key in r['results']:\\n print()\\n for k,v in key.items():\\n print(\\\"{0:6} : {1}\\\".format(k.upper(), str(v)))\",\n \"def get_domains(filters: Optional[Sequence[pulumi.InputType['GetDomainsFilterArgs']]] = None,\\n sorts: Optional[Sequence[pulumi.InputType['GetDomainsSortArgs']]] = None,\\n opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDomainsResult:\\n __args__ = dict()\\n __args__['filters'] = filters\\n __args__['sorts'] = sorts\\n opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)\\n __ret__ = pulumi.runtime.invoke('digitalocean:index/getDomains:getDomains', __args__, opts=opts, typ=GetDomainsResult).value\\n\\n return AwaitableGetDomainsResult(\\n domains=pulumi.get(__ret__, 'domains'),\\n filters=pulumi.get(__ret__, 'filters'),\\n id=pulumi.get(__ret__, 'id'),\\n sorts=pulumi.get(__ret__, 'sorts'))\",\n \"def parse(domains):\\n subdomains = []\\n for domain in domains:\\n url = 'https://urlscan.io/api/v1/search/?q=domain:{}'.format(domain)\\n json_resp = json.loads(requests.get(url).text)\\n subdomains += list(set(find('domain', json_resp)))\\n return list(set(subdomains))\",\n \"def get_dns_servers(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlSrvCfg_GetDnsServers', self.handle))\",\n \"def load_private_domains(self):\\n url = self.lookup(\\\"private_domains_url\\\")\\n p_domains = self._fetcher.get_entities(url)\\n domains = []\\n for domain in p_domains:\\n if 'name' in domain:\\n domains.append({'name': domain['name']})\\n self._domains_private = domains\",\n \"def getIpv4DnsList(self):\\n with self.status._dhcp_status_mutex:\\n if self.status.ipv4_lease_valid is None:\\n return [None]\\n else:\\n return self.status.ipv4_dnslist\",\n \"def get_all_courses(self) -> List[str]:\\n\\n print(\\\"Downloading all Courses from all Domains...\\\")\\n all_courses_url = []\\n for domain in DOMAINS:\\n print(\\\"Selected Domain: \\\", domain)\\n selected_domain_url = ROOT_URL + \\\"/\\\" + domain\\n courses, courses_url = self.get_courses(selected_domain_url)\\n all_courses_url += courses_url\\n\\n return all_courses_url\",\n \"def get_ipv4_dns_list(self):\\n \\n ipv4_dns_list = self._dhcp_client_ctrl.getIpv4DnsList()\\n if ipv4_dns_list is None:\\n return [None]\\n else:\\n return map(unicode, ipv4_dns_list)\",\n \"def get_domain_whitelist(self):\\n whitelist = self.charm_config[\\\"federation-domain-whitelist\\\"]\\n return list(filter(None, whitelist.split(\\\",\\\")))\",\n \"def domains(cls) -> Set[str]:\\n return set(cls.langs.values())\",\n \"def listRR(self):\\n reply = self.rpc.getSubdomains(self.username,\\n self.password,\\n self.domain)\\n\\n if len(reply) and reply[0] in ('UNKNOWN_ERROR',\\n 'RATE_LIMITED'):\\n raise Exception(\\\"RPC returned error: \\\" + reply[0])\\n return reply\",\n \"def get_domains(self, ID, domain_type):\\n \\n try:\\n record = self.database[ID]\\n except KeyError:\\n return -1\\n domain_type = domain_type.lower()\\n if domain_type == 'pfam':\\n doms = record[\\\"pfam_domains\\\"]\\n elif domain_type == 'uniprot':\\n doms = record[\\\"uniprot_domains\\\"]\\n else:\\n print \\\"%s is an unrecognized domain type. Use 'pfam' or 'uniprot'\\\"%(domain_type)\\n return -2\\n \\n doms_raw=doms.split(\\\";\\\")\\n doms_clean =[]\\n for i in doms_raw:\\n if i:\\n tmp = i.strip()\\n tmp = tmp.split(\\\":\\\")\\n if len(tmp)>=2:\\n name, sites = tmp\\n tmp = sites.split(\\\"-\\\")\\n doms_clean.append((name, tmp[0], tmp[1]))\\n else:\\n print \\\"ERROR: the domain did not match expected %s\\\"%(i)\\n #doms_clean.append((tmp, -1, -1))\\n return doms_clean\",\n \"def __parse_domains(self, lines):\\n domain_list = []\\n for line in lines:\\n if len(line) == 0:\\n continue\\n if line[0] == \\\"!\\\":\\n continue\\n if line[0] == \\\"|\\\":\\n continue\\n if line[0] == \\\"@\\\":\\n continue\\n if line[0] == \\\"[\\\":\\n continue\\n if line.find('zh.wikipedia.org') == 0:\\n continue\\n line = string.replace(line, \\\"||\\\", \\\"\\\").lstrip(\\\".\\\")\\n # strip everything from \\\"/\\\" to the end\\n if line.find(\\\"/\\\") != -1:\\n line = line[0:line.find(\\\"/\\\")]\\n if line.find(\\\"*\\\") != -1:\\n continue\\n if line.find(\\\".\\\") == -1:\\n continue\\n # if line in oklist:\\n # \\tcontinue\\n domain_list.append(line)\\n\\n return domain_list\",\n \"def disable_all_domains_always_in_scope(self, apikey=''):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/disableAllDomainsAlwaysInScope/', {'apikey': apikey})))\",\n \"def enable_all_domains_always_in_scope(self, apikey=''):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/action/enableAllDomainsAlwaysInScope/', {'apikey': apikey})))\",\n \"def domainlist_reverseip(self, response):\\n data = response.json()\\n for ip in data['response']['ip_addresses']:\\n for domain in ip['domain_names']:\\n yield(domain.lower())\",\n \"def domain(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"domain\\\")\",\n \"def test_client_get_domains(mocker, client_all_domains_input):\\n mocker.patch(\\\"tracker_client.client.get_auth_token\\\")\\n mocker.patch(\\\"tracker_client.client.create_client\\\")\\n test_client = Client()\\n test_client.execute_query = mocker.MagicMock(return_value=client_all_domains_input)\\n\\n domain_list = test_client.get_domains()\\n\\n test_client.execute_query.assert_called_once_with(\\n queries.GET_ALL_DOMAINS, {\\\"after\\\": \\\"abc\\\", \\\"search\\\": \\\"\\\"}\\n )\\n assert domain_list[0].domain_name == \\\"foo.bar\\\"\\n assert domain_list[1].dmarc_phase == \\\"not implemented\\\"\\n assert domain_list[2].last_ran == \\\"2021-01-27 23:24:26.911236\\\"\\n assert domain_list[0].dkim_selectors == []\",\n \"def fetch_domain_certs(domain):\\n url = BASE_URL.format(domain)\\n result = requests.get(url)\\n if result.status_code != 200:\\n result.raise_for_status()\\n return result.json()\",\n \"def get_dns_servers(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlSrvCfgNet_GetDnsServers', self.handle))\",\n \"def domain(self, id_or_name):\\n return DomainCollection(self.request).find(id_or_name)\",\n \"def domain(self):\\n return self['domain']\",\n \"def list_zones(self):\\n action = \\\"/api_dns_list.asp\\\"\\n if self.reseller_id is not None:\\n action = \\\"/api_dns_list_reseller.asp\\\"\\n zones = self.connection.request(action)\\n if len(zones.body) == 0:\\n return []\\n else:\\n return self._to_zones(zones.body)\",\n \"def dict_of_domains(fc):\\r\\n # need to find root database (GDB or SDE)\\r\\n db_root = os.path.dirname(fc)\\r\\n while db_root[-4:].lower() != '.gdb' and db_root[-4:].lower() != '.sde':\\r\\n old_db_root = db_root # protect against infinite loop\\r\\n db_root = os.path.dirname(db_root)\\r\\n if old_db_root == db_root: # protect against infinite loop\\r\\n break\\r\\n arcpy.AddMessage(\\\"Retrieving Domains from \\\" + str(db_root))\\r\\n return {domain.name: domain.codedValues for domain in arcpy.da.ListDomains(db_root)}\",\n \"def list_availability_domains(self, compartment_id, **kwargs):\\n resource_path = \\\"/availabilityDomains\\\"\\n method = \\\"GET\\\"\\n\\n expected_kwargs = [\\\"retry_strategy\\\"]\\n extra_kwargs = [_key for _key in six.iterkeys(kwargs) if _key not in expected_kwargs]\\n if extra_kwargs:\\n raise ValueError(\\n \\\"list_availability_domains got unknown kwargs: {!r}\\\".format(extra_kwargs))\\n\\n query_params = {\\n \\\"compartmentId\\\": compartment_id\\n }\\n query_params = {k: v for (k, v) in six.iteritems(query_params) if v is not missing and v is not None}\\n\\n header_params = {\\n \\\"accept\\\": \\\"application/json\\\",\\n \\\"content-type\\\": \\\"application/json\\\"\\n }\\n\\n retry_strategy = self.retry_strategy\\n if kwargs.get('retry_strategy'):\\n retry_strategy = kwargs.get('retry_strategy')\\n\\n if retry_strategy:\\n return retry_strategy.make_retrying_call(\\n self.base_client.call_api,\\n resource_path=resource_path,\\n method=method,\\n query_params=query_params,\\n header_params=header_params,\\n response_type=\\\"list[AvailabilityDomain]\\\")\\n else:\\n return self.base_client.call_api(\\n resource_path=resource_path,\\n method=method,\\n query_params=query_params,\\n header_params=header_params,\\n response_type=\\\"list[AvailabilityDomain]\\\")\",\n \"def get_dns(self) -> Set:\\n if self.dn_set.should_update():\\n contacts_data = self.get_contacts_data()\\n self.dn_set.update(set(contacts_data.get_dns()))\\n return self.dn_set.data\",\n \"def public_domain_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ContainerPublicDomainNameArgs']]]]:\\n return pulumi.get(self, \\\"public_domain_names\\\")\",\n \"def getIPs(self, domain = \\\"localhost\\\"):\\n # convert 'domain' to string, in case of erroneous type being passed\\n domain = str(domain)\\n\\n # Kind warning for those who entered an IP address instead of a domain\\n try: \\n inet_aton(domain)\\n print(\\\"Warning: an IP address was given instead of a domain name.\\\")\\n except:\\n pass\\n\\n # Try to query DNS records to populate A-Record IP list\\n # Prints errors and returns None if exceptions found\\n try:\\n iplist = gethost(domain)[2]\\n except gaierror as ge:\\n if ge.errno == -2:\\n print(\\\"Error: Domain '{}' invalid, or unknown. \\\"\\\\\\n \\\"Please check proper spelling and format.\\\\n\\\"\\\\\\n \\\"(e.g.: python dns_get_A_record_IPs.py google.com )\\\".format(domain))\\n elif ge.errno == -3:\\n print(\\\"Error: Domain '{}' unreachable. Please check your connection.\\\".format(domain))\\n return None\\n except timeout:\\n print(\\\"Error: Connection to {} timed out.\\\".format(domain))\\n return None\\n\\n return iplist\",\n \"def domain(self) -> str:\\n return pulumi.get(self, \\\"domain\\\")\",\n \"def domain(self) -> str:\\n return pulumi.get(self, \\\"domain\\\")\",\n \"def print_all_dns_records():\\n for domain in sorted(get_domains()):\\n dns_records = get_domain_dns_records(domain)\\n print(domain)\\n pprint(dns_records)\\n print(\\\"*\\\" * 50)\\n # TODO: poor man's rate limiter. improve?\\n time.sleep(2)\",\n \"def get_layer_urls(self):\\n urls = []\\n\\n if getattr(self, 'additional_domains'):\\n map(urls.append, (domain for domain in self.additional_domains.split(\\\";\\\") if domain))\\n\\n return urls\",\n \"def get_dns_servers(self):\\n\\t\\treturn handle_to_object(call_sdk_function('PrlVmDevNet_GetDnsServers', self.handle))\",\n \"def get_input_domains():\\n df = pandas.read_excel(\\\"AutoScrapy/files/EBE21 - Top 100 Onlineshops to scrapp.ods\\\", engine=\\\"odf\\\")\\n list_of_addresses = df['Domain'].to_list()\\n list_of_addresses = [(\\\"http://\\\" + address) for address in list_of_addresses]\\n print(list_of_addresses)\\n return list_of_addresses\",\n \"def get(self):\\r\\n url = '{0}/subdomains/{1}'.format(self.parent.get_url(),\\r\\n port.to_u(self.object_id))\\r\\n return http.Request('GET', url), parsers.parse_json\",\n \"def fusion_api_get_login_domains_login_certificates(self, api=None, headers=None, param=''):\\n return self.login_certificates.get(api, headers, param)\",\n \"def option_domains_always_in_scope(self):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/optionDomainsAlwaysInScope/')))\",\n \"def domains_v2():\\n # Is this public?\\n configs = get_configs()\\n if configs['api_requests'] == 'auth':\\n # Auth token in headers\\n try:\\n auth_token = Token.query.filter_by(auth_token=request.headers.get('Authorization')).first()\\n except:\\n return {\\\"alternatives\\\" : \\\"Database Error with token!\\\"}\\n if not auth_token:\\n return {\\\"alternatives\\\": \\\"Unauthorized!\\\"}\\n\\n req_data = request.get_json()\\n url = req_data['url']\\n if not url:\\n return {\\\"alternatives\\\" : 'None'}\\n \\n domain_data = check(url)\\n alternatives = {\\\"alternatives\\\": domain_data['available_alternatives']}\\n return alternatives\",\n \"def by_domains(self):\\n\\t\\t\\n\\t\\t# TODO: use urllib instead\\n\\t\\turl_format = r'^\\\\s*(?:(?P<protocol>\\\\w+)://)?(?P<domain>[\\\\w\\\\d\\\\-\\\\.]+)(?::(?P<port>\\\\d+))?/?(?P<everything_else>.*)$'\\n\\t\\tsites = {}\\n\\t\\tfor line in self.source.lines:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tif self.filter(line):\\n\\t\\t\\t\\t\\tresult = re.match(url_format, line.content.url)\\n\\t\\t\\t\\t\\tif result.group('domain') not in sites.keys():\\n\\t\\t\\t\\t\\t\\tsites[result.group('domain')] = 0\\n\\t\\t\\t\\t\\tsites[result.group('domain')] += int(line.content.size)\\n\\t\\t\\texcept AttributeError:\\n\\t\\t\\t\\tpass\\n\\t\\t\\n\\t\\t# TODO: sort; convert to lists is even better\\n\\t\\t\\n\\t\\treturn sites\",\n \"def list_websites(self):\\r\\n\\r\\n # Fetch websites\\r\\n self.fetch_website_list()\\r\\n\\r\\n # Print website data\\r\\n for website in self.website_list:\\r\\n print(\\\"ID: {0} | Domain: {1} | Name: {2}\\\".format(\\r\\n website['id'], website['domain'], website['name']))\",\n \"def get_domains_from_cert(cert_file):\\n proc = subprocess.Popen([\\\"openssl\\\", \\\"x509\\\", \\\"-in\\\", cert_file, \\\"-noout\\\", \\\"-text\\\"],\\n stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n out, err = proc.communicate()\\n if proc.returncode != 0:\\n raise IOError(\\\"Error loading {0}: {1}\\\".format(cert_file, err))\\n return ACMEClient._parse_domains_from_openssl_output(out.decode('utf8'))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.82744664","0.76725835","0.7275466","0.72130734","0.7188468","0.7123102","0.7106527","0.71019924","0.7034431","0.70254606","0.7023339","0.69961786","0.6931258","0.69296205","0.6853687","0.6843187","0.6822089","0.6772705","0.6753809","0.6742991","0.6693973","0.6681079","0.66689324","0.66550237","0.66511244","0.6635103","0.6612865","0.658361","0.6566474","0.65224487","0.6464172","0.64491","0.6447973","0.64409953","0.63741535","0.6354096","0.6333439","0.62408364","0.62126094","0.60852724","0.6071372","0.6067067","0.60492945","0.6028298","0.5996481","0.5976128","0.5975336","0.5962553","0.5946239","0.591592","0.5915199","0.5886879","0.5875029","0.58622384","0.585843","0.58525467","0.582552","0.58240294","0.58129066","0.5797633","0.5789385","0.5778386","0.5741338","0.57096255","0.5698289","0.56958705","0.5689746","0.56873685","0.56569403","0.5650599","0.5649958","0.56422234","0.5630903","0.5630386","0.5624595","0.5622027","0.5592967","0.5583474","0.5580943","0.5561862","0.55403227","0.5525581","0.5509804","0.5509188","0.5505259","0.55012614","0.5500372","0.5471805","0.5471805","0.54666525","0.54577273","0.54464424","0.5421184","0.5420839","0.54205704","0.54135036","0.5413111","0.5404056","0.54006815","0.5400229"],"string":"[\n \"0.82744664\",\n \"0.76725835\",\n \"0.7275466\",\n \"0.72130734\",\n \"0.7188468\",\n \"0.7123102\",\n \"0.7106527\",\n \"0.71019924\",\n \"0.7034431\",\n \"0.70254606\",\n \"0.7023339\",\n \"0.69961786\",\n \"0.6931258\",\n \"0.69296205\",\n \"0.6853687\",\n \"0.6843187\",\n \"0.6822089\",\n \"0.6772705\",\n \"0.6753809\",\n \"0.6742991\",\n \"0.6693973\",\n \"0.6681079\",\n \"0.66689324\",\n \"0.66550237\",\n \"0.66511244\",\n \"0.6635103\",\n \"0.6612865\",\n \"0.658361\",\n \"0.6566474\",\n \"0.65224487\",\n \"0.6464172\",\n \"0.64491\",\n \"0.6447973\",\n \"0.64409953\",\n \"0.63741535\",\n \"0.6354096\",\n \"0.6333439\",\n \"0.62408364\",\n \"0.62126094\",\n \"0.60852724\",\n \"0.6071372\",\n \"0.6067067\",\n \"0.60492945\",\n \"0.6028298\",\n \"0.5996481\",\n \"0.5976128\",\n \"0.5975336\",\n \"0.5962553\",\n \"0.5946239\",\n \"0.591592\",\n \"0.5915199\",\n \"0.5886879\",\n \"0.5875029\",\n \"0.58622384\",\n \"0.585843\",\n \"0.58525467\",\n \"0.582552\",\n \"0.58240294\",\n \"0.58129066\",\n \"0.5797633\",\n \"0.5789385\",\n \"0.5778386\",\n \"0.5741338\",\n \"0.57096255\",\n \"0.5698289\",\n \"0.56958705\",\n \"0.5689746\",\n \"0.56873685\",\n \"0.56569403\",\n \"0.5650599\",\n \"0.5649958\",\n \"0.56422234\",\n \"0.5630903\",\n \"0.5630386\",\n \"0.5624595\",\n \"0.5622027\",\n \"0.5592967\",\n \"0.5583474\",\n \"0.5580943\",\n \"0.5561862\",\n \"0.55403227\",\n \"0.5525581\",\n \"0.5509804\",\n \"0.5509188\",\n \"0.5505259\",\n \"0.55012614\",\n \"0.5500372\",\n \"0.5471805\",\n \"0.5471805\",\n \"0.54666525\",\n \"0.54577273\",\n \"0.54464424\",\n \"0.5421184\",\n \"0.5420839\",\n \"0.54205704\",\n \"0.54135036\",\n \"0.5413111\",\n \"0.5404056\",\n \"0.54006815\",\n \"0.5400229\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78274804"},"document_rank":{"kind":"string","value":"1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":49,"numItemsPerPage":100,"numTotalItems":95772,"offset":4900,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3Nzg3MDk5MCwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3Nzc4NzQ1OTAsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.2unWAwFfJz69gDILaWer2lVE0zNaJX_EfuyNjxxLV2Xi_OPSP6FocK7kkPCkHJVTfHCvBlXD5V5FRrlHan8UAg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Calculates the output size of the last conv layer. | def _get_conv_out(self, shape) -> int:
conv_out = self.conv(torch.zeros(1, *shape))
return int(np.prod(conv_out.size())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_size(self) -> int:\n return self.output_dim",
"def get_output_shape(self):\n weights = self.W.get_shape().as_list()\n input_size = np.asarray(self.incoming_shape[-3:-1])\n strides = np.asarray(self.strides[-3:-1])\n kernels = np.asarray(weights[0:2])\n num_out... | [
"0.72758055",
"0.7067759",
"0.70510364",
"0.7000888",
"0.68895096",
"0.6863038",
"0.6814944",
"0.68022835",
"0.67512447",
"0.67106795",
"0.6696877",
"0.6696877",
"0.66832334",
"0.66832334",
"0.6663041",
"0.6635598",
"0.6611119",
"0.6571467",
"0.6549242",
"0.65476173",
"0.6491... | 0.6925207 | 5 |
Forward pass through network. Calculates the Q using the value and advantage. | def forward(self, input_x):
adv, val = self.adv_val(input_x)
return val + (adv - adv.mean(dim=1, keepdim=True)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, state):\n x = state\n feature = self.feature_layer(x)\n action_value = self.value_layer(feature)\n advantage = self.advantage_layer(feature)\n \n q_value = action_value + (advantage - advantage.mean(dim=1, keepdim=True))\n return q_value",
"def a... | [
"0.6747889",
"0.62147856",
"0.6128476",
"0.60471773",
"0.6019139",
"0.60117346",
"0.6002128",
"0.5985154",
"0.5965721",
"0.59572846",
"0.5952152",
"0.59481573",
"0.5945076",
"0.5932837",
"0.5910055",
"0.5899582",
"0.5890279",
"0.58570886",
"0.5830228",
"0.5819873",
"0.5801153... | 0.56493485 | 43 |
Gets the advantage and value by passing out of the base network through the value and advantage heads. | def adv_val(self, input_x):
float_x = input_x.float()
base_out = self.conv(input_x).view(float_x.size()[0], -1)
return self.head_adv(base_out), self.head_val(base_out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bias(self):",
"def __get_net_probs(self):\n return np.array([node.value for node in self.net]).reshape(5,5)",
"def net_output(self):\n result = self.gives()\n for k, v in self.needs().items():\n result[k] = result.get(k, 0) - v\n\n return result",
"def forward(self,... | [
"0.5776241",
"0.5750878",
"0.5623462",
"0.54842955",
"0.5386926",
"0.52231693",
"0.52097505",
"0.5113644",
"0.5109669",
"0.5086685",
"0.5073465",
"0.50708735",
"0.5056254",
"0.5033763",
"0.5021825",
"0.5015476",
"0.50106674",
"0.5005514",
"0.4995753",
"0.49826834",
"0.4966393... | 0.5197751 | 7 |
Calculates the output size of the last conv layer. | def _get_conv_out(self, shape) -> int:
conv_out = self.conv(torch.zeros(1, *shape))
return int(np.prod(conv_out.size())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_size(self) -> int:\n return self.output_dim",
"def get_output_shape(self):\n weights = self.W.get_shape().as_list()\n input_size = np.asarray(self.incoming_shape[-3:-1])\n strides = np.asarray(self.strides[-3:-1])\n kernels = np.asarray(weights[0:2])\n num_out... | [
"0.72754544",
"0.70678294",
"0.70496345",
"0.7000903",
"0.68878484",
"0.6862838",
"0.6813435",
"0.6802265",
"0.67503273",
"0.6709293",
"0.6696119",
"0.6696119",
"0.66828674",
"0.66828674",
"0.66640866",
"0.6636642",
"0.66120887",
"0.65727687",
"0.65476394",
"0.6546968",
"0.64... | 0.6926029 | 6 |
Forward pass through network. | def forward(self, input_x) -> Tensor:
conv_out = self.conv(input_x).view(input_x.size()[0], -1)
return self.head(conv_out) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, input):\n\n return self.network(input)",
"def forward(self, input):\n\n return self.network(input)",
"def forward(self, input):\n\n return self.network(input)",
"def forward_pass(self):",
"def... | [
"0.7486405",
"0.7486405",
"0.72931826",
"0.72931826",
"0.72931826",
"0.72568643",
"0.71754724",
"0.70931304",
"0.70689535",
"0.7054133",
"0.69913656",
"0.6969786",
"0.69356275",
"0.69356275",
"0.69356275",
"0.6921335",
"0.6920985",
"0.6747466",
"0.6711534",
"0.67010707",
"0.6... | 0.0 | -1 |
Initializes or resets the paramseter of the layer. | def reset_parameters(self) -> None:
std = math.sqrt(3 / self.in_features)
self.weight.data.uniform_(-std, std)
self.bias.data.uniform_(-std, std) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset_parameters(self, param_init):\n logger.info('===== Initialize %s with lecun style =====' % self.__class__.__name__)\n for n, p in self.named_parameters():\n init_with_lecun_normal(n, p, param_init)",
"def reset_parameters(self):\n init_method = getattr(init, self.initial... | [
"0.75554377",
"0.7497733",
"0.74958974",
"0.73909175",
"0.73410285",
"0.7286859",
"0.7208283",
"0.71635944",
"0.7134587",
"0.71306086",
"0.71203345",
"0.71100825",
"0.71006113",
"0.70917517",
"0.7006945",
"0.69947183",
"0.69425595",
"0.69156086",
"0.6810136",
"0.6797556",
"0.... | 0.6573624 | 38 |
Forward pass of the layer. | def forward(self, input_x: Tensor) -> Tensor:
self.epsilon_weight.normal_()
bias = self.bias
if bias is not None:
self.epsilon_bias.normal_()
bias = bias + self.sigma_bias * self.epsilon_bias.data
noisy_weights = self.sigma_weight * self.epsilon_weight.data + sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, x):\n return self.layers(x)",
"def _forward(self, z):\n raise NotImplementedError(\"Forward shouldn't be called!\")",
"def __feed_forward(self, X):\n # go over all layers\n for layer in self.__layers:\n X = layer.compute_act(X)\n\n return X",
"def f... | [
"0.7267547",
"0.7236484",
"0.72101915",
"0.72012955",
"0.7173363",
"0.7161442",
"0.71286094",
"0.71286094",
"0.71286094",
"0.7043126",
"0.70097",
"0.6996241",
"0.69847035",
"0.69749874",
"0.6956434",
"0.6956434",
"0.694666",
"0.694666",
"0.6942731",
"0.6934393",
"0.69069153",... | 0.0 | -1 |
Takes in a distribution and actions and returns log prob of actions under the distribution. | def get_log_prob(self, pi: Categorical, actions: Tensor):
return pi.log_prob(actions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_log_prob(self, states, actions):\n dist, _ = self.get_dist_and_mode(states)\n log_probs = dist.log_prob(actions)\n log_probs = tf.expand_dims(log_probs, -1) # To avoid broadcasting\n return log_probs",
"def action_log_probs(self, state):\n dist = self.action_distribution(state)\n ... | [
"0.78015953",
"0.76985294",
"0.74659884",
"0.7390132",
"0.7234296",
"0.718054",
"0.71776885",
"0.71425647",
"0.7029758",
"0.694614",
"0.6867766",
"0.67514867",
"0.67146116",
"0.6675534",
"0.66467613",
"0.6508409",
"0.647576",
"0.6389438",
"0.6382274",
"0.63791734",
"0.6377181... | 0.72526956 | 4 |
Takes in a distribution and actions and returns log prob of actions under the distribution. | def get_log_prob(self, pi: Normal, actions: Tensor):
return pi.log_prob(actions).sum(axis=-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_log_prob(self, states, actions):\n dist, _ = self.get_dist_and_mode(states)\n log_probs = dist.log_prob(actions)\n log_probs = tf.expand_dims(log_probs, -1) # To avoid broadcasting\n return log_probs",
"def action_log_probs(self, state):\n dist = self.action_distribution(state)\n ... | [
"0.78019595",
"0.7698052",
"0.74672115",
"0.7391153",
"0.7252926",
"0.71811974",
"0.71788377",
"0.71434426",
"0.7029142",
"0.69469213",
"0.686866",
"0.67506903",
"0.6712733",
"0.6674502",
"0.664789",
"0.6507693",
"0.6476692",
"0.6389269",
"0.63830537",
"0.63797027",
"0.637702... | 0.72346884 | 5 |
Optimizes the distribution of allocations for a set of stock symbols. | def optimize_portfolio(sd=dt.datetime(2008,1,1), ed=dt.datetime(2009,1,1), \
syms=['GOOG','AAPL','GLD','XOM'], gen_plot=False):
# Read in adjusted closing prices for given symbols, date range
dates = pd.date_range(sd, ed)
prices_all = get_data(syms, dates) # automatically adds SPY
prices = prices_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_best_allocation():\n\n # symbols = ['BRCM', 'TXN', 'IBM', 'HNZ'] \n symbols = ['AAPL', 'GOOG', 'IBM', 'MSFT']\n # ['GOOG','AAPL','GLD','XOM']\n basic_portfolio = BasicPortfolio(symbols, dt.datetime(2014, 1, 1), dt.datetime(2014, 12, 31))\n\n alloc = range(4)\n\n sharpe_max = 0\n alloc... | [
"0.6063045",
"0.53763187",
"0.5290051",
"0.52126926",
"0.5207097",
"0.5145416",
"0.50932026",
"0.50518227",
"0.50404334",
"0.49763635",
"0.49679303",
"0.49524197",
"0.48846778",
"0.48805937",
"0.48631468",
"0.4856346",
"0.4832151",
"0.48185173",
"0.48169646",
"0.48079696",
"0... | 0.55457914 | 1 |
Given a starting value and prices of stocks in portfolio with allocations return the portfolio value over time. | def get_portfolio_value(prices, allocs, start_val):
normed = prices/prices.iloc[0]
alloced = np.multiply(allocs, normed)
pos_vals = alloced * start_val
port_val = pos_vals.sum(axis=1)
return port_val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_portvals(start_date, end_date, orders_file, start_val):\n \n #Read order file\n orders = pd.read_csv( orders_file, parse_dates = [0])\n \n #Get symbols making up the portfolio\n stock_symbols = list( set( orders[\"Symbol\"] ) )\n dates = pd.date_range(start_date, end_date)\n \n... | [
"0.7288363",
"0.6751513",
"0.649566",
"0.639736",
"0.6342396",
"0.58377224",
"0.5771629",
"0.57363266",
"0.5704653",
"0.5654795",
"0.56540567",
"0.564203",
"0.5640176",
"0.5620506",
"0.55888516",
"0.55628633",
"0.5536075",
"0.553035",
"0.55150396",
"0.55067617",
"0.5476467",
... | 0.7756678 | 0 |
Calculate sharpe ratio for minimizer. | def get_sharpe_ratio(allocs, prices):
port_val = get_portfolio_value(prices, allocs, start_val=1.0)
sharpe_ratio = get_portfolio_stats(port_val, daily_rf=0.0, samples_per_year=252)[3]
return -sharpe_ratio | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sharpe_ratio(self, r_f):\n return (\n self.cumulative_returns().last('1D').iat[0] - r_f\n ) / self.cumulative_returns().std()",
"def sharpe_ratio(r1, r2, rf, o1, o2, cov):\n def sr(x):\n w1 = x[0]\n w2 = 1 - w1\n\n Rp = w1 * r1 + w2 * r2\n STDEVp = math... | [
"0.6567362",
"0.6437101",
"0.63409936",
"0.6130169",
"0.6042319",
"0.60273135",
"0.5931197",
"0.59244883",
"0.5785139",
"0.5736135",
"0.57228225",
"0.5692179",
"0.5680298",
"0.5669893",
"0.5615704",
"0.5592618",
"0.55892605",
"0.55826575",
"0.55295515",
"0.5504721",
"0.549964... | 0.67490816 | 0 |
Plot stock prices with a custom title and meaningful axis labels. | def plot_normalized_data(df, title="Daily portfolio value and SPY",
xlabel="Date", ylabel="Normalized price"):
plot_data(df/df.iloc[0], title, xlabel, ylabel) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_data(df, title=\"normalized Stock prices\", ylabel=\"Price\", xlabel=\"Date\"):\n plt.clf()\n ax = df.plot(title=title, fontsize=12)\n ax.set_xlabel(xlabel)\n ax.set_ylabel(ylabel)\n plt.savefig('files/output/' + title + '.png')",
"def plot_data(df, title=\"normalized Stock prices\", ylab... | [
"0.731029",
"0.7286386",
"0.68272114",
"0.6824816",
"0.6797167",
"0.67936105",
"0.6715498",
"0.6569525",
"0.64421463",
"0.6384674",
"0.63568515",
"0.634274",
"0.63376296",
"0.6326378",
"0.62356347",
"0.62333536",
"0.6199969",
"0.6193358",
"0.6185668",
"0.618083",
"0.61708236"... | 0.59642863 | 33 |
Creates a SnowflakeSource object. | def __init__(
self,
name: Optional[str] = None,
database: Optional[str] = None,
schema: Optional[str] = None,
table: Optional[str] = None,
query: Optional[str] = None,
event_timestamp_column: Optional[str] = "",
created_timestamp_column: Optional[str] = ""... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_proto(data_source: DataSourceProto):\n return SnowflakeSource(\n field_mapping=dict(data_source.field_mapping),\n database=data_source.snowflake_options.database,\n schema=data_source.snowflake_options.schema,\n table=data_source.snowflake_options.table,\... | [
"0.70331",
"0.5826544",
"0.571125",
"0.56064165",
"0.5491815",
"0.5480783",
"0.5440601",
"0.54300314",
"0.54277056",
"0.5396629",
"0.5375585",
"0.5310123",
"0.5300051",
"0.5264698",
"0.52542096",
"0.5248735",
"0.5194064",
"0.5170257",
"0.51294655",
"0.5129411",
"0.5090866",
... | 0.5692184 | 3 |
Creates a SnowflakeSource from a protobuf representation of a SnowflakeSource. | def from_proto(data_source: DataSourceProto):
return SnowflakeSource(
field_mapping=dict(data_source.field_mapping),
database=data_source.snowflake_options.database,
schema=data_source.snowflake_options.schema,
table=data_source.snowflake_options.table,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def FromProto(cls, proto_obj):\n source = GameSource()\n source.type = proto_obj.type\n if proto_obj.update_time_utc_str:\n source.update_date_time = datetime.strptime(\n proto_obj.update_time_utc_str, tweets.DATE_PARSE_FMT_STR)\n else:\n source.update_date_time = datetime.now()\n ... | [
"0.69648314",
"0.6726757",
"0.62188435",
"0.6085031",
"0.54869676",
"0.53810257",
"0.5301759",
"0.52652085",
"0.5256398",
"0.52558035",
"0.52312374",
"0.5175181",
"0.51523924",
"0.51177007",
"0.5046059",
"0.5044137",
"0.50330454",
"0.50251067",
"0.5004873",
"0.49959263",
"0.4... | 0.8149464 | 0 |
Returns the database of this snowflake source. | def database(self):
return self.snowflake_options.database | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_database(self):\n return self.database",
"def database(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"database\")",
"def database(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"database\")",
"def database(self) -> pulumi.Input[str]:\n ... | [
"0.7446689",
"0.7409722",
"0.7409722",
"0.7361835",
"0.73268086",
"0.70755297",
"0.70755297",
"0.70755297",
"0.70755297",
"0.7035698",
"0.70008326",
"0.70008326",
"0.6984017",
"0.69791114",
"0.6932914",
"0.69217163",
"0.6915366",
"0.6904952",
"0.6886391",
"0.68326914",
"0.683... | 0.85056674 | 0 |
Returns the schema of this snowflake source. | def schema(self):
return self.snowflake_options.schema | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schema(self):\n return self.table_info.schema",
"def get_source_schema(cls) -> dict:\n source_schema = get_base_schema(\n root=True,\n id_=\"source.schema.json\",\n title=\"Source data schema\",\n description=\"Schema for the source data, files and di... | [
"0.7523006",
"0.7474272",
"0.731446",
"0.72799426",
"0.7248296",
"0.72096664",
"0.72077894",
"0.7188622",
"0.71739715",
"0.71583384",
"0.7152522",
"0.71101445",
"0.6935228",
"0.68277",
"0.6764784",
"0.67362326",
"0.67253757",
"0.6720299",
"0.67055655",
"0.6627854",
"0.6607061... | 0.8667721 | 0 |
Returns the table of this snowflake source. | def table(self):
return self.snowflake_options.table | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTable(self):\n return self.table",
"def _get_table(self):\n\t\treturn self._table",
"def get_tablename(self):\n return self.ds_table",
"def getTable(self):\n\n raise NotImplementedError",
"def table(self):\n if not self.exists:\n return None\n return sel... | [
"0.7333813",
"0.72519577",
"0.7144599",
"0.7141145",
"0.6996592",
"0.6968488",
"0.6951184",
"0.6948223",
"0.69295055",
"0.69295055",
"0.68013984",
"0.6795885",
"0.674512",
"0.66221476",
"0.65775824",
"0.6573351",
"0.6545",
"0.65317136",
"0.6509364",
"0.6500206",
"0.6481945",
... | 0.8042992 | 0 |
Returns the snowflake options of this snowflake source. | def query(self):
return self.snowflake_options.query | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_options(self):\n\t\treturn self.options",
"def options(self):\r\n return self._options",
"def options(self):\n return self.__options",
"def options(self) -> Mapping[str, str]:\n return pulumi.get(self, \"options\")",
"def _get_options(self):\n return self.options",
"def option... | [
"0.7124274",
"0.7121195",
"0.70052445",
"0.7004528",
"0.70010746",
"0.6985663",
"0.6985663",
"0.6985663",
"0.6985663",
"0.6985663",
"0.67881876",
"0.6759905",
"0.6664762",
"0.65246856",
"0.64745015",
"0.64547145",
"0.64213645",
"0.63637906",
"0.6305649",
"0.62842727",
"0.6252... | 0.59917724 | 30 |
Converts a SnowflakeSource object to its protobuf representation. | def to_proto(self) -> DataSourceProto:
data_source_proto = DataSourceProto(
type=DataSourceProto.BATCH_SNOWFLAKE,
field_mapping=self.field_mapping,
snowflake_options=self.snowflake_options.to_proto(),
)
data_source_proto.event_timestamp_column = self.event_ti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_proto(data_source: DataSourceProto):\n return SnowflakeSource(\n field_mapping=dict(data_source.field_mapping),\n database=data_source.snowflake_options.database,\n schema=data_source.snowflake_options.schema,\n table=data_source.snowflake_options.table,\... | [
"0.71726424",
"0.6312265",
"0.57572246",
"0.56970835",
"0.5353327",
"0.5324823",
"0.52810025",
"0.5244373",
"0.51959056",
"0.51375407",
"0.51266086",
"0.51017046",
"0.50727355",
"0.50727355",
"0.5006445",
"0.5004341",
"0.49543244",
"0.48841015",
"0.48770934",
"0.48703986",
"0... | 0.7205786 | 0 |
Returns a string that can directly be used to reference this table in SQL. | def get_table_query_string(self) -> str:
if self.database and self.table:
return f'"{self.database}"."{self.schema}"."{self.table}"'
elif self.table:
return f'"{self.table}"'
else:
return f"({self.query})" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def table_name() -> str:\n pass",
"def __repr__(self):\n cls_name = self.__class__.__name__\n conn_name = str(self._connection)\n tbl_name = self._table\n return '{0}({1}, table={2!r})'.format(cls_name, conn_name, tbl_name)",
"def __repr__(self):\n cls_name = self.__cl... | [
"0.72242546",
"0.7145293",
"0.7145293",
"0.71200347",
"0.70594376",
"0.70300525",
"0.6961341",
"0.6907269",
"0.6881874",
"0.6875941",
"0.68361664",
"0.68174165",
"0.68159",
"0.6803258",
"0.67897487",
"0.67895746",
"0.67832047",
"0.6771481",
"0.6731299",
"0.67075336",
"0.66725... | 0.76032066 | 0 |
Returns a mapping of column names to types for this snowflake source. | def get_table_column_names_and_types(
self, config: RepoConfig
) -> Iterable[Tuple[str, str]]:
from feast.infra.offline_stores.snowflake import SnowflakeOfflineStoreConfig
from feast.infra.utils.snowflake_utils import (
execute_snowflake_statement,
get_snowflake_conn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_column_types(self, table_name):\n\n curs = self.cursor()\n curs.execute('PRAGMA table_info(%s)' % table_name)\n\n types = {str(d[1].lower()): _TYPE_MAP[d[2].split()[0]] for d in curs.fetchall()}\n\n curs.close()\n\n return types",
"def to_schema(cls):\n result = ... | [
"0.73652345",
"0.6958067",
"0.69160265",
"0.6754187",
"0.6642904",
"0.66274935",
"0.6622891",
"0.6481625",
"0.6360409",
"0.63488346",
"0.63274217",
"0.6270515",
"0.6258899",
"0.6238819",
"0.61439264",
"0.6115824",
"0.6091439",
"0.6059644",
"0.59835035",
"0.59506655",
"0.59282... | 0.6247801 | 13 |
Returns the snowflake SQL query referenced by this source. | def query(self):
return self._query | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query(self):\n return self.snowflake_options.query",
"def sql_query(self):\n return self._project.sql_query",
"def get_sql_connection(self):\n return self.sql",
"def sql(self):\n return ';\\n'.join([x.sql() for x in self._statements]) + ';'",
"def get_query(self):\n c... | [
"0.7604513",
"0.7548185",
"0.644608",
"0.636173",
"0.62809396",
"0.6275104",
"0.6264084",
"0.62564576",
"0.6220409",
"0.60543776",
"0.59246194",
"0.5899583",
"0.58373946",
"0.57994354",
"0.57862854",
"0.5758391",
"0.57509285",
"0.5746539",
"0.5732655",
"0.56832737",
"0.567286... | 0.57847404 | 17 |
Sets the snowflake SQL query referenced by this source. | def query(self, query):
self._query = query | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sql_query(self, new_query):\n self._project.sql_query = new_query",
"def set_sa_query(self, query):\n self.sa_query = query",
"def query(self):\n return self.snowflake_options.query",
"def set_query(self, query):\n query = pylastica.query.Query.create(query)\n data = qu... | [
"0.72115916",
"0.6802297",
"0.6187164",
"0.6164766",
"0.60703343",
"0.6025312",
"0.5980297",
"0.5747391",
"0.57371366",
"0.57371366",
"0.57371366",
"0.5711442",
"0.55724436",
"0.55319154",
"0.5473519",
"0.54341775",
"0.54232275",
"0.5422666",
"0.5417376",
"0.5378323",
"0.5360... | 0.59033763 | 7 |
Returns the database name of this snowflake table. | def database(self):
return self._database | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def database_name(self) -> str:\n return pulumi.get(self, \"database_name\")",
"def database_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"database_name\")",
"def getDatabaseName(self):\n return self._base.getDatabaseName()",
"def getDatabaseName(self):\n raise Not... | [
"0.8153906",
"0.79219604",
"0.7853548",
"0.77648026",
"0.7695105",
"0.76031363",
"0.7507584",
"0.74824643",
"0.74470735",
"0.7436588",
"0.7392899",
"0.73886544",
"0.7282045",
"0.7271273",
"0.7229642",
"0.72007596",
"0.7197087",
"0.7124021",
"0.7117816",
"0.7098378",
"0.700156... | 0.5763545 | 71 |
Sets the database ref of this snowflake table. | def database(self, database):
self._database = database | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def table_ref(self, table_ref):\n self._table_ref = table_ref",
"def set_db(self, db):\n self._db = db",
"def db_name(self, db_name):\n\n self._db_name = db_name",
"def setDB(dbname):\n global DBNAME\n DBNAME = dbname",
"def change(cls, db):\n cls.configs['db'] = db\n\n ... | [
"0.69317377",
"0.6532754",
"0.6392685",
"0.5966977",
"0.5806949",
"0.5773162",
"0.5773162",
"0.57592016",
"0.56473815",
"0.56473684",
"0.5647304",
"0.55943197",
"0.5568484",
"0.54553974",
"0.54033595",
"0.53913724",
"0.53913724",
"0.5374103",
"0.5366539",
"0.5345408",
"0.5270... | 0.63701606 | 3 |
Returns the schema name of this snowflake table. | def schema(self):
return self._schema | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schema(self):\n return self.table_info.schema",
"def get_table_name(self):\n return self._table",
"def schema(self):\n return self.snowflake_options.schema",
"def schema_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"schema_name\")",
"def table(self):\n ... | [
"0.7543852",
"0.7407979",
"0.73744506",
"0.72745496",
"0.7205025",
"0.7046401",
"0.70127237",
"0.7001271",
"0.6922719",
"0.6922719",
"0.6922719",
"0.69220996",
"0.6912203",
"0.68869877",
"0.6849201",
"0.6825561",
"0.6613302",
"0.6605695",
"0.66030455",
"0.6539277",
"0.6509380... | 0.5733677 | 56 |
Sets the schema of this snowflake table. | def schema(self, schema):
self._schema = schema | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_schema(self, schema):\r\n self.__schema = schema",
"def schema(self, schema):\n\n self._schema = schema",
"def schema(self, schema):\n\n self._schema = schema",
"def schema(self, schema):\n\n self._schema = schema",
"def set_schema(self, schema, set_num_columns=True):\n ... | [
"0.7617374",
"0.7328084",
"0.7328084",
"0.7328084",
"0.7075173",
"0.6481325",
"0.63790625",
"0.63008064",
"0.6234697",
"0.61715263",
"0.61460024",
"0.61385447",
"0.6092166",
"0.60661066",
"0.60366577",
"0.6025765",
"0.5955309",
"0.59028065",
"0.5798888",
"0.5796591",
"0.57555... | 0.72960466 | 4 |
Returns the table name of this snowflake table. | def table(self):
return self._table | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_table_name(self):\n return self._table",
"def table_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"table_name\")",
"def table_name() -> str:\n pass",
"def table_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"table_name\")",
"def table_name(se... | [
"0.872357",
"0.8587216",
"0.8301262",
"0.82909656",
"0.82909656",
"0.82909656",
"0.82124346",
"0.8067328",
"0.80299294",
"0.8022681",
"0.79793465",
"0.758069",
"0.74290794",
"0.7428557",
"0.7422888",
"0.7326025",
"0.723662",
"0.71609664",
"0.71264887",
"0.7048128",
"0.7046885... | 0.64299667 | 48 |
Sets the table ref of this snowflake table. | def table(self, table):
self._table = table | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def table_ref(self, table_ref):\n self._table_ref = table_ref",
"def setTable(self, tabledef):\n if isinstance(tabledef, str):\n self._table = Table.Get ( tabledef )\n elif isinstance(tabledef, Table):\n self._table = tabledef\n else:\n raise ValueErro... | [
"0.840069",
"0.7259923",
"0.68128806",
"0.6655275",
"0.6641437",
"0.62347263",
"0.61731863",
"0.6130862",
"0.60809314",
"0.6049684",
"0.60375315",
"0.5879953",
"0.58563435",
"0.5758894",
"0.5728879",
"0.5722117",
"0.5694347",
"0.5653783",
"0.5653783",
"0.5530361",
"0.5422365"... | 0.6948597 | 3 |
Creates a SnowflakeOptions from a protobuf representation of a snowflake option. | def from_proto(cls, snowflake_options_proto: DataSourceProto.SnowflakeOptions):
snowflake_options = cls(
database=snowflake_options_proto.database,
schema=snowflake_options_proto.schema,
table=snowflake_options_proto.table,
query=snowflake_options_proto.query,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_proto(self) -> DataSourceProto.SnowflakeOptions:\n snowflake_options_proto = DataSourceProto.SnowflakeOptions(\n database=self.database,\n schema=self.schema,\n table=self.table,\n query=self.query,\n )\n\n return snowflake_options_proto",
"... | [
"0.72627205",
"0.67112297",
"0.6254082",
"0.5537946",
"0.5431298",
"0.54273605",
"0.5401342",
"0.53541476",
"0.53435814",
"0.5294465",
"0.523745",
"0.5237094",
"0.5193706",
"0.5100491",
"0.5098164",
"0.50886667",
"0.50617826",
"0.5013392",
"0.50065786",
"0.49748728",
"0.49595... | 0.8055073 | 0 |
Converts an SnowflakeOptionsProto object to its protobuf representation. | def to_proto(self) -> DataSourceProto.SnowflakeOptions:
snowflake_options_proto = DataSourceProto.SnowflakeOptions(
database=self.database,
schema=self.schema,
table=self.table,
query=self.query,
)
return snowflake_options_proto | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_proto(cls, snowflake_options_proto: DataSourceProto.SnowflakeOptions):\n snowflake_options = cls(\n database=snowflake_options_proto.database,\n schema=snowflake_options_proto.schema,\n table=snowflake_options_proto.table,\n query=snowflake_options_proto.... | [
"0.7185293",
"0.6591346",
"0.63469636",
"0.6190279",
"0.609588",
"0.6037695",
"0.59587693",
"0.57750213",
"0.574301",
"0.5736975",
"0.5731854",
"0.5646835",
"0.5621101",
"0.55236673",
"0.5520179",
"0.54465526",
"0.53726715",
"0.53726715",
"0.53726715",
"0.53726715",
"0.537267... | 0.7964391 | 0 |
Given a dict of lang>names, return a default one | def primary_name(names):
langs = names.keys()
if 'en' in langs:
return names['en']
return names[langs[0]] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def localizedWithFallback(field, allowEmpty=True):\n for lang in [''] + FallbackLanguages():\n t = field[lang]\n if allowEmpty:\n if isinstance(t, basestring):\n return t\n elif t:\n return t\n return u\"\"",
"def fallback_trans(x):\r\n t = _(x)\... | [
"0.60933506",
"0.60726446",
"0.6008112",
"0.5990976",
"0.59868455",
"0.5985267",
"0.5922496",
"0.590694",
"0.58639705",
"0.5810866",
"0.5780663",
"0.5768472",
"0.57512575",
"0.5717193",
"0.5704346",
"0.5672763",
"0.5649485",
"0.56342536",
"0.563318",
"0.5624843",
"0.5548256",... | 0.6597497 | 0 |
Initializes an instance of the InstagramBot class. | def __init__(self, username = None, password = None):
self.username = config['AUTH']['USERNAME']
self.password = config['AUTH']['PASSWORD']
self.login = config['URL']['LOGIN']
self.nav_url = config['URL']['NAV']
self.tag_url = config['URL']['TAGS']
self.direct_url = confi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self):\r\n self._instagram_api = InstagramAPI(mongo_api=self._mongo_api)\r\n self._inst_run()",
"def __init__(self, bot=BNBot):\n self.bot = bot",
"def __init__(self, client_id=None, access_token=None):\r\n if not client_id and not access_token:\r\n raise TypeErr... | [
"0.7040264",
"0.6685926",
"0.66698956",
"0.6649861",
"0.6649861",
"0.6602354",
"0.6402114",
"0.6402114",
"0.62316155",
"0.614077",
"0.6138122",
"0.60492367",
"0.60134923",
"0.5993596",
"0.59222096",
"0.59110945",
"0.5900702",
"0.58524567",
"0.5842189",
"0.5841665",
"0.5826000... | 0.75979745 | 0 |
Method allows user to log in through the web | def login(self):
self.driver.get(self.login)
PAUSE = 2
time.sleep(PAUSE)
user_input = self.driver.find_element_by_name('username')
pass_input = self.driver.find_element_by_name('password')
login_button = self.driver.find_elements_by_xpath("//div[contains(text(),'Log In')]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login(self):",
"def login():",
"def login():",
"def login(self):\n\t\treturn",
"def log_in(self):\n\n # Get login page.\n self.get_endpoint(endpoint=self.config['paths']['login'])\n\n # Post log-in data.\n email_form = self.browser.find_element_by_xpath(\"//input[@id='email'... | [
"0.80300766",
"0.795173",
"0.795173",
"0.78314114",
"0.76917493",
"0.7586301",
"0.7556712",
"0.7542856",
"0.75261706",
"0.7460586",
"0.74421704",
"0.7429035",
"0.74237245",
"0.7412092",
"0.7370598",
"0.73602885",
"0.7355475",
"0.7346966",
"0.7308393",
"0.73024786",
"0.7280960... | 0.7128185 | 29 |
Method allows users to navigate through a user's profile page | def nav_user(self, user):
self.driver.get(self.nav_url.format(user)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def profile_url(self):\n return reverse(\"auth_profile\", args=[self.user.username])",
"def user_view(cls, user, profile):\r\n pass",
"def profile():\n if g.user:\n return render_template('profile.html', user=g.user)\n return redirect(url_for('login'))",
"def user_view(cls, user, p... | [
"0.72839487",
"0.7275138",
"0.72487134",
"0.72350943",
"0.7165833",
"0.70807487",
"0.7042888",
"0.7016116",
"0.69886965",
"0.696752",
"0.6904682",
"0.6819126",
"0.6698022",
"0.6682588",
"0.6592525",
"0.6578378",
"0.6544088",
"0.6506118",
"0.6474697",
"0.64575464",
"0.6455914"... | 0.7264308 | 2 |
Method goes to posts with a specific tag | def search_tag(self, tag):
self.driver.get(self.tag_url.format(tag)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def show_tag(tag, page):\n per_page = current_app.config['POSTS_PER_PAGE']\n tag = Tag.query.filter_by(name=tag).first() or abort(404)\n posts = tag.posts.order_by(Post.id.desc())\n if not session.get('logged_in'): posts = posts.filter_by(visible=True)\n items = posts.limit(per_page).offset((page - ... | [
"0.66354024",
"0.6565476",
"0.649461",
"0.6490434",
"0.6155304",
"0.61414886",
"0.6071974",
"0.6021756",
"0.59992045",
"0.5903175",
"0.5880634",
"0.5843738",
"0.58239686",
"0.5765947",
"0.57510775",
"0.5750838",
"0.5728099",
"0.57190305",
"0.56963086",
"0.56737995",
"0.566945... | 0.61920655 | 4 |
Method allows bot to automatically type and send dm to user | def direct_message(self, user, msg, num):
PAUSE = 1
logging.info('Send message {} to {}'.format(msg,user))
self.driver.get(self.direct_url)
self.driver.find_elements_by_xpath('/html/body/div[2]/div/div/div[2]/div[1]/div/div[2]/input')[0].send_keys(user)
time.sleep(PAUSE)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def send_dm(user, message, embed=None):\n\n if type(user) is discord.User or type(user) is discord.Member:\n if user.dm_channel is None:\n await user.create_dm()\n\n await user.dm_channel.send(message, embed=embed)",
"async def _dm(self, ctx, user: str, *, message: str = None):\... | [
"0.6927895",
"0.67939085",
"0.67668486",
"0.6541166",
"0.63509613",
"0.62982935",
"0.629352",
"0.61479294",
"0.61420435",
"0.6082516",
"0.60807395",
"0.6071102",
"0.59702575",
"0.59686375",
"0.5959844",
"0.59589547",
"0.5958455",
"0.5929721",
"0.58878124",
"0.5874848",
"0.587... | 0.0 | -1 |
Method finds the button to follow or unfollow users. It filters the follow elements to find buttons. The default method looks for only follow buttons. | def find_buttons(self, button_txt):
button = self.driver.find_elements_by_xpath("//*[text()='{}']".format(button_txt))
return button | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def click_to_follow(browser):\n # browser.find_elements_by_css_selector(\"button\")\n # my_button_xpath: str = \"//button\"\n # browser.find_elements_by_xpath(my_button_xpath)\n\n # <button>\n my_follow_btn_xpath: str = \"//button[contains(text(), 'Follow')][not(contains(text(), 'Following'))]\"\n ... | [
"0.7135644",
"0.66539246",
"0.6400043",
"0.63385546",
"0.6108239",
"0.598225",
"0.5863128",
"0.57678187",
"0.5675595",
"0.56031513",
"0.5592132",
"0.556185",
"0.55301255",
"0.5489775",
"0.5486279",
"0.54782057",
"0.547135",
"0.5470326",
"0.54567957",
"0.54306024",
"0.5411247"... | 0.51461345 | 47 |
Method likes a specific number of a user's posts. | def latest_likes(self, user, number_posts, likes):
WAIT = 1
if likes:
action = 'Like'
else:
action = 'Unlike'
self.nav_user(user)
image_container = []
image_container.extend(self.driver.find_elements_by_class_name('_9AhH0'))
for image in im... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def like_user_posts(self, user:str, n_posts:int, like:bool=True):\n\n action = 'Like' if like else 'Unlike'\n\n self._nav_user(user)\n\n imgs = []\n elements = self._find_element(EC.presence_of_all_elements_located((By.CLASS_NAME, '_9AhH0')))\n imgs.extend(elements)\n\n fo... | [
"0.7468292",
"0.7368493",
"0.7155223",
"0.70347476",
"0.6748949",
"0.67359304",
"0.6665075",
"0.6645786",
"0.6584126",
"0.65746444",
"0.6570663",
"0.64926827",
"0.64644575",
"0.64383584",
"0.63599944",
"0.6310028",
"0.6255511",
"0.62522185",
"0.6192657",
"0.6181631",
"0.61792... | 0.67711866 | 4 |
Method gets a list of users who like a post | def get_likes_list(self, username):
api = self.api
api.searchUsername(username)
result = api.LastJson
username_id = result['user']['pk'] #Gets the user ID
user_posts = api.getUserFeed(username_id) # gets the user feed
result = api.LastJson
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user_likes(self, data_base):\n cursor = data_base.cursor(dictionary=True)\n cursor.execute(f\"SELECT user_id FROM user_like WHERE post_id = {self.id}\")\n user_likes = tuple(map(lambda x: str(x['user_id']), cursor.fetchall()))\n if not user_likes:\n return []\n ... | [
"0.80609584",
"0.7395297",
"0.69443375",
"0.6895322",
"0.68074024",
"0.67923427",
"0.6753025",
"0.6566023",
"0.6552493",
"0.63974077",
"0.639381",
"0.6380745",
"0.6334056",
"0.6326958",
"0.6302191",
"0.62897587",
"0.62885493",
"0.62881505",
"0.6275099",
"0.6275099",
"0.623825... | 0.76121527 | 1 |
Initialize a ``TFSPredictor``. See ``sagemaker.RealTimePredictor`` for more info about parameters. | def __init__(self, endpoint_name, sagemaker_session=None,
serializer=json_serializer,
deserializer=json_deserializer,
content_type=None,
model_name=None,
model_version=None):
super(Predictor, self).__init__(endpoint_name, sagem... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_predictor(self):\n try: \n predict_fn = tf.contrib.predictor.from_saved_model(self.saved_path)\n except OSError as err: \n print(f\"OSError: {err}\")\n self._predict_fn = predict_fn",
"def init_tf(FLAGS):\n gpus = tf.config.experimental.list_physical_devic... | [
"0.6117408",
"0.60252637",
"0.5911408",
"0.5851764",
"0.5833206",
"0.57801265",
"0.5762533",
"0.5741081",
"0.57022196",
"0.5699099",
"0.569854",
"0.5625027",
"0.55992603",
"0.5584619",
"0.55735224",
"0.55720514",
"0.556565",
"0.55640054",
"0.55431277",
"0.5542662",
"0.5516902... | 0.5464787 | 24 |
Load sample images for image manipulation. Loads both, ``china`` and ``flower``. Returns | def load_sample_images():
# Try to import imread from scipy. We do this lazily here to prevent
# this module from depending on PIL.
try:
try:
from scipy.misc import imread
except ImportError:
from scipy.misc.pilutil import imread
except ImportError:
raise ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_images(self):\r\n self.standing_frame = [load_image(\"cat1.png\")]\r\n self.walk_frames_r = [load_image(\"cat2.png\"), load_image(\"cat3.png\"),\r\n load_image(\"cat4.png\")]",
"def _preload_all_samples(self):\n if self.mode in ['train_noval', 'train_wit... | [
"0.6988628",
"0.6685474",
"0.66373193",
"0.66370726",
"0.6426989",
"0.6391403",
"0.63717645",
"0.62725484",
"0.62609285",
"0.62502795",
"0.6230983",
"0.62293315",
"0.6186863",
"0.6182871",
"0.61326575",
"0.6113",
"0.6112325",
"0.6069663",
"0.6068178",
"0.6067434",
"0.6062822"... | 0.7011758 | 0 |
Load the numpy array of a single sample image | def load_sample_image(image_name):
images = load_sample_images()
index = None
for i, filename in enumerate(images.filenames):
if filename.endswith(image_name):
index = i
break
if index is None:
raise AttributeError("Cannot find sample image: %s" % image_name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadImage(img_path):\n\n img = Image.open(img_path)\n np_img = np.array(img)\n return (np_img)",
"def load_img(path: str) -> np.ndarray:\n \n return np.array(Image.open(path))",
"def load(path):\n print(\"path\", path)\n print(Path(path).is_file())\n if Path(path).is_fil... | [
"0.6871681",
"0.6734598",
"0.66831964",
"0.6642155",
"0.66406447",
"0.6627881",
"0.65667224",
"0.65525585",
"0.65401435",
"0.6525812",
"0.6514177",
"0.6475732",
"0.645297",
"0.63903517",
"0.63789004",
"0.63789004",
"0.6344578",
"0.6340352",
"0.63352865",
"0.6329638",
"0.63233... | 0.625068 | 28 |
Recreate the (compressed) image from the code book & labels | def recreate_image(codebook, labels, w, h):
d = codebook.shape[1]
image = np.zeros((w, h, d))
label_idx = 0
for i in range(w):
for j in range(h):
image[i][j] = codebook[labels[label_idx]]
label_idx += 1
return image | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recreate_image(codebook, labels, w, h):\n d = codebook.shape[1]\n image = np.zeros((w, h, d))\n label_idx = 0\n for i in range(w):\n for j in range(h):\n image[i][j] = codebook[labels[label_idx]]\n label_idx += 1\n return image",
"de... | [
"0.79495394",
"0.7899799",
"0.7884121",
"0.7781928",
"0.7687692",
"0.60020334",
"0.5997393",
"0.5904447",
"0.58416754",
"0.5806961",
"0.5723574",
"0.5705346",
"0.56988686",
"0.56837463",
"0.5680749",
"0.5661601",
"0.5639231",
"0.55816334",
"0.55626464",
"0.555133",
"0.5549232... | 0.79031765 | 1 |
Custom easyconfig parameters for CrayPEToolchain | def extra_options():
extra_vars = {
'PrgEnv': [None, 'PrgEnv module to load, e.g., cray to load PrgEnv-cray, or None for automatic determination', CUSTOM],
'PrgEnv_load': [True, 'Load the PrgEnv module (if True) or just set the corresponding environment variable (if False)', CUSTOM],
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def config( **kwargs ):",
"def config():",
"def config():",
"def configuration():",
"def get_config(self):\n config = super(Sc2Policy, self).get_config()\n config['eps'] = self.eps\n config['testing'] = self.testing\n return config",
"def config(ctx):\n return",
"def get_... | [
"0.68244946",
"0.6493101",
"0.6493101",
"0.64695317",
"0.63397986",
"0.62136227",
"0.6132952",
"0.60887027",
"0.6073328",
"0.6053588",
"0.60361594",
"0.6020469",
"0.60147214",
"0.6013279",
"0.5986166",
"0.5982526",
"0.5982526",
"0.59803295",
"0.5972104",
"0.59715974",
"0.5953... | 0.5761126 | 51 |
Prepare build environment (skip loaded of dependencies). | def prepare_step(self, *args, **kwargs):
kwargs['load_tc_deps_modules'] = False
super(CrayPEToolchain, self).prepare_step(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_environment():\n global _ENV_SETUP_DONE\n if _ENV_SETUP_DONE:\n return\n _ENV_SETUP_DONE = True\n\n _configure_libraries()\n\n custom_module_path = os.environ.get(\"DETECTRON2_ENV_MODULE\")\n\n if custom_module_path:\n setup_custom_environment(custom_module_path)\n else... | [
"0.68191844",
"0.679081",
"0.6736225",
"0.67010844",
"0.6668821",
"0.66451913",
"0.66270363",
"0.6605766",
"0.6512834",
"0.6408785",
"0.6339571",
"0.63157713",
"0.6313925",
"0.6302971",
"0.6236211",
"0.62336695",
"0.62183577",
"0.6171169",
"0.6163672",
"0.6096524",
"0.6091713... | 0.6293774 | 14 |
Generate load/swap statements for the module file | def make_module_dep(self):
#
# First do some processing of and checks on the parameters
#
# One value that we will need a lot
if self.cfg['PrgEnv_family'] == None:
PrgEnv_family = None
else:
PrgEnv_family = self.cfg['PrgEnv_family'].lower()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exec_module(self, module):\n\n if not self.filename.endswith(config.FILE_EXT) and not self.filename.endswith(\n \"__init__.py\"\n ):\n print(\"Fatal error: ExtensionLoader is asked to load a normal file.\")\n print(\"filename:\", self.filename)\n print(... | [
"0.62639445",
"0.59777355",
"0.5830551",
"0.58056414",
"0.57554215",
"0.57490885",
"0.5679191",
"0.56280315",
"0.55938977",
"0.55713147",
"0.55694884",
"0.55570555",
"0.55020046",
"0.5476978",
"0.5473481",
"0.54465485",
"0.54001313",
"0.53518814",
"0.531311",
"0.5309852",
"0.... | 0.0 | -1 |
Plotting and scaling data | def exercise_6(path_to_data, path_to_figure):
print('='*30)
print('Running exercise_6()')
#### YOUR CODE HERE ####
walk_arr = numpy.loadtxt('data/walk.txt')
#### YOUR CODE HERE ####
# plot the data using matplotlib plot!
plt.plot(walk_arr)
plt.ylabel('Location')
plt.xl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_data(self):",
"def setPlotScaling(x,y):\n dislin.trfscl(x,y)",
"def scale_data(x):\n mu = x.mean(axis=0)\n sigma = x.std(axis=0)\n x = (x - mu) / sigma\n return (x, mu, sigma)",
"def myscale(g, factor=1.0):\n g.setdata(factor * g.getdata())\n # if !g.frozen eq 0 then show",
"d... | [
"0.68279326",
"0.66121054",
"0.64640146",
"0.6433218",
"0.64242774",
"0.6404947",
"0.6313454",
"0.6287877",
"0.61888176",
"0.618611",
"0.61710227",
"0.6164797",
"0.6157777",
"0.6145128",
"0.61247987",
"0.61205786",
"0.61193025",
"0.6103496",
"0.60717255",
"0.60140777",
"0.599... | 0.0 | -1 |
linearly scale the values of an array in the range [0, 1] | def scale01(arr):
walk_arr_01 = numpy.interp(arr, (numpy.amin(arr), numpy.amax(arr)), (-1, +1)) # linear scaling
return walk_arr_01 #return the scaled array
| {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scale0to1(img):\r\n\r\n min = np.min(img)\r\n max = np.max(img)\r\n\r\n if min == max:\r\n img.fill(0.5)\r\n else:\r\n img = (img-min) / (max-min)\r\n\r\n return img.astype(np.float32)",
"def scale0to1(img):\r\n\r\n img = img.astype(np.float32)\r\n\r\n min = np.min(img)\r\n... | [
"0.7274082",
"0.71151817",
"0.7070224",
"0.70607144",
"0.695351",
"0.6909782",
"0.6863304",
"0.683024",
"0.6815376",
"0.68095505",
"0.6759205",
"0.6644985",
"0.6604848",
"0.65765154",
"0.65633816",
"0.65503216",
"0.6484777",
"0.6470204",
"0.644784",
"0.64431757",
"0.64138615"... | 0.7821479 | 0 |
This is a doc string | def exercise_7():
print('=' * 30)
print('Running exercise_7()')
#### YOUR CODE HERE ####
numpy.random.seed(7)
# set the numpy random seed to 7
# This determines how many times we "throw" the
# 2 six-sided dice in an experiment
num_dice_throws = 10000 # don't edit this!
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DocString():\n return",
"def doc_string():\n pass # pass does nothing",
"def get_doc_string(self) -> str:\n r = \"Undocumented\"\n if self.doc is not None: r = self.doc\n return r",
"def raw_doc(self):\n try:\n return str(self.definition.docstr)\n ex... | [
"0.8623083",
"0.8082154",
"0.74954015",
"0.7324442",
"0.7286685",
"0.72765845",
"0.72732335",
"0.71542895",
"0.71460176",
"0.7124491",
"0.70944595",
"0.70730394",
"0.7053277",
"0.70136875",
"0.6961591",
"0.696057",
"0.69478667",
"0.6903653",
"0.69020563",
"0.6898957",
"0.6898... | 0.0 | -1 |
Random vectors and matrices, and some linear algebra operations | def exercise_8():
print("=" * 30)
print("Running exercise_8()")
#### YOUR CODE HERE ####
numpy.random.seed(seed= 7)
# set the numpy random seed to 7
#### YOUR CODE HERE ####
# Set x to a 2-d array of random number of shape (3, 1)
x = numpy.random.rand(3, 1)
print(f'x... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_norm_vector():\n random_state = np.random.RandomState(0)\n for n in range(1, 6):\n v = pr.random_vector(random_state, n)\n u = pr.norm_vector(v)\n assert_almost_equal(np.linalg.norm(u), 1)",
"def random_matrix():\n # Initialize random angles\n theta1 = np.random.rand() *... | [
"0.6085895",
"0.6054807",
"0.59700584",
"0.5968296",
"0.5936185",
"0.59123176",
"0.5900732",
"0.5889028",
"0.58634204",
"0.58405113",
"0.5830244",
"0.580792",
"0.5787771",
"0.57753277",
"0.5718604",
"0.5715407",
"0.5711817",
"0.5695124",
"0.56888473",
"0.5683767",
"0.5669956"... | 0.53885347 | 43 |
Implementing scalar versus vector math | def exercise_9(path_to_X_data, path_to_w_data):
print("="*30)
print("Running exercise_9()")
#### YOUR CODE HERE ####
# load the X and w data from file into arrays
X = numpy.loadtxt('data/X.txt', delimiter=',')
w = numpy.loadtxt('data/w.txt', delimiter=',')
print(f'X:\n{X}')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __div__(self, scalar):\n return Vector(self.x / scalar, self.y / scalar)",
"def scalar_vector_ext(alpha, v, a, b):\n return [alpha * v[0],\n alpha * v[0] * a + b]",
"def uv(vec):\n return vec / sqrt(dot(vec, vec))",
"def __rdiv__(self, scalar):\n return Vector(self.x / ... | [
"0.7258965",
"0.70950174",
"0.6895658",
"0.6889606",
"0.6887228",
"0.68746805",
"0.68746805",
"0.6856566",
"0.6807518",
"0.67988276",
"0.67679286",
"0.67590684",
"0.6742905",
"0.6713513",
"0.6690686",
"0.6619376",
"0.66111094",
"0.6601558",
"0.6597171",
"0.6592091",
"0.659029... | 0.0 | -1 |
extends the init_buffer of OffsetColorProgram class by creating the additional carry flag VBO | def _init_buffers(self, v, n, _):
super()._init_buffers(v, n, _)
self.vbos.append(gl.glGenBuffers(1))
# init VBO 2 - dynamic color data
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbos[3])
loc = self.get_attribute_location("carried")
gl.glEnableVertexAttribArray(loc)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_buffer(self):\n \n self.shape.buf = [pi3d.Buffer(self.shape, self.verts, self.texcoords, self.inds, self.norms)]\n self.shape.set_draw_details(self.shader, [self.spritesheet.img])",
"def setupVAO(self, gpuShape):\n glBindVertexArray(gpuShape.vao)\n\n glBindBuffer(GL_AR... | [
"0.60485387",
"0.5838095",
"0.58365405",
"0.58271587",
"0.58271587",
"0.5774059",
"0.5710976",
"0.5705954",
"0.5652349",
"0.5554869",
"0.5520962",
"0.55178773",
"0.54938525",
"0.53955853",
"0.5374403",
"0.53721666",
"0.5345584",
"0.53194004",
"0.5283975",
"0.5239198",
"0.5213... | 0.69480604 | 0 |
updates the carry flag data (VBO3) | def update_carried(self, data):
self.use()
gpu_data = np.array(data, dtype=np.float32)
gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vbos[3])
gl.glBufferData(gl.GL_ARRAY_BUFFER, gpu_data.nbytes, gpu_data, gl.GL_DYNAMIC_DRAW) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bcs(self, arg):\n\n self.pc += arg if self.p & const.FLAG_CARRY else 0\n self.pc = c_uint16(self.pc).value",
"def bvc(self, arg):\n\n self.pc += arg if not self.p & const.FLAG_OVERFLOW else 0\n self.pc = c_uint16(self.pc).value",
"def update_flags(self):\n # view mode, fi... | [
"0.57576525",
"0.55997807",
"0.55879223",
"0.5496893",
"0.54818845",
"0.5372455",
"0.530587",
"0.5240245",
"0.51702",
"0.5161561",
"0.515714",
"0.5140299",
"0.51236033",
"0.5092073",
"0.50008583",
"0.49901924",
"0.49867123",
"0.49156582",
"0.4907488",
"0.4875377",
"0.48464125... | 0.65785253 | 0 |
Sets scale control bitword = 0 x, y frozen scales + 1 x is interactive + 2 y is interactive bit value 0/1 frozen/interactive | def set_scale_control(self, scale_ctl=3):
self._scale_ctl = scale_ctl | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _force_rescale(self, setpoint_x, setpoint_y):",
"def scale(self,id,x,y,s):\n if id not in self.elements.keys():\n print(\"Id input not registered! Please check your process\")\n return False\n element=self.elements[id]\n state=element.scale(self.h-1-y,x,s,self.w,sel... | [
"0.67285424",
"0.6584716",
"0.6431193",
"0.6370215",
"0.6340126",
"0.6294655",
"0.62531334",
"0.6227982",
"0.6212142",
"0.6209266",
"0.6207113",
"0.6194933",
"0.6148316",
"0.61001164",
"0.6055724",
"0.60446364",
"0.60115176",
"0.6009035",
"0.59821504",
"0.59555095",
"0.591816... | 0.67066544 | 1 |
Run probabilistic road map planning | def prm_planning(start_x, start_y, goal_x, goal_y,
obstacle_x_list, obstacle_y_list, robot_radius, *, rng=None):
obstacle_kd_tree = KDTree(np.vstack((obstacle_x_list, obstacle_y_list)).T)
sample_x, sample_y = sample_points(start_x, start_y, goal_x, goal_y,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n for task in range(1, 6):\n # get map object for the current task\n map_obj = MapObj(task=task)\n # display map\n map_obj.show_map()\n # find cost optimal path using a-star\n node = search(\n map_obj=map_obj,\n heuristic=euclidian_dist... | [
"0.66793424",
"0.64969844",
"0.63846135",
"0.6238592",
"0.61426294",
"0.6089071",
"0.60473144",
"0.6015712",
"0.5973049",
"0.5957199",
"0.5950292",
"0.59151304",
"0.58676654",
"0.585917",
"0.5856333",
"0.5838859",
"0.5832239",
"0.58292663",
"0.58258164",
"0.58152735",
"0.5795... | 0.5963495 | 9 |
Removes all values of arg from the given string | def pippo(value):
return value.replace('BPM', '<abbr title="Banca Popolare di Milano">BPM</abbr>').replace('Rino Snaidero Scientific Foundation', '<a href="http://www.snaiderofoundation.org/">Rino Snaidero Scientific Foundation</a>') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strip_value(value, arg):\n return value.replace(arg, '')",
"def cut_string(value, arg):\n\n return value.replace(arg, '')",
"def cut(value, arg):\n return value.replace(arg, '')",
"def cut(value, arg):\n return value.replace(arg, '')",
"def cut(value,arg):\n return value.replace(arg, '')... | [
"0.7558784",
"0.7307502",
"0.70154285",
"0.70154285",
"0.69781893",
"0.6924862",
"0.676274",
"0.6756168",
"0.67021793",
"0.6586963",
"0.64901525",
"0.6459049",
"0.6459049",
"0.6459049",
"0.6459049",
"0.6459049",
"0.6406707",
"0.6270779",
"0.62498343",
"0.62498343",
"0.6242943... | 0.0 | -1 |
Monta uma API flask e registra seus blueprints. | def setup():
LOG.info("Creating API.")
api = Flask(__name__)
LOG.info("Registering blueprints.")
api.register_blueprint(health_check_blueprint.setup())
LOG.info("Registering error handlers.")
api.register_error_handler(Exception, default_error_handler)
LOG.info("Setting up config variables."... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_blueprints(self):\n # Local import due to flask/blueprint circular imports.\n from mmapi.views import api_bp\n self.app.register_blueprint(api_bp, url_prefix='/api')",
"def register_blueprints_on_app(app):\n app.register_blueprint(views.main_pages)\n app.register_blueprint... | [
"0.7972771",
"0.764559",
"0.7619169",
"0.7566443",
"0.74812996",
"0.74501944",
"0.7441911",
"0.7426413",
"0.7388967",
"0.73659635",
"0.7289081",
"0.7288449",
"0.72654545",
"0.724093",
"0.7233655",
"0.71914",
"0.71732324",
"0.71653473",
"0.71482444",
"0.71245396",
"0.70734113"... | 0.66193205 | 47 |
generate samples of mixture Gaussian distribution | def mix_gaussian(mu, sigma_list, weights, num_sample):
"""
inputs:
-------
mu mean list, numpy array
sigma_list sigma list
weights weights corresponding to each components
num_sample the number of samples
returns:
--------
samples
probability density function (pdf) of mixture Gaussian distribut... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_samples(mu1,cov,number_of_samples):\n samples = np.random.multivariate_normal(mu1, cov,number_of_samples)\n return samples",
"def gen_mixture():\n npr.seed(0)\n num_exp = int(1e4)\n x_dim = 2\n z_dim = 2\n mu1 = [5, 5,]\n mu2 = [-5, -5]\n theta = np.array([[2,1],[-1,-2]])\... | [
"0.71659434",
"0.70966846",
"0.7007388",
"0.6865769",
"0.677201",
"0.67334753",
"0.6702295",
"0.6684492",
"0.6668763",
"0.66618276",
"0.6634252",
"0.6606611",
"0.6601144",
"0.648774",
"0.6463612",
"0.64621603",
"0.6461179",
"0.64429975",
"0.6393839",
"0.6344043",
"0.6344043",... | 0.70466185 | 2 |
Show info to the user depending on verbosity level | def message(self, data, newline="\n"):
# Are we logging to screen, file or both?
if not self.quiet:
print(data)
if self.log_fo:
self.log_fo.write(data + newline)
self.log_fo.flush() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verbosity(v):\n assert v in [0,1,2] # debug, warn, info\n GLOBAL['VERBOSITY'] = v",
"def say(self, verbosity, msg):\n if self.verbosity >= verbosity:\n print(msg)",
"def verbose():\n return Verbose.level()",
"def _verbose(self,text):\n if self.verbose:\n pr... | [
"0.7465201",
"0.7334355",
"0.71003336",
"0.69231784",
"0.6840511",
"0.6791418",
"0.6718375",
"0.6699678",
"0.6693496",
"0.66344607",
"0.6631135",
"0.66225713",
"0.66161317",
"0.6589693",
"0.6587105",
"0.65763825",
"0.65573853",
"0.6548502",
"0.65454394",
"0.6543679",
"0.65303... | 0.0 | -1 |
Wrapper to make an API GET request, return the response and handle errors | def __make_api_get(self, api_path):
try:
self.last_response = urllib2.urlopen(
self.api_server + api_path, cafile=self.cacert_path)
json_data = self.last_response.read()
# Check for errors
except urllib2.HTTPError as err:
error = "API HTTP err... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _http_get(self, url, params={}):\n if not self.token:\n self.get_token()\n headers = {'Authorization': self.token, 'Accept': 'application/json; indent=4'}\n url = self.server + '/api2' + url\n try:\n r = requests.get(url=url, headers=headers, params=params)\n ... | [
"0.778995",
"0.768153",
"0.7418646",
"0.739191",
"0.73206294",
"0.72995013",
"0.7262301",
"0.7259874",
"0.7223338",
"0.7208629",
"0.71811944",
"0.7158694",
"0.7158694",
"0.71570796",
"0.7130304",
"0.7127936",
"0.7122294",
"0.709202",
"0.7063909",
"0.7061155",
"0.70599645",
... | 0.72182447 | 9 |
Wrapper to make an API POST request, return the response and handle errors | def __make_api_post(self, api_path, data=None):
headers = {
"Content-type": "application/json",
"Accept": "application/json"}
x = json.dumps(data)
try:
req = urllib2.Request(self.api_server + api_path, x, headers)
self.last_response = urllib2.urlo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self, *args, **kwargs):\n return self._requests_call(util.requests_post, *args, **kwargs)",
"def make_post_request(api_endpoint: str, data: dict):\n response = requests.post(api_endpoint, data=data)\n logprint_request(api_endpoint)\n\n logprint_response(response)\n log.debug(\"Response di... | [
"0.7550158",
"0.72697294",
"0.72025406",
"0.7184173",
"0.7127111",
"0.7112929",
"0.7065529",
"0.7061984",
"0.70534045",
"0.7048021",
"0.69344455",
"0.6925657",
"0.68850005",
"0.68809766",
"0.68611604",
"0.6811874",
"0.67909265",
"0.6754902",
"0.6729885",
"0.67012155",
"0.6694... | 0.6983514 | 10 |
Validate the response that came back from the API, return True if it's good, False if bad | def _validate_response(self, response):
# Check for unexpected response - all should be JSON dicts that have
# already been deserialised
if not isinstance(response, types.DictionaryType):
self.message(
"\t\t[!] ERROR - Unexpected value returned from the API: '%s'" %
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate(self, response):\n return response[\"status_code\"] == 1",
"def is_valid_response(self, response):\r\n if response.status_code in VALID_CODES:\r\n return True\r\n return False",
"def validate_response(self, response):\n pass",
"def validate_response(respons... | [
"0.8024064",
"0.78625363",
"0.77986264",
"0.7515456",
"0.74777824",
"0.74465626",
"0.73384",
"0.7265737",
"0.7262182",
"0.72441804",
"0.7198832",
"0.712405",
"0.7028976",
"0.701251",
"0.69981617",
"0.69959635",
"0.6970569",
"0.6948191",
"0.6897628",
"0.68025744",
"0.68025744"... | 0.76538676 | 3 |
Validate the supplied json file to make sure it is json in the expected format | def _validate_json(self):
# Do we find valid json?
try:
with open(self.batch_json_path, "rb") as fd:
batch_json = json.loads(fd.read())
except Exception as err:
raise
self.message(
"[-] Error reading JSON batch file '%s' : '%s'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_input(update_file):\n try:\n json.load(open(update_file))\n print \"\\nValid JSON\"\n return True\n except ValueError:\n print \"\\nInvalid JSON\"\n exit(-1)\n return False",
"def validate_input(update_file):\n try:\n json.load(open(update_fi... | [
"0.7859762",
"0.77667236",
"0.7729442",
"0.7575843",
"0.73721087",
"0.7308936",
"0.7206595",
"0.7121494",
"0.708791",
"0.7065255",
"0.7045056",
"0.6959003",
"0.6920872",
"0.6845389",
"0.68421036",
"0.6783331",
"0.6779957",
"0.67763454",
"0.67711896",
"0.67469054",
"0.67342323... | 0.70778465 | 9 |
Get versions of EFI, Boot ROM, OS & Mac Device as well as the SysUUID | def gather_system_versions(self):
# Get Mac model ID
self.hw_version = str(
IORegistryEntryCreateCFProperty(
IOServiceGetMatchingService(
0,
IOServiceMatching("IOPlatformExpertDevice")),
"model",
None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_firmware_version():\r\n return utils.run('crossystem fwid').stdout.strip()",
"def _get_release_infos():\n \n # support RHEL or CentOS, we don't care about the rest...\n with settings(hide('warnings', 'running', 'stdout', 'stderr'), warn_only=True):\n infos = run('cat /etc/redhat-releas... | [
"0.6673707",
"0.6660692",
"0.6526378",
"0.628747",
"0.62810564",
"0.62695277",
"0.62047887",
"0.619877",
"0.6136058",
"0.613013",
"0.61185354",
"0.61024153",
"0.60582775",
"0.6051702",
"0.5979974",
"0.5965632",
"0.59549516",
"0.59407663",
"0.59400725",
"0.5934368",
"0.5919144... | 0.7456519 | 0 |
Send the System info to the API so as the expected EFI version and other data can be returned relevant to this system | def submit_system_data(self, data_to_submit=None):
endpoint = "/apple/oneshot"
# if not data_to_submit:
# data_to_submit = {"hashed_uuid":self.h_sys_uuid, "hw_ver":self.hw_version, "rom_ver":self.efi_version,
# "smc_ver":self.smc_version, "board_id":self.board_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def system_info(self, system_id):\n\n\t\tpath = f'{self.BIKE_ENDPOINT}system/{system_id}/{self.secret_key}'\n\t\tresponse = requests.get(path).json()\n\t\tself.check_api_key(response)\n\n\t\treturn response",
"async def get_system_info(self) -> Dict[str, Any]:\n assert self._client is not None\n re... | [
"0.71641546",
"0.6972458",
"0.6943339",
"0.6877875",
"0.68028116",
"0.6581513",
"0.6516118",
"0.65054244",
"0.6417727",
"0.62935936",
"0.62915426",
"0.6286806",
"0.6262276",
"0.6224786",
"0.6207814",
"0.61550796",
"0.6147702",
"0.6147702",
"0.6147702",
"0.6147702",
"0.6147702... | 0.0 | -1 |
Given the OS version are you running, what is the highest available build number? Are you running it? | def check_highest_build(self, sys_info, api_results):
if not api_results.get("latest_build_number"):
self.results[self.current_endpoint]["latest_build_number"] = self.__make_api_get(
'/apple/latest_build_number/%s' % (".".join(sys_info.get("os_ver").split(".")[:2])))
self.me... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def version_max():\n return VERSION_MAX",
"def get_max_build_version(version: str) -> str:\n return Version(version).bump_minor().get_stable().dumps()",
"def get_build_number():\n try:\n return int(os.getenv(*legion.config.BUILD_NUMBER))\n except ValueError:\n raise Exception('Cannot ... | [
"0.74187696",
"0.71662873",
"0.7020225",
"0.70104754",
"0.6995423",
"0.6940619",
"0.67905074",
"0.6742232",
"0.66234714",
"0.6523554",
"0.65176624",
"0.6482276",
"0.6474209",
"0.6407805",
"0.6395835",
"0.63706833",
"0.63454497",
"0.6344706",
"0.6331214",
"0.6328722",
"0.63287... | 0.7350579 | 1 |
Given your major OS version are you running the latest minor patch? | def check_os_up_to_date(self, sys_info, api_results):
if not api_results.get("latest_os_version"):
self.results[self.current_endpoint]["latest_os_version"] = self.__make_api_get(
'/apple/latest_os_version/%s' % (".".join(sys_info.get("os_ver").split(".")[:2])))
self.message(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def osversion():\n return platform()",
"def minor_version(self):\n return self.unpack_dword(0x18)",
"def operatingsystem_version_minor(self):\n # type: () -> string_types\n return self._operatingsystem_version_minor",
"def get_host_os_minor(self):\n\t\treturn call_sdk_function('PrlSrv... | [
"0.72008204",
"0.68455917",
"0.6837146",
"0.679873",
"0.6781404",
"0.67812794",
"0.675668",
"0.6753822",
"0.6739434",
"0.6729564",
"0.6697316",
"0.6688061",
"0.65758175",
"0.6563506",
"0.65488297",
"0.6537565",
"0.64876926",
"0.6484937",
"0.64745766",
"0.64729935",
"0.6472536... | 0.0 | -1 |
Does it look like this mac model is still receiving EFI firmware updates? | def check_fw_being_updated(self, sys_info, api_results):
if not api_results.get("efi_updates_released"):
# Call the API to see what the latest version of EFI you are
# expected to be running given OS ver and mac model
self.results[
self.current_endpoint]["efi_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gather_system_versions(self):\n # Get Mac model ID\n self.hw_version = str(\n IORegistryEntryCreateCFProperty(\n IOServiceGetMatchingService(\n 0,\n IOServiceMatching(\"IOPlatformExpertDevice\")),\n \"model\",\n ... | [
"0.66273475",
"0.64601934",
"0.63994926",
"0.63584757",
"0.6354337",
"0.6339835",
"0.62948906",
"0.62154347",
"0.62096334",
"0.61546713",
"0.6140502",
"0.61369526",
"0.61060196",
"0.60729986",
"0.6002015",
"0.59328735",
"0.59070283",
"0.58983636",
"0.5769682",
"0.5757605",
"0... | 0.64189225 | 2 |
Compare this systems versions to the firmware table to see if FW is at latest versions | def check_fw_versions(self, sys_info, api_results):
if not api_results.get("latest_efi_version"):
# Call the API to see what the latest version of EFI you are
# expected to be running given OS ver and mac model
api_results[
self.current_endpoint]["latest_efi_v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def firmware_newer(self):\n if self.firmware_outdated():\n return False\n return self.firmware_version != self.compatible_firmware_version",
"def firmware_outdated(self):\n datefmt = ' %b %d %Y %H:%M:%S'\n\n compat_date = self.compatible_firmware_version.split('compiled')[1... | [
"0.70892644",
"0.708643",
"0.70024616",
"0.64528227",
"0.64317346",
"0.64306974",
"0.6340362",
"0.6231141",
"0.61943406",
"0.6168598",
"0.61505914",
"0.612571",
"0.6075346",
"0.60498714",
"0.6030455",
"0.60061157",
"0.59848315",
"0.59787464",
"0.5975126",
"0.59665155",
"0.596... | 0.7005981 | 2 |
Output results in a json format which can be useful to ingest into other tools | def dump_json(self):
# JSON output not requested
if not self.json_results:
return
# Are we writing to a file or stdout?
if self.json_results == "-":
json_results_fd = sys.stdout
else:
try:
json_results_fd = open(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def print_json(results):\r\n import json\r\n stats = calc_stats(results)\r\n print(json.dumps(stats._asdict()))",
"def format_json(self,query_results):\n results=query_results.data\n factory=factory_json()\n dump=factory.dumps(results)\n print(dump)\n # TODO return out... | [
"0.75546306",
"0.7512504",
"0.73262453",
"0.7086924",
"0.698022",
"0.6938096",
"0.6925703",
"0.6855479",
"0.67590535",
"0.67026407",
"0.66884065",
"0.6552769",
"0.64993656",
"0.6483085",
"0.6483022",
"0.64827317",
"0.6453574",
"0.6452356",
"0.64301246",
"0.6410083",
"0.639727... | 0.66968524 | 10 |
Cleanup up so nothing dangles | def cleanup(self):
if self.log_fo:
self.log_fo.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def horde_cleanup(self):",
"def cleanup(self):\n self.subpixel, self.pixel = self.stepup(self.subpixel, self.pixel, AxisDistance.pixelsize)\n self.pixel, self.tile = self.stepup(self.pixel, self.tile, AxisDistance.tilesize)",
"def cleanup():",
"def clean(self):\n for i in range(len(self.... | [
"0.7524904",
"0.7230241",
"0.71339816",
"0.7000594",
"0.6759445",
"0.6759445",
"0.6759445",
"0.66640466",
"0.66440374",
"0.65345025",
"0.6510747",
"0.6510747",
"0.64583874",
"0.64583874",
"0.64583874",
"0.64583874",
"0.64583874",
"0.64583874",
"0.64583874",
"0.64583874",
"0.6... | 0.0 | -1 |
Get a translation for the given message. This proxies for the internal translations object. | def gettext(self, string):
return self._translations.gettext(string) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gettext(self, message):\n if self._translations.has_key(message):\n return self._translations[message]\n return super(Translations, self).gettext(message)",
"def get(self, msgid):\r\n return self.trans.get(msgid, str(msgid))",
"def get_translation(self):\n return self... | [
"0.76010066",
"0.7040674",
"0.66040176",
"0.6410865",
"0.63327235",
"0.6329257",
"0.63121814",
"0.6301266",
"0.62613475",
"0.61739236",
"0.61739236",
"0.6169561",
"0.61192596",
"0.6037068",
"0.60274595",
"0.6026245",
"0.60075307",
"0.5990841",
"0.5933024",
"0.58953375",
"0.58... | 0.5226103 | 59 |
A decorator that can exclude a view from csrf protection. | def exempt(self, view):
if isinstance(view, Blueprint):
self._exempt_blueprints.add(view.name)
return view
if isinstance(view, string_types):
view_location = view
else:
view_location = '%s.%s' % (view.__module__, view.__name__)
self._exempt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def csrf_exempt(view_func):\r\n # We could just do view_func.csrf_exempt = True, but decorators\r\n # are nicer if they don't have side-effects, so we return a new\r\n # function.\r\n def wrapped_view(*args, **kwargs):\r\n return view_func(*args, **kwargs)\r\n wrapped_view.csrf_exempt = True\... | [
"0.81446385",
"0.8072049",
"0.7513782",
"0.7303216",
"0.72622657",
"0.71674573",
"0.67435366",
"0.6682247",
"0.6664801",
"0.6651317",
"0.6612883",
"0.6552151",
"0.64375037",
"0.6431673",
"0.6428775",
"0.63179326",
"0.6248671",
"0.62409854",
"0.621281",
"0.6179554",
"0.6161637... | 0.61926156 | 19 |
A decorator that set the error response handler. | def error_handler(self, view):
self._error_response = view
return view | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def errorhandler(self, status_code_or_exception_class):\n def decorated(f):\n self.error_handlers[status_code_or_exception_class] = f\n return f\n return decorated",
"def error(self, func):\n self.error_handler = func\n return func",
"def on_error(self, namespa... | [
"0.7790632",
"0.77100396",
"0.727186",
"0.70996445",
"0.695573",
"0.6953457",
"0.6853296",
"0.6826386",
"0.67512983",
"0.67437077",
"0.6728367",
"0.669882",
"0.66451806",
"0.6628181",
"0.6596329",
"0.658002",
"0.6575629",
"0.65438235",
"0.6527638",
"0.65149397",
"0.6502375",
... | 0.7654537 | 2 |
Process raw inputs into a dataset. | def build_dataset(words):
count = []
# count.extend(collections.Counter(words).most_common(n_words - 1))
count.extend(collections.Counter(words).most_common())
dictionary = dict()
for word, _ in count:
dictionary[word] = len(dictionary)
data = list()
# unk_count = 0
for word in words:
index = di... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_inputs(self, inputs):",
"def processInputs(self):",
"def input_fn(self, ctx=None):\n sup_dataset = self.supervised_input.make_parsed_dataset(ctx)\n unsup_dataset = self.unsupervised_input.make_parsed_dataset(ctx)\n\n dataset = tf.data.Dataset.zip((sup_dataset, unsup_dataset))\n dataset ... | [
"0.72874445",
"0.6668611",
"0.64020455",
"0.63785404",
"0.63785404",
"0.6376394",
"0.6374364",
"0.62511826",
"0.6218678",
"0.6197006",
"0.61118746",
"0.6104894",
"0.6071575",
"0.60514355",
"0.60514355",
"0.6045758",
"0.6040936",
"0.6020063",
"0.6003791",
"0.59921783",
"0.5986... | 0.0 | -1 |
Make sure the tables are dropped. | def test_drop_tables(self):
self.assertEqual(Manager.table_exists().run_sync(), True)
self.assertEqual(Band.table_exists().run_sync(), True)
drop_tables(Manager, Band)
self.assertEqual(Manager.table_exists().run_sync(), False)
self.assertEqual(Band.table_exists().run_sync(), Fa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drop(self):\n self.__init__()\n cursor = self.connection.cursor()\n cursor.execute(drop_tables)\n queries = cursor.fetchall()\n for i in queries:\n cursor.execute(i[0])\n\n self.commit()\n self.__init__()",
"def drop_tables():\n drop_table(Shoppi... | [
"0.83170086",
"0.824251",
"0.8148625",
"0.80837333",
"0.80614614",
"0.80125594",
"0.80077255",
"0.798122",
"0.79612356",
"0.78991616",
"0.7891649",
"0.7845138",
"0.775593",
"0.77060443",
"0.76956725",
"0.7687249",
"0.7681075",
"0.76451164",
"0.7631582",
"0.76200426",
"0.76058... | 0.7902523 | 9 |
Load multiple datasets (simultaneously) | def processing_handler(
datasets: list, load: Callable[[dict], None], cores: int, threads: int
) -> None:
# Data output
output = []
# Multi-core processing
if cores > 1 and len(datasets) > 1:
# Create process pool
with Pool(cores) as pool:
# Process datasets in pool
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_datasets():\n idx, data_paths, data_names, desc_paths, descrips, sql_paths, \\\n sql_names, loaded, table_size, \\\n loaded_names = mgr.build_datasets_table()\n return render_template('load_datasets.html',\n zip=zip(idx, data_paths, data_names, desc_paths,\n ... | [
"0.68618584",
"0.6650741",
"0.6626212",
"0.66049284",
"0.65869296",
"0.6572509",
"0.6537458",
"0.65346485",
"0.65204453",
"0.65077704",
"0.65056384",
"0.64877063",
"0.64608717",
"0.644231",
"0.64391696",
"0.6436018",
"0.64284915",
"0.6427725",
"0.64143807",
"0.63900393",
"0.6... | 0.0 | -1 |
Load a single CSV file into a DataFrame | def load_handler(
endpoint: str,
path: str,
columns: list,
types: Union[dict, None],
parse_dates: list,
coerce_dates: bool = False,
) -> pd.DataFrame:
try:
# Read CSV file from Meteostat endpoint
df = pd.read_csv(
endpoint + path,
compression="gzip",... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_from_csv(self, filepath):\n self.dataframe = pd.load_csv(filepath, separator='')",
"def _parse_csv(csv_file: str) -> pd.DataFrame:\n return pd.read_csv(csv_file, header=0)",
"def _load_csv_into_df(csv_file: Any, csv_name: str) -> pd.DataFrame:\n try:\n df = pd.read_csv(csv_file... | [
"0.82277906",
"0.8012845",
"0.7859813",
"0.7839427",
"0.7722293",
"0.7609823",
"0.75901395",
"0.7588599",
"0.75861067",
"0.75579536",
"0.7539103",
"0.75356525",
"0.74848354",
"0.7478136",
"0.74515945",
"0.74494445",
"0.7425229",
"0.7384577",
"0.73813176",
"0.73813176",
"0.738... | 0.0 | -1 |
Preprocess graphs by casting into FloatTensor and setting to cuda if available | def preprocess(dataset, cuda):
for g, _ in dataset:
for key_g, val_g in g.ndata.items():
processed = g.ndata.pop(key_g)
processed = processed.type('torch.FloatTensor')
if cuda:
processed = processed.cuda()
g.ndata[key_g] = processed
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_cuda(network):\n network.cuda()\n\n network._to_cuda_forward_cache = network.forward\n\n def cuda_forward(x):\n return network._to_cuda_forward_cache(x.cuda(non_blocking=True))\n\n network.forward = cuda_forward",
"def cuda_if_gpu(T):\n\n return T.cuda() if use_cuda else T",
"def _... | [
"0.5934677",
"0.5921635",
"0.58703035",
"0.581513",
"0.5797795",
"0.5776158",
"0.57602173",
"0.57533664",
"0.5746811",
"0.5742912",
"0.5733459",
"0.5706499",
"0.56763935",
"0.56657827",
"0.5658226",
"0.5653087",
"0.5644797",
"0.5627843",
"0.55857766",
"0.55729073",
"0.5570853... | 0.69795823 | 0 |
The init of this class converts all of the downloaded data into usable lists which can then be analysed or plotted through the use of other functions and modules | def __init__(self, stock, start_date, end_date):
try:
self.data = yahoo_finance.Share(stock).get_historical(start_date, end_date)
self.close = [dic['Close'] for dic in self.data]
self.open = [dic['Open'] for dic in self.data]
self.date = [dic['Date'] for dic in se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self._distance_data = []\n self._location_data = []\n self._package_data = []",
"def __init__(self, dataset_dir, listfile=None):\n Reader.__init__(self, dataset_dir, listfile)\n self._data = [line.split(',') for line in self._data]\n\n def process_i... | [
"0.70053685",
"0.6822351",
"0.68023336",
"0.67671615",
"0.67606527",
"0.6706474",
"0.65779483",
"0.65768045",
"0.65497845",
"0.65438706",
"0.64940745",
"0.64903885",
"0.6471294",
"0.6471034",
"0.6459046",
"0.64494765",
"0.64485466",
"0.6430215",
"0.6430215",
"0.6430215",
"0.6... | 0.0 | -1 |
The delete method has yet to be designed. NOT IN USE | def __delete__(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n ...",
"def delete():",
"def delete(self):\n pass",
"def delete(self):\n pass",
"def delete(self):\n pass",
"def delete(self):\n pass",
"def delete(self):\n raise NotImplementedError",
"def delete(self):\n raise NotImplementedError()... | [
"0.8987653",
"0.8940316",
"0.8721936",
"0.8721936",
"0.8721936",
"0.8721936",
"0.85827905",
"0.84170693",
"0.84170693",
"0.83346015",
"0.83346015",
"0.8312875",
"0.8245658",
"0.81583333",
"0.8149139",
"0.80602145",
"0.80241364",
"0.80155075",
"0.79894155",
"0.7970612",
"0.783... | 0.7856196 | 20 |
Log a message to ``kastle`` logger. | def log(level: str, *messages: str) -> None:
for message in messages:
getattr(logger, level)(message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log(self, message: str):",
"def log(self, message):",
"def log(self, message):\n self._logger.write(message)",
"def log(self, _strMessage=\"\"):\n self.edLogging.log(_strMessage)",
"def log( loglevel, message ):\n E.log( loglevel, message )",
"def log(\n message: str,\n ... | [
"0.6749791",
"0.66110027",
"0.62929875",
"0.61028975",
"0.60638314",
"0.60285443",
"0.6009939",
"0.6003057",
"0.59888184",
"0.5934584",
"0.5918162",
"0.59128755",
"0.5903931",
"0.5870506",
"0.5867751",
"0.58582294",
"0.58571404",
"0.58528185",
"0.5843078",
"0.5834469",
"0.582... | 0.0 | -1 |
Plot the languages stored in the dictionaries | def plot_languages(dict_usage_complexities, dict_cognitive_complexity):
attested_languages = (
frozenset(['nor', 'and', 'or', 'not']),
frozenset(['and', 'or', 'not']),
frozenset(['and', 'not']),
frozenset(['or', 'not']),
)
fig, ax = plt.subplots(figsize=(8.27,4))
for nam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize_vecDict(vecDict):\n for url in vecDict:\n plt.plot(vecDict[url])\n plt.legend([key for key in vecDict])\n plt.title(f'Vectors for {len(vecDict)} Documents')\n plt.xlabel('Vector Dimensions')\n plt.ylabel('Document Value')\n plt.show()",
"def draw_all_plots(self):\n\n ... | [
"0.60507584",
"0.5974315",
"0.5905134",
"0.5861216",
"0.58539575",
"0.57940316",
"0.5775768",
"0.5712009",
"0.57002044",
"0.5681444",
"0.56463766",
"0.5642815",
"0.5637291",
"0.5622407",
"0.5596009",
"0.5593054",
"0.5562897",
"0.55299807",
"0.5506552",
"0.5498803",
"0.5488566... | 0.6960431 | 0 |
Requests frames for a product. | def find(cls, product_id, start=None, end=None, limit=None, sort=None, reruns=None, **kwargs):
return super(ProductFrame, cls).find(product_id=product_id, start=start, end=end,
limit=limit, sort=sort, reruns=reruns, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _request_frame(self):\n self._send_command('GET_FRAME')",
"def GetProduct(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def products(self, star... | [
"0.62623674",
"0.61581105",
"0.55546266",
"0.55507904",
"0.5484503",
"0.5441134",
"0.5407963",
"0.5333419",
"0.5302095",
"0.5175288",
"0.5174018",
"0.5140395",
"0.5135881",
"0.51053953",
"0.5032891",
"0.50136805",
"0.50059825",
"0.49878338",
"0.4946766",
"0.49369532",
"0.4900... | 0.5573586 | 2 |
Requests frames for a product. | def find(cls, forecast_id, start=None, end=None, limit=None, sort=None, reruns=None, **kwargs):
return super(ForecastFrame, cls).find(forecast_id=forecast_id, start=start, end=end,
limit=limit, sort=sort, reruns=reruns, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _request_frame(self):\n self._send_command('GET_FRAME')",
"def GetProduct(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')",
"def find(cls, product_i... | [
"0.62623674",
"0.61581105",
"0.5573586",
"0.55546266",
"0.55507904",
"0.5484503",
"0.5441134",
"0.5407963",
"0.5333419",
"0.5302095",
"0.5175288",
"0.5174018",
"0.5140395",
"0.5135881",
"0.51053953",
"0.5032891",
"0.50136805",
"0.50059825",
"0.49878338",
"0.4946766",
"0.49369... | 0.0 | -1 |
calculate total residual for fits to several data sets held in a 2D array, and modeled by Gaussian functions | def objective(self, params, x, data):
# make residual per data set
ndata, nx = data.shape
resid = 0.0*data[:]
resid[0, :] = data[0, :] - self.thermo(params, x)
resid[1, :] = data[1, :] - self.density(params, x)
# now flatten this to a 1D array, as minimize() needs
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def residual(pars, data= None):\n\n\t\t\tresid = np.array([])\n\n\n\t\t\t# make residual per data set\n\n\t\t\tfor N in range(n_annulus):\n\n\t\t\t\tmdl_ev = 0\n\t\t\t\tr_space_k = rings_pos[N+1] - rings_pos[N] \n\t\t\t\tmask = np.where( (r_n >= rings_pos[N] ) & (r_n < rings_pos[N+1]) )\n\t\t\t\tx,y = XY_mesh[0][m... | [
"0.6726535",
"0.6726535",
"0.6726535",
"0.6638139",
"0.6608545",
"0.6222338",
"0.6214014",
"0.6180789",
"0.61609596",
"0.6121418",
"0.6121418",
"0.6110018",
"0.6100451",
"0.60828114",
"0.602451",
"0.6002838",
"0.59453905",
"0.5928811",
"0.59279364",
"0.5912145",
"0.5909047",
... | 0.5425459 | 65 |
Merge draft invoices. Work only with same partner. You can merge invoices and refund invoices with echa other. Moves all lines on the first invoice. | def merge_invoice(self, cr, uid, invoices, context=None):
order_ids = []
pick_ids = []
if len(invoices) <= 1:
return False
parent = self.pool.get('account.invoice').browse(cr, uid, context['active_id'])
for inv in invoices:
if parent.partner_id != inv.part... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_purchase_invoice(self):\r\n active_id = self.env['purchase.order'].browse(self.env['purchase.order']._context.get('active_ids'))\r\n journal_id = self.env['account.journal'].search([('type', '=', 'purchase')]) \r\n active_id_count = 0\r\n active_count = 0\r\n exist_vend... | [
"0.6526457",
"0.60499185",
"0.6039584",
"0.5971947",
"0.5949904",
"0.5877273",
"0.58699375",
"0.5868027",
"0.5864572",
"0.57496387",
"0.56165034",
"0.5592037",
"0.55525774",
"0.5516271",
"0.5495002",
"0.5483541",
"0.5412485",
"0.5412102",
"0.53373694",
"0.53041404",
"0.529060... | 0.7914905 | 0 |
r"""Return the standard path to the shared area on the current platform. | def shared_area_path() -> str:
try:
return os.environ["OITG_SHARED_AREA"]
except KeyError:
pass
if os.name == "nt": # Windows
return "Z:\\"
if os.name == "unix" or os.name == "posix": # Linux / OSX / ...
return os.path.expanduser("~/steaneShared/")
raise Exception... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_share_path():\n cwd = os.path.dirname(__file__)\n share = os.path.join(cwd, '../share')\n return os.path.abspath(share)",
"def path_share(self) -> Path:\n return self.path_supervisor / SHARE_DATA",
"def get_path(self):\n\t\treturn call_sdk_function('PrlShare_GetPath', self.handle)",
"... | [
"0.75354296",
"0.6952207",
"0.67871875",
"0.67391086",
"0.67256176",
"0.6657467",
"0.6635167",
"0.661767",
"0.66105354",
"0.6436675",
"0.6340287",
"0.6331047",
"0.63205075",
"0.6297639",
"0.62504154",
"0.6217222",
"0.6186836",
"0.6157988",
"0.61453235",
"0.6119978",
"0.611485... | 0.85109854 | 0 |
Return the path to the given users analysis directory on the shared area (``/Users//analysis``). | def analysis_root_path(user: Optional[str] = None) -> str:
if user is None:
user = _get_user()
return os.path.join(shared_area_path(), "Users", user, "analysis") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def todays_analysis_path(day: Optional[str] = None, user: Optional[str] = None) -> str:\n if day is None:\n day = date.today().isoformat()\n if user is None:\n user = _get_user()\n path = os.path.join(analysis_root_path(user=user), day)\n\n if not os.access(path, os.R_OK):\n # If t... | [
"0.6710544",
"0.66245717",
"0.64282644",
"0.61189187",
"0.5994886",
"0.5977346",
"0.5951611",
"0.59258217",
"0.5919063",
"0.5871089",
"0.5855553",
"0.5822797",
"0.5740604",
"0.5706992",
"0.56850857",
"0.5682241",
"0.5660873",
"0.5612151",
"0.5608156",
"0.5605027",
"0.560351",... | 0.84479433 | 0 |
Return the path to the analysis directory for the given day, defaulting to today. The analysis directory is intended to be used as working space for analysing data while it is taken, so that the code can easily be found again later if the data or conclusions reached are reexamined. If the directory does not exist, it i... | def todays_analysis_path(day: Optional[str] = None, user: Optional[str] = None) -> str:
if day is None:
day = date.today().isoformat()
if user is None:
user = _get_user()
path = os.path.join(analysis_root_path(user=user), day)
if not os.access(path, os.R_OK):
# If the dir does n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_day_data_path(self, days_ago=0):\n home = os.environ.get('USERPROFILE').replace('\\\\', '/')\n self.data_dir= os.path.join(home, 'TimeData')\n if not os.path.isdir(self.data_dir):\n mkdir(self.data_dir)\n today_filename = os.path.join(\n self.data_dir,\n ... | [
"0.62076753",
"0.5934615",
"0.59194785",
"0.58207476",
"0.57378083",
"0.5428975",
"0.54136276",
"0.53955543",
"0.5333741",
"0.5282543",
"0.5224942",
"0.519696",
"0.519696",
"0.5180282",
"0.5148305",
"0.51434815",
"0.5098279",
"0.5076191",
"0.5064754",
"0.50544584",
"0.5054282... | 0.7822021 | 0 |
Return the path to an experiment's ARTIQ results directory. The standard results path is ``/artiqResults/``. | def artiq_results_path(experiment: Optional[str] = None) -> str:
path = os.path.join(shared_area_path(), "artiqResults")
if experiment is None:
try:
experiment = os.environ["OITG_EXPERIMENT"]
except KeyError:
raise Exception(
"No experiment supplied, and... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_abex_results_dir(experiment_name: str) -> Path: # pragma: no cover\n return experiment_dir(experiment_name) / \"Results\"",
"def data_abex_results_iteration_dir(experiment_name: str, iteration: int) -> Path: # pragma: no cover\n return data_abex_results_dir(experiment_name) / iteration_name(iter... | [
"0.80512667",
"0.7191955",
"0.68996114",
"0.6845597",
"0.68339694",
"0.66065645",
"0.65667313",
"0.65667313",
"0.65667313",
"0.65351224",
"0.63939637",
"0.6320295",
"0.61587936",
"0.6123075",
"0.60877836",
"0.60146594",
"0.5972927",
"0.5961885",
"0.5882054",
"0.58809346",
"0.... | 0.873001 | 0 |
estimate an MxF user factor matrix and an FxN item factor matrix from the MxN rating matrix | def factor_mat(all_dat, f_num, iterations, regularization):
# get # of users and # of items
[u_num, i_num] = all_dat.shape
# init user factors and item factors with random values
u_fac = np.matrix(np.random.rand(u_num, f_num)) # MxF
i_fac = np.matrix(np.random.rand(i_num, f_num)) # NxF
# calculate the preferen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_matrix(self):\n\n self.matrix = np.zeros((len(self.users), len(self.items)))\n\n for user in self.train_set['users']:\n for item in self.train_set['feedback'][user]:\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\n se... | [
"0.6282623",
"0.62621325",
"0.60587424",
"0.6045789",
"0.6040702",
"0.6002245",
"0.5951851",
"0.59179777",
"0.59059614",
"0.58943605",
"0.589419",
"0.587945",
"0.5858747",
"0.58264637",
"0.5798391",
"0.57919794",
"0.574544",
"0.5737683",
"0.5693354",
"0.5668427",
"0.56560904"... | 0.72323316 | 0 |
calculate the confidence of each useritem pair | def cal_confidence(dat):
alpha = 40.0
confidence = np.zeros(dat.shape)
confidence = 1 + alpha * dat
return np.matrix(confidence) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _predict_user_item(self, user, item):\n if not isinstance(user, int):\n user = self._user_to_ndx[user]\n if not isinstance(item, int):\n item = self._item_to_ndx[item]\n\n try:\n rating_mean = self._averages[user]\n except AttributeError:\n ... | [
"0.6476335",
"0.6331386",
"0.6273888",
"0.62594044",
"0.62203914",
"0.6011443",
"0.58879673",
"0.58871895",
"0.58729005",
"0.58711815",
"0.582148",
"0.57926047",
"0.57851225",
"0.5779903",
"0.57435066",
"0.5729716",
"0.5727403",
"0.57262325",
"0.56652945",
"0.5631243",
"0.560... | 0.50412726 | 94 |
calculate the preference of each useritem pair | def cal_preference(dat):
preference = np.ones(dat.shape)
preference[dat == 0] = 0
return np.matrix(preference) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _predict_user_item(self, user, item):\n if not isinstance(user, int):\n user = self._user_to_ndx[user]\n if not isinstance(item, int):\n item = self._item_to_ndx[item]\n\n try:\n rating_mean = self._averages[user]\n except AttributeError:\n ... | [
"0.6196895",
"0.6023507",
"0.6007207",
"0.59735894",
"0.5927089",
"0.59151995",
"0.5914826",
"0.590741",
"0.5795329",
"0.56757665",
"0.56184",
"0.5602994",
"0.5584905",
"0.55800134",
"0.5564539",
"0.5547924",
"0.55471706",
"0.54899234",
"0.5459986",
"0.5451552",
"0.54258966",... | 0.0 | -1 |
calculate latent factors using the alternating least square method applicable to computing both user factors and item factors | def alternate_ls (u_num, Y, P, C, reg):
# get # of items/users and # of latent factors
[i_num, f_num] = Y.shape
# output buffer
X = np.zeros((u_num, f_num))
# precalculate YtY to improve the performance
YtY = Y.T * Y
# iterate over each user/item
for u in range(u_num):
# store the diagonal elements of th... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_factors():",
"def factors(self):\n X = [Var(i,2) for i in range(self.nvar)]\n factors = [Factor([],np.exp(self.c))] \n # TODO: exclude if zero? or exclude if inf/-inf, or if in \"assigned\", or?\n factors = factors + [Factor([X[i]],[-th,th]).exp() for i,th in enumerate(self.h) if self.dims[i]... | [
"0.6412927",
"0.6364732",
"0.6273934",
"0.59649765",
"0.58943266",
"0.5739722",
"0.56869096",
"0.5642237",
"0.5588103",
"0.55404395",
"0.55167574",
"0.54780066",
"0.54257447",
"0.5419568",
"0.5391013",
"0.53886884",
"0.53792053",
"0.53650635",
"0.53555024",
"0.53386456",
"0.5... | 0.5874729 | 5 |
Get authorization header for GoDaddy Developer API. | def _get_headers() -> dict:
api_key = API_KEY_CRED_LOADER.load_credentials()
api_secret = API_SECRET_CRED_LOADER.load_credentials()
return {"Authorization": "sso-key {}:{}".format(api_key, api_secret)} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_client_authz_header():\n return assemble_authorization_header(API_TOKEN)",
"def api_client_authz_header():\n return assemble_authorization_header(API_TOKEN)",
"def get_authorization_header(self):\n return {\"Authorization\": \"Bearer {}\".format(self.get_jwt())}",
"def get_authorization_... | [
"0.77325",
"0.77325",
"0.7386359",
"0.73046136",
"0.71326786",
"0.70995873",
"0.7064967",
"0.69181406",
"0.67679745",
"0.6723393",
"0.67186785",
"0.66517",
"0.66500354",
"0.66368353",
"0.6635809",
"0.6585172",
"0.6572229",
"0.6569699",
"0.65522623",
"0.65466243",
"0.65304196"... | 0.6833908 | 8 |
Call GoDaddy developer API endpoint. Only supports GET endpoints to keep access readonly. | def _call_endpoint(url_suffix: str, base_url: str = BASE_URL) -> dict:
headers = _get_headers()
url = os.path.join(base_url, url_suffix)
resp = requests.get(url, headers=headers)
return resp.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_call():\n\tresponse = requests.get(URL_API)\n\treturn response",
"def call_api(url):\n\n req = requests.get(url)\n return req",
"def call_api(url):\n\n req = requests.get(url)\n return req",
"def requester(get_args: dict) -> dict:\n get_args.update(dict(apikey = apikey))\n response ... | [
"0.6853146",
"0.6268339",
"0.6268339",
"0.62518954",
"0.62271094",
"0.605959",
"0.60268193",
"0.60259753",
"0.59603226",
"0.59556425",
"0.59494823",
"0.5872682",
"0.5860177",
"0.58262163",
"0.57653207",
"0.5758254",
"0.57468194",
"0.57456577",
"0.5684184",
"0.567575",
"0.5663... | 0.55546147 | 38 |
Get list of Domains for this API key. | def get_domains() -> List[str]:
ret = _call_endpoint("v1/domains")
# Example response:
# [{'createdAt': '2016-06-25T03:08:44.000Z',
# 'domain': 'mydomain.com',
# 'domainId': 12345678,
# 'expirationProtected': False,
# 'expires': '2020-06-25T03:08:44.000Z',
# 'holdRegistrar': False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_domains(self):\n\n response = self.call(method='getDomains')\n domains = []\n for d in response:\n domain = self.domain(domain=d['domain'])\n domains.append(domain)\n return domains",
"def listDomains(self):\n reply = self.rpc.getDomains(self.usern... | [
"0.82744664",
"0.76725835",
"0.7275466",
"0.72130734",
"0.7188468",
"0.7123102",
"0.7106527",
"0.71019924",
"0.7034431",
"0.70254606",
"0.7023339",
"0.69961786",
"0.6931258",
"0.69296205",
"0.6853687",
"0.6843187",
"0.6822089",
"0.6772705",
"0.6753809",
"0.6742991",
"0.669397... | 0.78274804 | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.