list:\\n new_members = []\\n for new_member_data in safe_getter(\\n worker.source, 'message.new_chat_members', default=[], mode='DICT'):\\n participant = get_from_Model(Participant, id=new_member_data['id'])\\n if not participant:\\n participant = user_registry.register_participant(new_member_data)\\n gspd = get_from_Model(\\n participant.groupspecificparticipantdata_set,\\n participant_group=worker['participant_group'], _mode='direct')\\n if not gspd:\\n gspd = user_registry.register_groupspecificparticipantdata(\\n participant=participant,\\n participant_group=worker['participant_group'],\\n joined=datetime.fromtimestamp(\\n worker['message'][\\\"date\\\"], tz=timezone.get_current_timezone()),\\n )\\n new_members.append((participant, gspd))\\n worker.source.new_members_models = new_members\\n return new_members\",\n \"def event_register_collaborator(request, event_id, employee_id):\\n if request.method == 'PUT':\\n event = get_object_or_404(Event, pk=event_id, is_registration_open=True)\\n collaborator = get_object_or_404(Employee, pk=employee_id)\\n event.collaborators.add(collaborator)\\n event.save()\\n serializer = EventSimpleRegistrationSerializer(event)\\n return Response(serializer.data, status=status.HTTP_202_ACCEPTED)\",\n \"async def scan_members(self, ctx):\\n if not ctx.guild.id:\\n return\\n\\n if not await self.bot.guildservice.check_guild(ctx.guild.id):\\n await self.bot.guildservice.add_guild(ctx.guild)\\n\\n async for member in ctx.guild.fetch_members():\\n await self.register_member(member, ctx.guild.id)\\n await asyncio.sleep(0)\\n print(\\\"Usuários salvos com sucesso.\\\")\\n await asyncio.sleep(1)\\n await ctx.message.delete()\",\n \"def team_add(token_user):\\n if not json_param_exists('name') or \\\\\\n not json_param_exists('type'):\\n abort(400, \\\"one or more required parameter is missing\\\")\\n name = request.json['name']\\n team_type = TeamType.query.filter_by(name=request.json['type']).first()\\n if not team_type:\\n abort(400, \\\"invalid team type\\\")\\n\\n if team_type.name == 'other_team':\\n if not token_user.has_permission('team.create') and \\\\\\n not token_user.has_permission('team.create.elevated'):\\n abort(403, 'team creation is not permitted')\\n else: # creating any team other than 'other_team' requires elevated\\n if not token_user.has_permission('team.create.elevated'):\\n abort(403, 'insufficient permissions to create a team of this type')\\n\\n team = Team(name=name)\\n team.team_type = team_type\\n\\n try:\\n get_db().add(team)\\n get_db().commit()\\n except IntegrityError:\\n abort(409, 'team name is already in use')\\n\\n return '', 201\",\n \"def add_member(self, request, pk):\\n farm = self.get_object()\\n user = request.data.get('user')\\n farm.add_member(user)\\n return Response({}, status=status.HTTP_202_ACCEPTED)\",\n \"async def team_url(self, ctx: commands.Context, *users: discord.User):\\n await ctx.send(f'Sending {len(users)} registration URLs to admin stderr')\\n\\n tokens = await asyncio.gather(*[self._token(user=user) for user in users])\\n base_url = await self._register_url()\\n urls = [f'{display(user)}: {os.path.join(base_url, token)}'\\n for user, token in zip(users, tokens)]\\n await self.admin_msg('\\\\n'.join(urls))\",\n \"def test_register_user():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app)\\n team_count = app.db.session.query(app.db.func.count(Teams.id)).first()[0]\\n assert team_count == 2 # There's the admin user and the created user\\n destroy_ctfd(app)\",\n \"def test_teams_add_user_to_team_by_batch_v1(self):\\n pass\",\n \"async def register(self, ctx, osu_link: str, timezone: str = \\\"\\\"): # TODO handle teams + multiples brackets\\n tournament = self.get_tournament(ctx.guild.id)\\n if len(tournament.brackets) != 1:\\n await self.send_reply(ctx, \\\"not_supported_yet\\\")\\n return\\n bracket = tournament.current_bracket\\n if bracket.registration_end_date:\\n registration_end_date = datetime.datetime.strptime(\\n bracket.registration_end_date, tosurnament.DATABASE_DATE_FORMAT\\n )\\n if datetime.datetime.now() > registration_end_date:\\n raise tosurnament.RegistrationEnded()\\n\\n players_spreadsheet = await bracket.get_players_spreadsheet()\\n if not players_spreadsheet:\\n raise tosurnament.NoSpreadsheet(\\\"players\\\")\\n if players_spreadsheet.range_timezone:\\n if not timezone:\\n raise commands.MissingRequiredArgument(timezone)\\n if not re.match(r\\\"(UTC)?[-\\\\+]([0-9]|1[0-4])(:[0-5][0-9])?$\\\", timezone, re.IGNORECASE):\\n raise InvalidTimezone(timezone)\\n timezone = \\\"UTC\\\" + re.sub(r\\\"^UTC\\\", \\\"\\\", timezone, flags=re.IGNORECASE)\\n if players_spreadsheet.range_team_name:\\n await self.send_reply(ctx, \\\"not_supported_yet\\\")\\n return\\n team_info = TeamInfo.get_first_blank_fields(players_spreadsheet)\\n osu_name = osu.get_from_string(osu_link)\\n osu_user = osu.get_user(osu_name, m=tournament.game_mode)\\n if not osu_user:\\n raise tosurnament.UserNotFound(osu_name)\\n team_info.players.append(\\n TeamInfo.PlayerInfo(\\n osu_user.name,\\n str(ctx.author),\\n ctx.author.id,\\n str(osu_user.rank),\\n str(osu_user.rank),\\n str(osu_user.id),\\n str(int(float(osu_user.pp))),\\n str(osu_user.country),\\n )\\n )\\n team_info.timezone.set(timezone)\\n self.add_update_spreadsheet_background_task(players_spreadsheet)\\n roles_to_give = [tosurnament.get_role(ctx.guild.roles, tournament.player_role_id, \\\"Player\\\")]\\n roles_to_give.append(tosurnament.get_role(ctx.guild.roles, bracket.role_id, bracket.name))\\n await ctx.author.add_roles(*filter(None, roles_to_give))\\n try:\\n await ctx.author.edit(nick=osu_user.name)\\n except (discord.Forbidden, discord.HTTPException):\\n pass\\n await self.send_reply(ctx, \\\"success\\\")\",\n \"def test_handle_add_not_admin(self):\\n test_user = User(\\\"userid\\\")\\n test_user.github_username = \\\"githubuser\\\"\\n team = Team(\\\"BRS\\\", \\\"brs\\\", \\\"web\\\")\\n team.github_team_id = \\\"githubid\\\"\\n self.db.retrieve.return_value = test_user\\n self.db.query.return_value = [team]\\n self.assertTupleEqual(self.testcommand.handle(\\\"team add brs ID\\\", user),\\n (self.testcommand.permission_error, 200))\\n self.db.store.assert_not_called()\\n self.gh.add_team_member.assert_not_called()\",\n \"def test_add_member_to_group(client):\\n group = client.add_members_to_group(TEAM_ID, GROUP_ID, 35555)\\n assert group.team_id == TEAM_ID\\n assert group.group_id == GROUP_ID\\n assert 35555 in group.members\",\n \"def register(project_id, runner):\\n pass\",\n \"def test_register_email_as_team_name():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app, name=\\\"user@ctfd.io\\\", email=\\\"user@ctfd.io\\\", password=\\\"password\\\")\\n team_count = app.db.session.query(app.db.func.count(Teams.id)).first()[0]\\n assert team_count == 1 # There's only the admin user\\n destroy_ctfd(app)\",\n \"def add_team_player():\\n if request.form['add_template'] == 'Add Team':\\n return render_template('addteam.html')\\n elif request.form['add_template'] == 'Add Player':\\n teams = get_team()\\n return render_template('addplayer.html', teams=teams)\\n else:\\n return getAllPlayers()\",\n \"def manage_project_members(self, project_name, admin_project_resources,\\n check=True):\\n page_projects = self._page_projects()\\n\\n with page_projects.table_projects.row(\\n name=project_name).dropdown_menu as menu:\\n menu.item_default.click()\\n\\n with page_projects.form_available_members as form:\\n form.item_members(admin_project_resources[\\\"user\\\"].name).click()\\n form.submit()\\n\\n if check:\\n self.close_notification('success')\",\n \"def test_delete_team_member(self):\\n pass\",\n \"def add_member(self, db: Session, *, room: Room, user: User) -> Room:\\n members = [x for x in room.members]\\n members.append(user)\\n return self.update(db=db, db_obj=room, obj_in={\\\"members\\\": members})\",\n \"def register_user():\\n pass\",\n \"def test_remove_team_manager_from_team(self):\\n pass\",\n \"def test_teams_create(self):\\n pass\",\n \"def register(self, user) -> None:\\n self._all_members[user.name] = user\\n if type(user).__name__ == 'LeaderUser':\\n self._leaders.append(user)\",\n \"def add_member(self, request, **kwargs):\\n valid_user = Member.objects.filter(group=self.get_object(), user=self.request.user).values('role_type').first()\\n if valid_user['role_type'] == 'member':\\n return Response({'message': 'You have no right to perform this action'}, status=status.HTTP_403_FORBIDDEN)\\n if request.data.get('phone') is None:\\n return Response({'message': 'Phone number not provided'}, status=status.HTTP_400_BAD_REQUEST)\\n if request.data.get('role') is None:\\n return Response({'message': 'Role is required'}, status=status.HTTP_400_BAD_REQUEST)\\n if request.data.get('display_name') is None:\\n return Response({'message': 'Name is required'}, status=status.HTTP_400_BAD_REQUEST)\\n req_user = request.data.get('phone')\\n user_data = User.objects.get(phone=req_user)\\n if user_data is None:\\n return Response({'message': 'User with this number is not registered'}, status=status.HTTP_404_NOT_FOUND)\\n group = self.get_object()\\n if group.members.filter(user=user_data).count() != 0:\\n return Response({'message': 'User is already member of this group'}, status=status.HTTP_400_BAD_REQUEST)\\n member_role = request.data.get('role')\\n new_member_data = Member.objects.create(group=group, user=user_data,role_type=member_role, display_name=request.data.get('display_name'))\\n new_member_data.save()\\n serializer_data = MemberSerializer(new_member_data)\\n return Response(serializer_data.data)\",\n \"def creat_team(self):\\n te = Teams()\\n per = Persons()\\n teamlist = []\\n for one in per.find({'role':'leader'},{'team_name'}):\\n if one['team_name'] not in teamlist:\\n teamlist.append(one['team_name'])\\n # print len(teamlist)\\n for team in teamlist:\\n tmp = {'name': '', 'leader_email': '', 'person_emails': []}\\n tmp['name'] = team\\n tmp['leader_email'] = per.get_one({'team_name':team,'role':'leader'})['email']\\n for one in per.find({'team_name':team},{'email'}):\\n tmp['person_emails'].append(one['email'])\\n print tmp\\n search_t = te.get_one({'name':team})\\n if search_t is None:\\n te.insert_one(tmp)\\n else:\\n te.update_one({'name':team,'leader_email':'','person_emails':''},tmp,cover=True)\",\n \"def test_add_role_to_project_member(self):\\n pass\",\n \"async def on_project_member_add(self, guild_id: int, project: dict,\\n members: list) -> discord.Message:\\n # print(project)\\n guild = (await self.bot.fetch_guild(guild_id))\\n channel = await self.bot.fetch_channel(int(project.get(\\\"channel\\\")))\\n members = [(await guild.fetch_member(member)) for member in members]\\n count = len(members)\\n if count == 1:\\n member = members[0]\\n return await channel.send(f\\\"**> Member Update:** `{member}` was\\\"\\n \\\" added to this project.\\\")\\n if count == 2:\\n return await channel.send(f\\\"**> Member Update:** `{members[0]} `\\\"\\n f\\\"and `{members[1]}\\\"\\n \\\" were added to this project.\\\"\\n )\\n else:\\n last_member = members[count - 1]\\n members = members.pop(count - 1)\\n string = \\\"`\\\"\\n members = string + \\\"`, \\\".join(str(x) for x in members) + string\\n members = members + f\\\" and `{last_member}`\\\"\\n return await channel.send(f\\\"**> Member Update:** {members} were \\\"\\n \\\"added to this project.\\\")\",\n \"def tournament_registration(request, tournament_id):\\n tournament = get_object_or_404(Tournament, id=tournament_id)\\n \\n if tournament.is_online():\\n form = OnlineTournamentRegistrationForm(request.POST, initial={\\n 'tournament': tournament\\n })\\n else:\\n form = TournamentRegistrationForm(request.POST, initial={\\n 'tournament': tournament\\n })\\n\\n if form.is_valid():\\n if tournament.is_online():\\n tenhou_nickname = form.cleaned_data.get('tenhou_nickname')\\n if OnlineTournamentRegistration.objects.filter(tournament=tournament, tenhou_nickname=tenhou_nickname).exists():\\n messages.success(request, _('You already registered to the tournament!'))\\n return redirect(tournament.get_url())\\n\\n instance = form.save(commit=False)\\n instance.tournament = tournament\\n \\n # it supports auto load objects only for Russian tournaments right now\\n \\n try:\\n instance.player = Player.objects.get(first_name_ru=instance.first_name.title(), \\n last_name_ru=instance.last_name.title())\\n except (Player.DoesNotExist, Player.MultipleObjectsReturned):\\n # TODO if multiple players are here, let's try to filter by city\\n pass\\n \\n try:\\n instance.city_object = City.objects.get(name_ru=instance.city)\\n except City.DoesNotExist:\\n pass\\n\\n if tournament.registrations_pre_moderation:\\n instance.is_approved = False\\n message = _('Your registration was accepted! It will be visible on the page after administrator approvement.')\\n else:\\n instance.is_approved = True\\n message = _('Your registration was accepted!')\\n\\n instance.save()\\n \\n messages.success(request, message)\\n else:\\n messages.success(request, _('Please, allow to store personal data'))\\n\\n return redirect(tournament.get_url())\",\n \"def test_teams_remove_user_from_team_v2(self):\\n pass\",\n \"def add_or_update_accounts(self, accounts, members):\\n pending_members = dict([(a.nickname, a) for a in accounts.get_all_member_accounts()]) # Get the nicknames of accounts that are already member.\\n for member in members.list_members(): # Loop over the members\\n account = accounts.new_account()\\n try:\\n account.load_account_from_member(member)\\n except MemberNotValidException as ex:\\n log.warning(\\\"invalid member received! '%s'\\\", ex)\\n continue\\n account.save()\\n if not account.is_member:\\n account.grant_membership()\\n if member.nickname in pending_members:\\n pending_members.pop(member.nickname)\\n return pending_members # this is a list of accounts that used to be members, but are not now.\",\n \"def teams(request):\\n if request.method == 'GET':\\n # Validates if the member exists. If members logon successfully they are created on the teams-app.\\n email = request.session.get('email', None)\\n full_name = request.session.get('full_name', None)\\n try: \\n member = Member.objects.get(email=email)\\n except ObjectDoesNotExist:\\n member = Member(email=email, full_name=full_name)\\n member.save()\\n\\n member_teams = member.teams.all() \\n context = {\\n 'email': email,\\n 'full_name': full_name,\\n 'member_teams': member_teams\\n }\\n return render(request, 'teamsapp/teams.html', context)\\n else:\\n raise Http404('Not allowed')\",\n \"def validate_register_team():\\n team = request.args.get('team')\\n school_name = request.args.get('school')\\n if not team:\\n # No team name\\n return jsonify({'valid': False, 'error': 'Please specify a team name'})\\n\\n school = School.query.filter(School.name.ilike(school_name)).first()\\n team = Team.query.filter(Team.name.ilike(team)).first()\\n if team and school:\\n if team.school.id != school.id:\\n # The team is already registered to another school\\n return jsonify({'valid': False, 'error': 'Sorry, that team name is already registered at another school'})\\n if team and len(team.users) == 2:\\n # The team alread is full\\n return jsonify({'valid': False, 'error': 'Sorry, that team is already full (limit of 2 students per team)'})\\n return jsonify({'valid': True})\",\n \"def add_member_bulk(self, request, **kwargs):\\n if request.data is None:\\n return Response({'message': 'Invalid member details'}, status=status.HTTP_400_BAD_REQUEST)\\n group = self.get_object()\\n invalid_phone_number = []\\n valid_phone_number = []\\n for member_data in request.data:\\n valid_member = User.objects.filter(phone=member_data['phone'])\\n is_already_member = Member.objects.filter(user__in=valid_member, group=group)\\n if valid_member.count() > 0 and (not is_already_member):\\n user = User.objects.get(phone=member_data['phone'])\\n new_member = Member.objects.create(user=user, group=group, role_type='member', display_name=member_data['display_name'])\\n valid_phone_number.append(member_data['phone'])\\n else:\\n invalid_phone_number.append(member_data['phone']) \\n return Response({'Success': valid_phone_number, 'Failed': invalid_phone_number})\",\n \"def create_team(self, name, owner_id, members=None):\\n # Ensure that the owner exists and all team members exist. Will raise\\n # exception if user is unknown.\\n self.assert_user_exists(owner_id)\\n if not members is None:\\n for user_id in set(members):\\n if not user_id == owner_id:\\n self.assert_user_exists(user_id)\\n # Ensure that the given team name is uniqe and does not contain too many\\n # characters\\n sql = 'SELECT * FROM team WHERE name = ?'\\n if name is None or name.strip() == '':\\n raise err.ConstraintViolationError('missing team name')\\n elif len(name.strip()) > 255:\\n raise err.ConstraintViolationError('team name contains more than 255 character')\\n elif not self.con.execute(sql, (name.strip(),)).fetchone() is None:\\n raise err.ConstraintViolationError('team name \\\\'{}\\\\' exists'.format(name.strip()))\\n # Get unique identifier for the new team.\\n team_id = util.get_unique_identifier()\\n # Create the new team and add team members. Ensure that at least the\\n # team owner is added as a team member.\\n sql = 'INSERT INTO team_member(team_id, user_id) VALUES(?, ?)'\\n self.con.execute(\\n 'INSERT INTO team(id, name, owner_id) VALUES(?, ?, ?)',\\n (team_id, name.strip(), owner_id)\\n )\\n self.con.execute(sql, (team_id, owner_id))\\n member_count = 1\\n if not members is None:\\n for user_id in set(members):\\n if not user_id == owner_id:\\n self.con.execute(sql, (team_id, user_id))\\n member_count += 1\\n self.con.commit()\\n # Return team descriptor\\n return TeamDescriptor(\\n identifier=team_id,\\n name=name,\\n owner_id=owner_id,\\n member_count=member_count\\n )\",\n \"def assign_members(self, **kwargs):\\n\\n return self.api_request(self._get_method_fullname(\\\"assign_members\\\"), kwargs)\",\n \"def test_assign_managing_team(self):\\n pass\",\n \"def test_teams_remove_user_from_team_v1(self):\\n pass\",\n \"def test_members(self):\\n self.run_function(\\\"group.add\\\", [self._group], gid=self._gid)\\n self.run_function(\\\"user.add\\\", [self._user])\\n self.run_function(\\\"user.add\\\", [self._user1])\\n m = \\\"{},{}\\\".format(self._user, self._user1)\\n ret = self.run_function(\\\"group.members\\\", [self._group, m])\\n self.assertTrue(ret)\\n group_info = self.run_function(\\\"group.info\\\", [self._group])\\n self.assertIn(self._user, str(group_info[\\\"members\\\"]))\\n self.assertIn(self._user1, str(group_info[\\\"members\\\"]))\",\n \"def post(self):\\n req = team_req.parse_args(strict=True)\\n curr_user = api.user.get_user()\\n if curr_user[\\\"teacher\\\"]:\\n raise PicoException(\\\"Teachers may not create teams\\\", 403)\\n req[\\\"team_name\\\"] = req[\\\"team_name\\\"].strip()\\n if not all(\\n [\\n c in string.digits + string.ascii_lowercase + \\\" ()+-,#'&!?\\\"\\n for c in req[\\\"team_name\\\"].lower()\\n ]\\n ):\\n raise PicoException(\\n \\\"Team names cannot contain special characters other than \\\"\\n + \\\"()+-,#'&!?\\\",\\n status_code=400,\\n )\\n\\n if req[\\\"team_name\\\"] == curr_user[\\\"username\\\"]:\\n raise PicoException(\\\"Invalid team name\\\", status_code=409)\\n\\n new_tid = api.team.create_and_join_new_team(\\n req[\\\"team_name\\\"], req[\\\"team_password\\\"], curr_user\\n )\\n res = jsonify({\\\"success\\\": True, \\\"tid\\\": new_tid})\\n res.status_code = 201\\n return res\",\n \"async def add(self, ctx, *, name=None):\\n server = ctx.message.server\\n author = ctx.message.author\\n names = None\\n namesp = None\\n if name is None:\\n name = author\\n elif \\\",\\\" in str(name):\\n if \\\", \\\" in name:\\n names = name.split(\\\", \\\")\\n elif \\\",\\\" in name:\\n names = name.split(\\\",\\\")\\n namesp = names.copy()\\n for i in range(len(names)):\\n names[i] = discord.utils.find(\\n lambda m: m.display_name == names[i], server.members)\\n if names[i] is None:\\n names[i] = discord.utils.find(\\n lambda m: m.name == names[i], server.members)\\n name = None\\n else:\\n namea = name[:]\\n name = discord.utils.find(\\n lambda m: m.display_name == name, server.members)\\n if name is None:\\n name = discord.utils.find(\\n lambda m: m.name == name, server.members)\\n if name is None:\\n await self.bot.say(\\\"{} was not found, please check the spelling and also make \\\"\\n \\\"sure that the member name being entered is a member in your Discord and \\\"\\n \\\"that its the same as their Discord name / nickname.\\\".format(namea))\\n return\\n if server.id not in self.db:\\n self.db[server.id] = {}\\n if not name:\\n counter = -1\\n for x in names:\\n counter += 1\\n if x is None:\\n await self.bot.say(\\\"{} was not found, please check the spelling and also make \\\"\\n \\\"sure that the member name being entered is a member in your Discord and \\\"\\n \\\"that its the same as their Discord name / nickname.\\\".format(namesp[counter]))\\n await asyncio.sleep(1)\\n continue\\n elif x.id in self.db[server.id]:\\n await self.bot.say(\\\"{} is already in the list\\\".format(x.display_name))\\n elif x.id not in self.db[server.id]:\\n self.db[server.id][x.id] = OrderedDict(\\n {\\\"Name\\\": x.display_name, \\\"Balance\\\": 0, \\\"Lifetime Gain\\\": 0, \\\"Lifetime Loss\\\": 0})\\n self.save_db()\\n await self.bot.say(\\\"{} has been added to the list.\\\".format(x.display_name))\\n await asyncio.sleep(1)\\n\\n else:\\n if name.id in self.db[server.id]:\\n await self.bot.say(\\\"{} is already in the list\\\".format(name.display_name))\\n return\\n elif name.id not in self.db[server.id]:\\n self.db[server.id][name.id] = OrderedDict(\\n {\\\"Name\\\": name.display_name, \\\"Balance\\\": 0, \\\"Lifetime Gain\\\": 0, \\\"Lifetime Loss\\\": 0})\\n self.save_db()\\n await self.bot.say(\\\"{} has been added to the list.\\\".format(name.display_name))\",\n \"def add_member_list_board(request):\\n print(request.data)\\n board = Board.objects.get(joining_code=request.data[\\\"boardCode\\\"])\\n print(board.name)\\n for i in request.data[\\\"emails\\\"]:\\n if User.objects.filter(email=i[\\\"value\\\"]).exists():\\n user = User.objects.get(email=i[\\\"value\\\"])\\n if Member.objects.filter(user_id=user.id, board_id=board.id).exists():\\n print(\\\"{} exists in database and is a member\\\".format(user.username))\\n else:\\n Member.objects.create(user_id=user, board_id=board, is_admin=False, is_creator=False)\\n add_user_to_board(user.username, board.id)\\n print(\\\"{} exists in database but is not a member\\\".format(user.username))\\n else:\\n print (\\\"user does not exist in database\\\")\\n send_mail(\\n 'You have been invited to join KB4L',\\n 'You have been invtied to the KB4l Board for {} \\\\n'.format(board.name) +\\n 'click this link below join \\\\n' +\\n 'http://localhost:4200/register?email={}&board_code={}'.format(\\n i[\\\"value\\\"],\\n request.data[\\\"boardCode\\\"]\\n ),\\n 'no_reply@KB4L.com',\\n [i[\\\"value\\\"]],\\n fail_silently=False,\\n )\\n return Response({\\\"success\\\":\\\"members have been added\\\"})\",\n \"def register_member(self, address, uuid):\\n\\n final_address = self.parse_address(address)\\n\\n self.members.append({'uuid': uuid, 'address': final_address})\",\n \"def add_user(self, team, params={}, **options):\\n path = \\\"/teams/%s/addUser\\\" % (team)\\n return self.client.post(path, params, **options)\",\n \"async def register_to_lobby(self, ctx, *, lobby_id: str): # TODO: improve, was in a rush =)\\n tournament = self.get_tournament(ctx.guild.id)\\n user = tosurnament.UserAbstraction.get_from_ctx(ctx)\\n for bracket in tournament.brackets:\\n qualifiers_spreadsheet = await bracket.get_qualifiers_spreadsheet()\\n if not qualifiers_spreadsheet:\\n continue\\n lobby_id_cells = qualifiers_spreadsheet.spreadsheet.get_cells_with_value_in_range(\\n qualifiers_spreadsheet.range_lobby_id\\n )\\n if players_spreadsheet := await bracket.get_players_spreadsheet():\\n team_info = TeamInfo.from_discord_id(players_spreadsheet, user.discord_id)\\n team_name = team_info.team_name.get()\\n else:\\n if not user.verified:\\n continue\\n team_name = user.name\\n lobby_infos = []\\n for lobby_id_cell in lobby_id_cells:\\n lobby_infos.append(\\n LobbyInfo.from_lobby_id_cell(qualifiers_spreadsheet, lobby_id_cell, filled_only=False)\\n )\\n lobby_found = False\\n for lobby_info in lobby_infos:\\n if lobby_info.lobby_id.casefold() == lobby_id.casefold():\\n first_empty_cell = None\\n for team_cell in lobby_info.teams:\\n if not first_empty_cell and not team_cell:\\n first_empty_cell = team_cell\\n if team_name.casefold() == team_cell.casefold():\\n raise tosurnament.AlreadyInLobby()\\n if not first_empty_cell:\\n raise tosurnament.LobbyIsFull()\\n first_empty_cell.set(team_name)\\n lobby_found = True\\n break\\n if not lobby_found:\\n continue\\n for lobby_info in lobby_infos:\\n for team_cell in lobby_info.teams:\\n if (\\n lobby_info.lobby_id.casefold() != lobby_id.casefold()\\n and team_name.casefold() == team_cell.casefold()\\n ):\\n team_cell.set(\\\"\\\")\\n break\\n self.add_update_spreadsheet_background_task(qualifiers_spreadsheet)\\n await self.send_reply(ctx, \\\"success\\\", lobby_id)\\n return\\n raise tosurnament.LobbyNotFound()\",\n \"def add(self, team):\\n ### INVARIANT: team is a Team class object.\\n if team not in self._conf_teams:\\n self._conf_teams.append(team)\",\n \"def update_teams(self, team_name, numero, pc):\\n\\n self.execute(TABELLE['teams']['insert'], (team_name, numero, pc))\",\n \"def test_teams_save_workgroup_member_v1(self):\\n pass\",\n \"def add_teams_players(teams_dictionary, player_counter, injury_counter, player_season_counter,\\r\\n player_team_counter, host, root, password):\\r\\n players, injuries, players_seasons, players_teams = \\\\\\r\\n scrape_players(teams_dictionary, player_counter, injury_counter, player_season_counter,\\r\\n player_team_counter)\\r\\n if players:\\r\\n create_players(host, root, password, dict_to_read=players)\\r\\n create_injuries(host, root, password, dict_to_read=injuries)\\r\\n create_players_by_team(host, root, password, dict_to_read=players_teams)\\r\\n create_players_by_season(host, root, password, dict_to_read=players_seasons)\",\n \"def add_fb_team(self, team_name, member_one, member_two):\\n\\n if len(team_name) is 0:\\n raise exceptions.DBValueError(\\\"Team name must be at \\\\\\nleast one character\\\")\\n\\n if len(member_one) != 3:\\n raise exceptions.DBValueError(\\\"First team member must\\\\\\n be complete\\\")\\n\\n if len(member_two) != 3:\\n raise exceptions.DBValueError(\\\"Second team member must\\\\\\n be complete\\\")\\n\\n if member_one == member_two:\\n raise exceptions.DBValueError(\\\"Team members must be different players\\\")\\n\\n if self.check_if_team_exists(team_name=team_name):\\n raise exceptions.DBValueError(\\\"Team already exists\\\")\\n\\n if self.check_if_two_players_on_team(member_one, member_two):\\n raise exceptions.DBValueError(\\\"Players already on team together\\\")\\n\\n self._logger.debug(\\\"Adding fb team to database\\\")\\n try:\\n self.check_if_db_connected()\\n cursor = self._db_conn.cursor()\\n fb_rating_id = self.create_new_default_rating()\\n mk_rating_id = self.create_new_default_rating()\\n mp_rating_id = self.create_new_default_rating()\\n ss_rating_id = self.create_new_default_rating()\\n cursor.execute(\\\"INSERT INTO team (team_name, fb_team_rating, mk_team_rating, \\\\\\nmp_team_rating, ss_team_rating) VALUES ('{0}', {1}, {2}, {3}, {4})\\\".format(\\n team_name, fb_rating_id, mk_rating_id, mp_rating_id, ss_rating_id))\\n\\n team_id = cursor.lastrowid\\n\\n cursor.execute(\\\"INSERT INTO fb_team_rating_hist (rating, team) VALUES ({0}, {1}\\\\\\n)\\\".format(fb_rating_id, team_id))\\n cursor.execute(\\\"INSERT INTO mk_team_rating_hist (rating, team) VALUES ({0}, {1}\\\\\\n)\\\".format(mk_rating_id, team_id))\\n cursor.execute(\\\"INSERT INTO mp_team_rating_hist (rating, team) VALUES ({0}, {1}\\\\\\n)\\\".format(mp_rating_id, team_id))\\n cursor.execute(\\\"INSERT INTO ss_team_rating_hist (rating, team) VALUES ({0}, {1}\\\\\\n)\\\".format(ss_rating_id, team_id))\\n\\n cursor.execute(\\\"INSERT INTO player_team_xref (player, team) \\\\\\nVALUES ((SELECT player_id FROM player WHERE first_name = '{0}' AND last_name \\\\\\n= '{1}' AND nickname = '{2}'), {3})\\\".format(member_one[0], member_one[1],\\n member_one[2], team_id))\\n\\n cursor.execute(\\\"INSERT INTO player_team_xref (player, team) \\\\\\nVALUES ((SELECT player_id FROM player WHERE first_name = '{0}' AND last_name \\\\\\n= '{1}' AND nickname = '{2}'), {3})\\\".format(member_two[0], member_two[1],\\n member_two[2], team_id))\\n\\n self._db_conn.commit()\\n\\n except MySQLdb.OperationalError:\\n self._logger.error(\\\"MySQL operational error occured\\\")\\n traceback.print_exc()\\n raise exceptions.DBConnectionError(\\\"Cannot connect to MySQL server\\\")\\n\\n except MySQLdb.ProgrammingError:\\n self._logger.error(\\\"MySQL programming error\\\")\\n traceback.print_exc()\\n raise exceptions.DBSyntaxError(\\\"MySQL syntax error\\\")\\n\\n else:\\n return team_id\",\n \"def test_user_register_adds_a_user_to_list_of_users(self):\\n\\n user_randint = randint(0, 1000)\\n test_user = {'username': 'TESTUSERNAME%d' % user_randint,\\n 'name': 'TESTNAME',\\n 'email': 'TESTEMAIL%d@TESTHOST.com' % user_randint,\\n 'location': 'TESTLOCATION',\\n 'position': 'TESTPOSITION',\\n 'password': 'Testpass1'}\\n\\n # Navigate to registration form\\n self.browser.get(self.warno_url)\\n self.browser.find_element_by_link_text(\\\"Sign In\\\").click()\\n self.browser.find_element_by_link_text(\\\"New here? Register.\\\").click()\\n contents = self.browser.find_element_by_class_name(\\\"sub-title\\\")\\n self.assertTrue(\\\"Register\\\" in contents.text, \\\"Redirected page's subtitle did not contain 'Register'\\\")\\n\\n # Register as a new user with test information\\n self.browser.find_element_by_id(\\\"username\\\").send_keys(test_user[\\\"username\\\"])\\n self.browser.find_element_by_id(\\\"email\\\").send_keys(test_user[\\\"email\\\"])\\n self.browser.find_element_by_id(\\\"name\\\").send_keys(test_user[\\\"name\\\"])\\n self.browser.find_element_by_id(\\\"position\\\").send_keys(test_user[\\\"position\\\"])\\n self.browser.find_element_by_id(\\\"location\\\").send_keys(test_user[\\\"location\\\"])\\n self.browser.find_element_by_id(\\\"password\\\").send_keys(test_user[\\\"password\\\"])\\n final_element = self.browser.find_element_by_id(\\\"retype_password\\\")\\n final_element.send_keys(test_user[\\\"password\\\"])\\n final_element.submit()\\n\\n # Navigate to user page, confirm new user is in list\\n self.browser.find_element_by_link_text('Users').click()\\n contents = self.browser.find_element_by_class_name('sub-title')\\n self.assertTrue('User' in self.browser.title, 'Redirected page did not have \\\"Users\\\" in subtitle')\\n\\n user_table = self.browser.find_element_by_id(\\\"user-table\\\")\\n print user_table.text\\n self.assertTrue(test_user[\\\"username\\\"] in user_table.text,\\n \\\"List of users does not contain the new username '%s'\\\" % test_user[\\\"username\\\"])\",\n \"def add_member(self, user):\\n if user is self.owner:\\n raise ValidationError('A trip owner cannot also be a member.')\\n # check the user is not already a member\\n if self.members.filter(pk=user.pk).exists():\\n return\\n self.members.add(user)\",\n \"def test_account_add_registration(session, client, jwt, desc, roles, status, account_id, reg_num):\\n headers = None\\n # setup\\n if account_id:\\n headers = create_header_account(jwt, roles, 'test-user', account_id)\\n else:\\n headers = create_header(jwt, roles)\\n\\n # test\\n response = client.post('/api/v1/financing-statements/registrations/' + reg_num,\\n headers=headers,\\n content_type='application/json')\\n\\n # check\\n assert response.status_code == status\",\n \"def add_league_teams(league_diction, team_count, host, root, password):\\r\\n teams_diction = scrape_teams(league_diction, team_count)\\r\\n create_teams(host, root, password, dict_to_read=teams_diction)\\r\\n\\r\\n return teams_diction\",\n \"def add_team(inp_to_add, type_to_add, host, root, password):\\r\\n team_name = \\\"\\\"\\r\\n\\r\\n if type_to_add == \\\"url\\\":\\r\\n team_soup = BeautifulSoup(requests.get(inp_to_add).text, 'html.parser')\\r\\n team_site = inp_to_add\\r\\n else:\\r\\n team_soup, team_site = get_first_search_result(\\r\\n SOCCER_URL + \\\"/search/teams/?q=\\\" + inp_to_add)\\r\\n\\r\\n if team_soup:\\r\\n # Need to examine if league already exists, if not - add it. Then, get its LEAGUE_ID\\r\\n league_url = SOCCER_URL + team_soup.find('div', id=\\\"page_team_1_block_team_table_9-wrapper\\\").h2.a[\\\"href\\\"]\\r\\n find_league({league_url}, \\\"url\\\", host, root, password)\\r\\n\\r\\n team_name = team_soup.find(\\\"table\\\", class_=\\\"leaguetable sortable table\\\").tbody.find_all(\\r\\n 'tr', class_=[\\\"odd highlight team_rank\\\", \\\"even highlight team_rank\\\"])[0].find(\\r\\n 'td', class_=\\\"text team large-link\\\").a.text\\r\\n\\r\\n return team_name\",\n \"def test_register_unicode_user():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app, name=\\\"你好\\\")\\n team_count = app.db.session.query(app.db.func.count(Teams.id)).first()[0]\\n assert team_count == 2 # There's the admin user and the created user\\n destroy_ctfd(app)\",\n \"async def channel_add(\\n self, ctx: commands.Context, channel: Union[discord.TextChannel, discord.VoiceChannel], *team_ids: int):\\n if set(team_ids) - set(self.teams):\\n await ctx.send('Missing data for the following team IDs: %s' % (\\n ', '.join(map(str, set(team_ids) - set(self.teams))),))\\n return\\n\\n await asyncio.gather(*[\\n self._permit_team_in_channel(self.teams[team_id], channel)\\n for team_id in team_ids],\\n return_exceptions=True)\\n await ctx.send('Added team%s `%s` to channel %s' % (\\n nl.s(len(team_ids)),\\n '`, `'.join(self.teams[team_id].username for team_id in team_ids),\\n channel.mention))\",\n \"def test_get_member(self):\\n test_resource = 'test_get_member'\\n self.app.post(f'/v1/resource/{self.test_resource}/id/{test_resource}', headers=admin_headers)\\n\\n # make groups\\n members = []\\n for group in [f'rt_group{i}' for i in range(5)]:\\n resp = self.app.post(\\n f'/v1/group',\\n data=json.dumps({'group_id': group}),\\n headers=admin_headers)\\n self.assertEqual(resp.status_code, 201)\\n members.append({'member': group,\\n 'member_type': 'group',\\n 'access_level': 'read'})\\n\\n # make users\\n for user in [f'rt_user{i}' for i in range(6)]:\\n resp = self.app.post(\\n f'/v1/user',\\n data=json.dumps({'user_id': user}),\\n headers=admin_headers)\\n self.assertEqual(resp.status_code, 201)\\n members.append({'member': user,\\n 'member_type': 'user',\\n 'access_level': 'read'})\\n for m in members:\\n resp = self.app.put(\\n f'/v1/resource/{self.test_resource}/id/{test_resource}/members',\\n data=json.dumps([m]),\\n headers=admin_headers)\\n self.assertEqual(resp.status_code, 200)\\n self._test_paging(f'/v1/resource/{self.test_resource}/id/{test_resource}/members', admin_headers, 10, 'members')\",\n \"def add_users(self, *users):\\r\\n pass\",\n \"def add_member(data):\\n print(\\\"Adding: %s \\\" % data)\\n conn = create_connection(db_location)\\n sql = \\\"INSERT INTO members(member_uid, name, email, badge_id, new) VALUES({}, \\\\\\\"{}\\\\\\\", \\\\\\\"{}\\\\\\\", \\\\\\\"{}\\\\\\\", \\\\\\\"{}\\\\\\\");\\\".format(\\n data['id'], data['forename'] + \\\" \\\" + data['surname'], data['email'], data['badge_id'], data['new'])\\n execute_sql(conn, sql)\\n return\",\n \"def test_create_team(self):\\n pass\",\n \"async def register(ctx, *args):\\n user = ctx.message.author\\n user_mention = ctx.author.mention\\n chan_mention = \\\"<#876850365730021386>\\\"\\n \\n if user in self.data[\\\"users.json\\\"]:\\n await ctx.message.channel.send(user_mention+\\\", you are already registered. :blue_heart:\\\")\\n else:\\n self.data[\\\"users_asked_to_be_registered.json\\\"].append(user)\\n await ctx.message.channel.send(user_mention+\\\", do you accept the \\\"+chan_mention+\\n \\\" (Indie Library Terms of Service). Command .accept if you do. :blue_heart:\\\")\",\n \"def update_guild_members(name, server):\\n url = base_wow + guild+\\\"/\\\"+ server+\\\"/\\\"+ name+\\\"?\\\"+ method + locale + api\\n r = requests.get(url)\\n data = r.json()\\n guilde = data['name']\\n for member in data[\\\"members\\\"]:\\n add_member(guilde, member['character']['name'], member['rank'], member['character']['level'])\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68252176","0.65158945","0.6490704","0.639203","0.6363671","0.63076943","0.62758386","0.61730903","0.6119535","0.6111411","0.60833365","0.605366","0.60312194","0.59802115","0.5968567","0.5962732","0.592363","0.5835005","0.5833699","0.58229077","0.58150005","0.5775126","0.57706314","0.57298315","0.5668468","0.56679595","0.5637681","0.56304425","0.56231195","0.56169575","0.5614265","0.55779094","0.55401915","0.553845","0.5507646","0.55071545","0.5483651","0.54624003","0.543884","0.5432577","0.5420311","0.54131573","0.54115766","0.53958994","0.53949785","0.5382247","0.53630507","0.5362951","0.53370434","0.5336586","0.5330731","0.5323818","0.5313311","0.53015137","0.5285428","0.52763313","0.5251918","0.52505994","0.52460915","0.52281266","0.5226918","0.5212342","0.5210527","0.520809","0.5207272","0.5205035","0.5170401","0.51698","0.51580846","0.515648","0.51544434","0.5151477","0.51347834","0.5134173","0.5132726","0.5122696","0.5096732","0.5095908","0.50933415","0.5085205","0.5083987","0.506575","0.5063913","0.5063128","0.50570893","0.50535506","0.50349385","0.5030015","0.5029783","0.50271106","0.50271076","0.5022945","0.5019856","0.5018763","0.5016228","0.49996403","0.49977478","0.4981048","0.49726972","0.4968111"],"string":"[\n \"0.68252176\",\n \"0.65158945\",\n \"0.6490704\",\n \"0.639203\",\n \"0.6363671\",\n \"0.63076943\",\n \"0.62758386\",\n \"0.61730903\",\n \"0.6119535\",\n \"0.6111411\",\n \"0.60833365\",\n \"0.605366\",\n \"0.60312194\",\n \"0.59802115\",\n \"0.5968567\",\n \"0.5962732\",\n \"0.592363\",\n \"0.5835005\",\n \"0.5833699\",\n \"0.58229077\",\n \"0.58150005\",\n \"0.5775126\",\n \"0.57706314\",\n \"0.57298315\",\n \"0.5668468\",\n \"0.56679595\",\n \"0.5637681\",\n \"0.56304425\",\n \"0.56231195\",\n \"0.56169575\",\n \"0.5614265\",\n \"0.55779094\",\n \"0.55401915\",\n \"0.553845\",\n \"0.5507646\",\n \"0.55071545\",\n \"0.5483651\",\n \"0.54624003\",\n \"0.543884\",\n \"0.5432577\",\n \"0.5420311\",\n \"0.54131573\",\n \"0.54115766\",\n \"0.53958994\",\n \"0.53949785\",\n \"0.5382247\",\n \"0.53630507\",\n \"0.5362951\",\n \"0.53370434\",\n \"0.5336586\",\n \"0.5330731\",\n \"0.5323818\",\n \"0.5313311\",\n \"0.53015137\",\n \"0.5285428\",\n \"0.52763313\",\n \"0.5251918\",\n \"0.52505994\",\n \"0.52460915\",\n \"0.52281266\",\n \"0.5226918\",\n \"0.5212342\",\n \"0.5210527\",\n \"0.520809\",\n \"0.5207272\",\n \"0.5205035\",\n \"0.5170401\",\n \"0.51698\",\n \"0.51580846\",\n \"0.515648\",\n \"0.51544434\",\n \"0.5151477\",\n \"0.51347834\",\n \"0.5134173\",\n \"0.5132726\",\n \"0.5122696\",\n \"0.5096732\",\n \"0.5095908\",\n \"0.50933415\",\n \"0.5085205\",\n \"0.5083987\",\n \"0.506575\",\n \"0.5063913\",\n \"0.5063128\",\n \"0.50570893\",\n \"0.50535506\",\n \"0.50349385\",\n \"0.5030015\",\n \"0.5029783\",\n \"0.50271106\",\n \"0.50271076\",\n \"0.5022945\",\n \"0.5019856\",\n \"0.5018763\",\n \"0.5016228\",\n \"0.49996403\",\n \"0.49977478\",\n \"0.4981048\",\n \"0.49726972\",\n \"0.4968111\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6414152"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":20398,"cells":{"query":{"kind":"string","value":"Register team repo addition."},"document":{"kind":"string","value":"def register_team_repo_add(self, body):\n httpretty.register_uri(\n httpretty.PUT,\n re.compile(\n r'^{url}teams/\\d+/repos/{org}/({repo}|{rerun_repo})$'.format(\n url=self.URL,\n org=self.ORG,\n repo=re.escape(self.TEST_REPO),\n rerun_repo=re.escape(self.TEST_RERUN_REPO)\n )\n ),\n body=body\n )"},"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 add(name, url):\n click.echo(\"registered repo {} at url {}\".format(name, url))","def _RegisterAmberRepository(self, tuf_repo, remote_port):\n\n # Extract the public signing key for inclusion in the config file.\n root_keys = []\n root_json_path = os.path.join(tuf_repo, 'repository', 'root.json')\n root_json = json.load(open(root_json_path, 'r'))\n for root_key_id in root_json['signed']['roles']['root']['keyids']:\n root_keys.append({\n 'Type': root_json['signed']['keys'][root_key_id]['keytype'],\n 'Value': root_json['signed']['keys'][root_key_id]['keyval']['public']\n })\n\n # \"pm serve\" can automatically generate a \"config.json\" file at query time,\n # but the file is unusable because it specifies URLs with port\n # numbers that are unreachable from across the port forwarding boundary.\n # So instead, we generate our own config file with the forwarded port\n # numbers instead.\n config_file = open(os.path.join(tuf_repo, 'repository', 'repo_config.json'),\n 'w')\n json.dump({\n 'ID': _MANAGED_REPO_NAME,\n 'RepoURL': \"http://127.0.0.1:%d\" % remote_port,\n 'BlobRepoURL': \"http://127.0.0.1:%d/blobs\" % remote_port,\n 'RatePeriod': 10,\n 'RootKeys': root_keys,\n 'StatusConfig': {\n 'Enabled': True\n },\n 'Auto': True\n }, config_file)\n config_file.close()\n\n # Register the repo.\n return_code = self._target.RunCommand(\n [('amberctl rm_src -n %s; ' +\n 'amberctl add_src -f http://127.0.0.1:%d/repo_config.json')\n % (_MANAGED_REPO_NAME, remote_port)])\n if return_code != 0:\n raise Exception('Error code %d when running amberctl.' % return_code)","def add(orgname, pat, reponame, branchname):\n g = Github(pat)\n repo = g.get_organization(orgname).get_repo(reponame)\n all_files = []\n contents = repo.get_contents(\"\")\n while contents:\n file_content = contents.pop(0)\n if file_content.type == \"dir\":\n contents.extend(repo.get_contents(file_content.path))\n else:\n file = file_content\n all_files.append(str(file)\n .replace('ContentFile(path=\"', '')\n .replace('\")', ''))\n\n with open('./CODEOWNERS', 'r') as file:\n content = file.read()\n\n # Upload to github\n git_prefix = '.github/'\n git_file = git_prefix + 'CODEOWNERS'\n if git_file in all_files:\n contents = repo.get_contents(git_file)\n repo.update_file(contents.path,\n \"updating CODEOWNERS\",\n content,\n contents.sha,\n branch=branchname)\n print(git_file + ' updated for: ' + reponame)\n else:\n repo.create_file(git_file,\n \"adding CODEOWNERS\",\n content,\n branch=branchname)\n print(git_file + ' created for: ' + reponame)","def test_add_team_manager_to_team(self):\n pass","def register(id, name, get_packages, find_installed_packages):\n repo = Repository()\n repo.id = id\n repo.name = name\n repo.get_packages = get_packages\n repo.find_installed_packages = find_installed_packages\n repositories.append(repo)","def _add_repo(repo_name, repo_url, index):\n\n package_manager = _get_package_manager()\n package_manager.add_repo(repo_name, repo_url, index)\n\n return 0","def add_addon_repository(self, repo: str) -> None:\n if repo in self._data[ATTR_ADDONS_CUSTOM_LIST]:\n return\n\n self._data[ATTR_ADDONS_CUSTOM_LIST].append(repo)","def register_repo_create(self, body):\n httpretty.register_uri(\n httpretty.POST,\n '{url}orgs/{org}/repos'.format(\n url=self.URL,\n org=self.ORG,\n ),\n body=body\n )","def repo_add(self, name, url, **kwargs):\n\n self.helm_client.repo_add(name, url, **kwargs)","def __add_repo(repo_name, url):\n\n conn = sqlite3.connect(DTF_DB)\n cur = conn.cursor()\n\n entry = [(repo_name, url)]\n\n sql = ('INSERT INTO repos (repo_name, url)'\n 'VALUES (?, ?)')\n\n cur.executemany(sql, entry)\n conn.commit()\n\n return 0","def process_repo(vb, options):\n if not options.repo:\n return\n\n vb.add_repo(options.repo_os, options.repo_id, options.repo_name, options.repo_url,\n options.unique, options.repo_tags)","def fusion_api_add_repository(self, body, api=None, headers=None):\n return self.repository.post(body, api, headers)","def addRepository(self, name, url):\n sslVerify = \"yes\" if url.startswith(\"https\") else \"no\"\n self.manager.addKickstartRepository(self.currentProject, baseurl=url,\n name=name,\n ssl_verify=sslVerify)\n self.manager.saveKickstartFile(self.currentProject)\n self.refresh()","def __gitSubmoduleAdd(self):\n self.vcs.gitSubmoduleAdd(self.project.getProjectPath())","def addRepository(self, uri):\n pass","def __gitAddRemote(self):\n self.vcs.gitAddRemote(self.project.getProjectPath())","def add_team(inp_to_add, type_to_add, host, root, password):\r\n team_name = \"\"\r\n\r\n if type_to_add == \"url\":\r\n team_soup = BeautifulSoup(requests.get(inp_to_add).text, 'html.parser')\r\n team_site = inp_to_add\r\n else:\r\n team_soup, team_site = get_first_search_result(\r\n SOCCER_URL + \"/search/teams/?q=\" + inp_to_add)\r\n\r\n if team_soup:\r\n # Need to examine if league already exists, if not - add it. Then, get its LEAGUE_ID\r\n league_url = SOCCER_URL + team_soup.find('div', id=\"page_team_1_block_team_table_9-wrapper\").h2.a[\"href\"]\r\n find_league({league_url}, \"url\", host, root, password)\r\n\r\n team_name = team_soup.find(\"table\", class_=\"leaguetable sortable table\").tbody.find_all(\r\n 'tr', class_=[\"odd highlight team_rank\", \"even highlight team_rank\"])[0].find(\r\n 'td', class_=\"text team large-link\").a.text\r\n\r\n return team_name","def add_repo(self, id, user, repo):\n request = self.request_builder('orgs.teams.add_repo',\n id=id, user=user, repo=repo)\n return self._put(request)","def register_team(self, agents_on_team):\n self.agents_on_team = agents_on_team","def team_add(token_user):\n if not json_param_exists('name') or \\\n not json_param_exists('type'):\n abort(400, \"one or more required parameter is missing\")\n name = request.json['name']\n team_type = TeamType.query.filter_by(name=request.json['type']).first()\n if not team_type:\n abort(400, \"invalid team type\")\n\n if team_type.name == 'other_team':\n if not token_user.has_permission('team.create') and \\\n not token_user.has_permission('team.create.elevated'):\n abort(403, 'team creation is not permitted')\n else: # creating any team other than 'other_team' requires elevated\n if not token_user.has_permission('team.create.elevated'):\n abort(403, 'insufficient permissions to create a team of this type')\n\n team = Team(name=name)\n team.team_type = team_type\n\n try:\n get_db().add(team)\n get_db().commit()\n except IntegrityError:\n abort(409, 'team name is already in use')\n\n return '', 201","def register(project_id, runner):\n pass","def add(self,path):\n out, err, code = self.command( [\"git\", \"add\", path], self.directory )","def add_repo(repo_name, url):\n\n # First, validate the URL\n if not utils.is_valid_url(url):\n log.e(TAG, \"Invalid URL provided (missing http/s)\")\n return -2\n\n # Next, make sure this repo doesnt exist\n if __has_repo(repo_name):\n log.e(TAG, \"Repo name '%s' already exists!\" % repo_name)\n return -3\n\n return __add_repo(repo_name, url)","def add(self, team):\n ### INVARIANT: team is a Team class object.\n if team not in self._conf_teams:\n self._conf_teams.append(team)","async def add_to_team(self, player : Player, team):\r\n if player in self.remaining:\r\n self.teams[team].append(player)\r\n self.remaining.remove(player)\r\n return discord.Embed(title=\"Valorant 10 Man Bot\",\r\n description=\"{} has been drafted to team {}\".format(get_member_name(player,lower=False), \":a:\" if team == \"A\" else \":b:\"))\r\n else:\r\n return discord.Embed(title=\"Valorant 10 Man Bot\",description=\"Sorry, {} is already drafted\".format(get_member_name(player)))","def addTag(self, repoType, txt, addSlash=True, project=0):\n # remove slash\n while txt.startswith(\"/\"):\n txt = txt[1:]\n \n # add fix to support & in filename, ampersand is used \n # as a shortcut for the tab by pyqt\n txt = txt.replace(\"&\", \"&&\")\n # end of fix\n \n if repoType == UCI.REPO_TESTS_LOCAL:\n repo = \"local-tests\"\n elif repoType == UCI.REPO_TESTS:\n repo = \"remote-tests\"\n project_name = self.iRepo.remote().getProjectName(project=project)\n repo += '(%s)' % project_name\n elif repoType == UCI.REPO_ADAPTERS:\n repo = \"remote-adapters\"\n elif repoType == UCI.REPO_LIBRARIES:\n repo = \"remote-libraries\"\n elif repoType == UCI.REPO_UNDEFINED:\n repo = \"undefined\"\n else:\n repo = \"unknown\"\n self.error( \"repo unknown: %s\" % repoType )\n if addSlash:\n if repoType == UCI.REPO_TESTS_LOCAL:\n ret = \"%s:%s\" % (repo, txt) \n else:\n ret = \"%s:/%s\" % (repo, txt)\n else:\n ret = \"%s: %s\" % (repo, txt) \n return ret","def gitAdd(filename, repo_dir):\n file_path = \"%s/%s\" % (repo_dir, filename)\n git(\"add\", file_path)","def registerTeam(self, agentsOnTeam):\n\n self.agentsOnTeam = agentsOnTeam","def commit_changes(repo, project = ''):\n cmd = repo.git\n cmd.add(all=True)\n try:\n cmd.commit(m=\"redcap2mysql.py data sync for project \" + project)\n except git.exc.GitCommandError, err:\n logging.info([traceback.format_exc(limit=1).splitlines()[-1]])","def add(self, organisation: Organisation) -> None:\n ...","def create_repo(self, repo):\n return self.user_con.create_repo(repo=repo)","def register_git_repository(args, namespace, notifier=None):\n\n tempdir = tempfile.mkdtemp()\n subprocess.check_call(\n \"\"\"\n cd {} &&\n git clone {} user_code\n \"\"\".format(tempdir, args.git_repository), shell=True)\n return register(Service, args, namespace,\n os.path.join(tempdir, 'user_code'), notifier)","def add(self):\r\n self._svn('add')","def add_user_to_team(self, for_user, to_manager):\n for_user = User.get_user_by_username(for_user)\n manager = User.get_user_by_username(to_manager)\n # @Todo test inheritance of get_user_by_username\n self.access_handler.check_add_user_to_team(for_user, manager)\n manager.add_user_to_team(for_user)","def newrepo():\n form = AddRepoForm()\n if form.validate_on_submit():\n\n # make the directory for this package\n os.mkdir(DATA + form.name.data)\n\n flash('Repo created successfully')\n\n # redirect to the login page\n return redirect(url_for('home.dashboard'))\n\n # load registration template\n return render_template('home/add.html', form=form, title='Local Repo', target=\"add\")","def test_teams_add_user_to_team_v2(self):\n pass","def _add_missing_repositories(frozen_repos, ret, **kwargs):\n repos = __salt__[\"pkg.list_repos\"](**kwargs)\n missing_repos = set(frozen_repos) - set(repos)\n for repo in missing_repos:\n try:\n # In Python 2 we cannot do advance destructuring, so we\n # need to create a temporary dictionary that will merge\n # all the parameters\n _tmp_kwargs = frozen_repos[repo].copy()\n _tmp_kwargs.update(kwargs)\n __salt__[\"pkg.mod_repo\"](repo, **_tmp_kwargs)\n ret[\"repos\"][\"add\"].append(repo)\n log.info(\"Added missing repository %s\", repo)\n except Exception as e: # pylint: disable=broad-except\n msg = \"Error adding %s repository: %s\"\n log.error(msg, repo, e)\n ret[\"comment\"].append(msg % (repo, e))","def on_add(self, project, name, **kwargs):\n pass","def add_repository(self, repo):\n repo = repo.lower()\n command = shlex.split(\"sudo add-apt-repository -y ppa:\"+repo)\n print subprocess.call(command)","def test_teams_add_user_to_team_v1(self):\n pass","def add_team(self, team):\n return self \\\n .team_identifier(team.identifier) \\\n .fold() \\\n .coalesce(\n # The team exists.\n __.unfold()\n .project('vertex', 'exists')\n .by(__.identity().elementMap())\n .by(__.constant(True)),\n # The team does not exist.\n __.addV('Team')\n .property(T.id, str(uuid.uuid4()))\n .property(Cardinality.single, 'identifier', team.identifier)\n .property(Cardinality.single, 'name', team.name)\n .project('vertex', 'exists')\n .by(__.identity().elementMap())\n .by(__.constant(False)),\n )","def test_handle_add(self):\n test_user = User(\"userid\")\n test_user.permissions_level = Permissions.admin\n test_user.github_username = \"githubuser\"\n team = Team(\"BRS\", \"brs\", \"web\")\n team.github_team_id = \"githubid\"\n add_user = User(\"anotheruser\")\n add_user.github_username = \"myuser\"\n add_user.github_id = \"otherID\"\n self.db.retrieve.side_effect = [test_user, add_user]\n self.db.query.return_value = [team]\n with self.app.app_context():\n resp, code = self.testcommand.handle(\"team add brs ID\", user)\n team_attach = team.get_attachment()\n expect = {'attachments': [team_attach],\n 'text': 'Added User to brs'}\n self.assertDictEqual(resp, expect)\n self.assertEqual(code, 200)\n self.db.store.assert_called_with(team)\n assert team.has_member(\"otherID\")\n self.gh.add_team_member.assert_called_once_with(\"myuser\", \"githubid\")","def add_user(self, team, params={}, **options):\n path = \"/teams/%s/addUser\" % (team)\n return self.client.post(path, params, **options)","def team_user_add(token_user, team_id, user_id):\n team = Team.query.get(team_id)\n if team is None:\n abort(404, 'team not found')\n\n # check for permissions to update the team\n if not (token_user.has_permission('team.update.elevated') or\n (token_user.has_permission('team.update') and\n team.has_member(token_user))):\n abort(403, 'insufficient permissions to add user to team')\n\n # don't allow adding to 'single' teams\n if team.team_type == TeamType.query.filter_by(name='single').first():\n abort(400, 'cannot add a user to a \"single\" team')\n\n user = User.query.get(user_id)\n if user is None:\n abort(400, 'invalid user id')\n\n if team.has_member(user):\n abort(409, 'user already in team')\n\n user.teams.append(team)\n get_db().commit()\n\n return '', 201","def patch_repos(self):","def repository_create_hosted():\n pass","def test_add_team_member(self):\n pass","def add_distdir ( self, distdir, src_uri=None, name=None ):\n self.repos.append ( BasicRepo (\n name=os.path.basename ( distdir ) if name is None else name,\n directory=distdir,\n src_uri=src_uri\n ) )","def command_new_repo(self):\n repoinit.new_repo(*self.args())","def _git_add(repo, path, contents='example!\\n'):\n path.write_text(contents)\n subprocess.run(['git', '-C', repo, 'add', path], check=True)","def register_team_membership(self, body):\n url_regex = re.compile(r'^{url}teams/\\d+/memberships/\\w+$'.format(\n url=re.escape(self.URL),\n ))\n httpretty.register_uri(\n httpretty.PUT, url_regex, body=body\n )\n httpretty.register_uri(\n httpretty.DELETE, url_regex, body=body\n )","def add_team(self):\n team = Team(self.context, ResourcePath(\"team\", self.resource_path))\n team._parent_collection = self.parent_collection\n qry = ServiceOperationQuery(self, \"team\", None, team, None, team)\n self.context.add_query(qry)\n\n def _construct_create_team_request(request):\n cur_qry = self.context.current_query\n if cur_qry.id == qry.id:\n request.method = HttpMethod.Put\n request.set_header('Content-Type', \"application/json\")\n request.data = json.dumps(request.data)\n\n self.context.before_execute(_construct_create_team_request, False)\n return team","def addTeam(request):\n registered = False\n if request.method == 'POST':\n team_form = TeamForm(data=request.POST)\n if team_form.is_valid():\n team = team_form.save()\n registered = True\n else:\n print(team_form.errors)\n else:\n team_form = TeamForm()\n return render(request,'footBallApp/team.html',\n {'team_form':team_form,\n 'registered':registered})","def callback_team_repo(self, request, uri, headers, status_code=204):\n self.assertEqual(\n request.headers['Authorization'],\n 'token {0}'.format(self.OAUTH2_TOKEN)\n )\n self.assertIsNotNone(re.match(\n '{url}teams/[13]/repos/{org}/({repo}|{rerun_repo})'.format(\n url=re.escape(self.URL),\n org=self.ORG,\n repo=re.escape(self.TEST_REPO),\n rerun_repo=re.escape(self.TEST_RERUN_REPO)\n ),\n uri\n ))\n if status_code == 422:\n return (status_code, headers, json.dumps({\n \"message\": \"Validation Failed\",\n }))\n return (status_code, headers, '')","def add_team_player(self, team_file, player_file):\n\n team_data = self.read_team_data(team_file)\n team_data['player_files'].append(player_file)\n self.update_team_data(team_file, team_data)","def _register_teams(self):\n # loop through all agents\n for agent_id, agent_body in self.registered_agents.items():\n # find their team name\n team = agent_body.properties['team']\n\n # register the team (if not already done) and the agent in it\n if team not in self.__teams:\n self.__teams[team] = []\n self.__teams[team].append(agent_id)","def register_repo_check(self, body):\n httpretty.register_uri(\n httpretty.GET,\n re.compile(\n '^{url}repos/{org}/({repo}|{repo_rerun})$'.format(\n url=self.URL,\n org=self.ORG,\n repo=re.escape(self.TEST_REPO),\n repo_rerun=re.escape(self.TEST_RERUN_REPO)\n )\n ),\n body=body\n )","def stage_changes(c):\n c.run(f\"git add -u\")","def add_all(self, top_repo_path):\n my_output = subprocess.check_output([\"git\", \"add\", \"-A\"], cwd=top_repo_path)\n return my_output","def add_tag(tag):\n check_call(['git', 'tag', tag])","def addTeam(teaminfo):\r\n team, auto, rc_comp, spirit_comp, video_comp = teaminfo\r\n if team_exists(team): # Team already exists\r\n print(\"Team\", team, \"already exists.\")\r\n else:\r\n with sqlite3.connect(database_file) as conn:\r\n #(teamname TEXT, autonomous TEXT, rc TEXT, spirit INT, video INT)\r\n conn.execute(\"INSERT INTO scores(teamname, autonomous, rc, spirit, video)\\\r\n VALUES('{0}', '{1}', '{2}', '{3}', '{4}');\".format(team, auto, rc_comp, spirit_comp, video_comp))","def create_from_git(self, token: Any, repo: str):\n params = [token, repo, ]\n method = \"ProjectAPI.CreateFromGit\"\n self.__add_request(method, params, lambda payload: Definition.from_json(payload))","def add(self, filename, top_repo_path):\n my_output = subprocess.check_output([\"git\", \"add\", filename], cwd=top_repo_path)\n return my_output","async def team_role(self, ctx: commands.Context, *, team: HockeyTeams) -> None:\n guild = ctx.message.guild\n if team is None:\n return await ctx.send(_(\"You must provide a valid current team.\"))\n try:\n role = [\n role\n for role in guild.roles\n if (team.lower() in role.name.lower() and \"GOAL\" not in role.name)\n ]\n if role[0] >= guild.me.top_role:\n return\n await ctx.author.add_roles(role[0])\n await ctx.send(role[0].name + _(\" role applied.\"))\n except Exception:\n log.error(\"error adding team role\", exc_info=True)\n await ctx.send(team + _(\" is not an available role!\"))","def install_experiment(self):\n # read git credentials configuration\n try:\n with open('GlobalConfigurations/tokens.json', 'r') as tokens_file:\n data = json.load(tokens_file)\n username = data['GitHub']['user']\n password = data['GitHub']['password']\n\n except EnvironmentError:\n print('Cannot open tokens file')\n\n protocol_name = self.protocol_config['protocol']\n working_directory = self.protocol_config['workingDirectory']\n cp = list(self.protocol_config['CloudProviders'].keys())\n git_address = self.protocol_config['CloudProviders'][cp[0]]['git']['gitAddress']\n git_branch = self.protocol_config['CloudProviders'][cp[0]]['git']['gitBranch']\n\n for idx in range(len(working_directory)):\n os.system(f'fab -f Execution/fabfile.py install_git_project:{username},{password},{git_branch[idx]},'\n f'{git_address[idx]},{working_directory[idx]} --parallel | '\n f' tee WebApp/ExecutionLogs/{protocol_name}.log')","def add_easyconfig(self, cfg, name, version, stats, append):\n dest = FileRepository.add_easyconfig(self, cfg, name, version, stats, append)\n # add it to version control\n if dest:\n try:\n self.client.add(dest)\n except GitCommandError, err:\n self.log.warning(\"adding %s to git failed: %s\" % (dest, err))","def _AddRepository(url):\n name = url.split('/')[-1]\n\n if ndb.Key(Repository, name).get():\n raise AssertionError(\"Attempted to add a repository that's already in the \"\n 'Datastore: %s: %s' % (name, url))\n\n Repository(id=name, urls=[url]).put()\n return name","def test_register_team_already_team(self):\n result = self.client.post(\"/teams\", data={\"already_team\": \"Killers\"}, follow_redirects=True)\n self.assertEqual(result.status_code, 200)\n # self.assertIn(b\"Sorry! That team name is already in use!\", result.data) #error:not in /teams, but should be in createTeam","def test_add_repo(self):\r\n with self.assertRaisesRegexp(GitImportError, GitImportError.NO_DIR):\r\n git_import.add_repo(self.TEST_REPO, None, None)\r\n\r\n os.mkdir(self.GIT_REPO_DIR)\r\n self.addCleanup(shutil.rmtree, self.GIT_REPO_DIR)\r\n\r\n with self.assertRaisesRegexp(GitImportError, GitImportError.URL_BAD):\r\n git_import.add_repo('foo', None, None)\r\n\r\n with self.assertRaisesRegexp(GitImportError, GitImportError.CANNOT_PULL):\r\n git_import.add_repo('file:///foobar.git', None, None)\r\n\r\n # Test git repo that exists, but is \"broken\"\r\n bare_repo = os.path.abspath('{0}/{1}'.format(settings.TEST_ROOT, 'bare.git'))\r\n os.mkdir(bare_repo)\r\n self.addCleanup(shutil.rmtree, bare_repo)\r\n subprocess.check_output(['git', '--bare', 'init', ], stderr=subprocess.STDOUT,\r\n cwd=bare_repo)\r\n\r\n with self.assertRaisesRegexp(GitImportError, GitImportError.BAD_REPO):\r\n git_import.add_repo('file://{0}'.format(bare_repo), None, None)","def register_packages(self, module_name, extra_package):\n self.creator_manager.register_packages(module_name, extra_package)","def addbot(connection, amount=None, team=None):\n protocol = connection.protocol\n if team:\n bot_team = get_team(connection, team)\n blue, green = protocol.blue_team, protocol.green_team\n amount = int(amount or 1)\n for i in range(amount):\n if not team:\n bot_team = blue if blue.count() < green.count() else green\n bot = protocol.add_bot(bot_team)\n if not bot:\n return \"Added %s bot(s)\" % i\n return \"Added %s bot(s)\" % amount","def assign_team(self, nickname, team):\n cmd = '{}assignTeam \"{}\" {}'.format(self.console, Commands.aquote(nickname), Commands.get_team(team))\n self.write_command(cmd)","def test_add_greenfield_repos(tmpdir, HOME):\n from homely._errors import ERR_NO_COMMITS, ERR_NOT_A_REPO, ERR_NO_SCRIPT\n\n system = getsystemfn(HOME)\n\n def _repolist():\n cmd = HOMELY('repolist') + ['--format', '%(localpath)s']\n return list(filter(None, system(cmd).strip().split(\"\\n\")))\n\n # Target dir is not a git repo\n notarepo = HOME + '/not_a_repo'\n os.mkdir(notarepo)\n contents(notarepo + '/HOMELY.py', \"print('YES')\\n\")\n output = system(HOMELY('add') + [notarepo], expecterror=1)\n assert ERR_NOT_A_REPO in output\n del notarepo, output\n # this should have resulted in nothing being added to homely\n assert not len(_repolist())\n\n # Target dir doesn't have any commits\n nocommits = HOME + '/nocommits'\n os.mkdir(nocommits)\n contents(nocommits + '/HOMELY.py', \"print('YES')\\n\")\n system(['git', 'init'], cwd=nocommits)\n assert os.path.exists(nocommits + '/.git')\n output = system(HOMELY('add') + [nocommits], expecterror=1)\n assert ERR_NO_COMMITS in output\n del nocommits, output\n # this should have resulted in nothing being added to homely\n assert not len(_repolist())\n\n # Target dir doesn't have a HOMELY.py script - when we add a repo that\n # doesn't have a HOMELY.py script we should raise an error and provide\n # instructions on how to write a HOMELY.py script (and not try to do the\n # homely update).\n noscript = HOME + '/noscript'\n os.mkdir(noscript)\n readme = noscript + '/README.md'\n contents(readme, \"Hello world!\\n\")\n system(['git', 'init'], cwd=noscript)\n system(['git', 'config', 'user.name', \"fred\"], cwd=noscript)\n system(['git', 'config', 'user.email', \"fred@example\"], cwd=noscript)\n system(['git', 'add', 'README.md'], cwd=noscript)\n system(['git', 'commit', '-m', \"Added readme\"], cwd=noscript)\n output = system(HOMELY('add') + [noscript], expecterror=1)\n assert ERR_NO_SCRIPT in output\n # the repo should have added to homely\n assert [noscript] == _repolist()","def add_league_teams(league_diction, team_count, host, root, password):\r\n teams_diction = scrape_teams(league_diction, team_count)\r\n create_teams(host, root, password, dict_to_read=teams_diction)\r\n\r\n return teams_diction","def add_prod_repo_as_origin_and_push(git_repo_name):\n local(\"\"\"echo '[remote \"origin\"]' >> .git/config\"\"\")\n local(r\"echo ' fetch = +refs/heads/*:refs/remotes/origin/*' >> .git/config\")\n local(r\"echo ' url = %s:webapps/git/repos/%s.git' >> .git/config\" % (env.hosts[0], git_repo_name))\n local(r\"git push origin master\")","def addOrganisation(SID, name):\n return call(\"addOrganisation\", SID, name)","def add_team(display_name, indexed_name, game, division, fingerprint, now=None):\n\ttry:\n\t\tteam = session.query(Team).filter(Team.fingerprint == fingerprint).one()\n\t\tteam.display_name = display_name\n\t\tteam.indexed_name = indexed_name\n\texcept sa_orm.exc.NoResultFound:\n\t\tteam = Team(display_name=display_name, indexed_name=indexed_name,\n\t\t\t\tgame=game, division=division, fingerprint=fingerprint)\n\t\tsession.add(team)\n\n\tsession.commit()\n\treturn team.id","def update_teams(self, team_name, numero, pc):\n\n self.execute(TABELLE['teams']['insert'], (team_name, numero, pc))","def process_events(gitlab_server, gitlab_token, debug=False):\n global gitlab, hook_url\n gitlab = GLSession(gitlab_server, gitlab_token)\n if debug:\n logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)\n\n group = gitlab.createGroup(\"forestscribetest\")['id']\n gitlab.createRepo(group, \"test_repo1\")\n gitlab.createRepo(group, \"test_repo2\")\n gitlab.createRepo(group, \"test_repo3\")","def pushrepo(projectjson, repourl):\n try:\n components = projectjson['components']\n name = projectjson['name']\n reponame = name + '_sc'\n logger.debug(f\"repourl is : {repourl}\")\n bb_split = repourl.split(\"//\")\n bb_split[1] = f\"{username}:{escape_password}@\"+bb_split[1]\n newrepourl = \"//\".join(bb_split)\n local_code_setup(reponame, newrepourl)\n dst_makefile_path = f\"/tmp/{reponame}/Makefile\"\n if not os.path.exists(dst_makefile_path):\n src_makefile_path = f\"/tmp/skeleton-build/Makefile\"\n copy2(src_makefile_path, dst_makefile_path)\n print(\"Makefile added\")\n createcomponents(components, reponame, newrepourl, name)\n bitbucket.push_repo_to_bitbucket(f\"/tmp/{reponame}\")\n rmtree('/tmp/skeleton-build')\n rmtree(f'/tmp/{reponame}')\n return True\n except Exception as e:\n print(\"caught exception.: \", e)\n return False","def register_manager(self, update, context):\r\n new_manager_chat_id = update['message']['chat']['id']\r\n new_manager_name = update['message']['chat']['first_name']\r\n\r\n with open('managers.json') as obj:\r\n managers = json.load(obj)\r\n\r\n managers[new_manager_name] = new_manager_chat_id\r\n\r\n with open('managers.json', 'w') as obj:\r\n json.dump(managers, obj)\r\n\r\n context.bot.send_message(chat_id=update.message.chat_id, text=f'{new_manager_name} - {new_manager_chat_id}')","def test_add_repo_to_empty(tmpdir):\n # Arange\n cfg = tmpdir.mkdir(\"sub\").join(\"empty.json\")\n REPO = \"foo.bar/foobar\"\n NAME = \"foorepo\"\n # Act\n rm = gcbo.RepoManager(repo=REPO, cfg=cfg)\n rm.save(NAME)\n\n # Assert\n with open(cfg) as fp:\n data = json.load(cfg)\n assert data[NAME][\"url\"] == REPO","def test_handle_add_not_admin(self):\n test_user = User(\"userid\")\n test_user.github_username = \"githubuser\"\n team = Team(\"BRS\", \"brs\", \"web\")\n team.github_team_id = \"githubid\"\n self.db.retrieve.return_value = test_user\n self.db.query.return_value = [team]\n self.assertTupleEqual(self.testcommand.handle(\"team add brs ID\", user),\n (self.testcommand.permission_error, 200))\n self.db.store.assert_not_called()\n self.gh.add_team_member.assert_not_called()","def add_to_repository(user):\n try:\n repository.add(user)\n except (KeyError, DuplicateIndexError):\n raise","def add(self, add_all=False, filepattern='', loop=None):\n assert add_all or filepattern\n\n yield from _run_command(\n 'git add {} {}'.format('--all' if add_all else '', filepattern),\n self._path, loop=loop)","async def channel_add(\n self, ctx: commands.Context, channel: Union[discord.TextChannel, discord.VoiceChannel], *team_ids: int):\n if set(team_ids) - set(self.teams):\n await ctx.send('Missing data for the following team IDs: %s' % (\n ', '.join(map(str, set(team_ids) - set(self.teams))),))\n return\n\n await asyncio.gather(*[\n self._permit_team_in_channel(self.teams[team_id], channel)\n for team_id in team_ids],\n return_exceptions=True)\n await ctx.send('Added team%s `%s` to channel %s' % (\n nl.s(len(team_ids)),\n '`, `'.join(self.teams[team_id].username for team_id in team_ids),\n channel.mention))","def addDevs(repo,name,permissions):\n #print(\"before clientSocket\") \n clientSocket = connectToServer()\n #print(\"after connectToServer\")\n\n PACKET = {} \n\n if repo == \".\":\n #print(\"inside repo .\")\n repo = getCurrentRepoName()\n #print(\"after repo .\") \n\n PACKET[\"repo\"] = repo\n PACKET[\"userData\"] = authenticate()\n \n #print(f\" name : {name} and permissions : {permissions}\") \n\n if name and permissions: \n #print(\"in side add devs name and permissions\") \n addDevOne(clientSocket,PACKET,name,permissions)\n \n elif not name and not permissions:\n #print(\"in side add devs not name and not permissions\")\n addDevMul(clientSocket,PACKET)\n\n else:\n click.secho(\"Invalid operation\",fg=\"red\")","def test_add_invalid_svn_repo(self):\n pass","def add(ref):\n cmd = 'qri add %s' % ref\n print('Fetching from registry...')\n result, err = shell_exec(cmd)\n return 'Added %s: %s' % (ref, result)","def addRepository(self, addType, repoPath=\"\", repoUser=\"\", repoPassword=\"\", defaultRepository=True,\n onlyTestConnection=False):\n try:\n utility.execLog(\"Navigating to Firmware Tab\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('FW_tab'))), action=\"CLICK\")\n utility.execLog(\"Clicking on 'Add Repository'\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('Add_FW'))), action=\"CLICK\")\n utility.execLog(\"Verifying 'Add Firmware Repository' Page\")\n pageTitle = self.handleEvent(\n EC.element_to_be_clickable((By.CLASS_NAME, self.RepositoriesObjects('modal_title'))), action=\"GET_TEXT\")\n if \"Add Firmware / Software Repository\" not in pageTitle:\n return self.browserObject, False, \"Failed to verify 'Add Firmware Repository' Page Actual:'%s' Expected:'%s'\" % (\n pageTitle, \"Add Firmware / Software Repository\")\n utility.execLog(\"Verified 'Add Firmware Repository' Page Actual:'%s' Expected:'%s'\" % (\n pageTitle, \"Add Firmware / Software Repository\"))\n if addType == \"Network Path\":\n utility.execLog(\"Selecting Network Path Option\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('catalog_local'))),\n action=\"CLICK\")\n utility.execLog(\"Setting Network Path '%s'\" % repoPath)\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('local_file_path'))),\n action=\"SET_TEXT\", setValue=repoPath)\n if repoUser:\n utility.execLog(\"Setting Network Username '%s'\" % repoUser)\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('local_UN'))),\n action=\"SET_TEXT\", setValue=repoUser)\n if repoPassword:\n utility.execLog(\"Setting Network Password '%s'\" % repoPassword)\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('password'))),\n action=\"SET_TEXT\", setValue=repoPassword)\n elif addType == \"Local Drive\":\n utility.execLog(\"Selecting Local Drive Option\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('catalog_file'))),\n action=\"CLICK\")\n utility.execLog(\"Setting Local Drive Path '%s'\" % repoPath)\n self.handleEvent(EC.presence_of_element_located((By.ID, self.RepositoriesObjects('file_browse_path'))),\n action=\"SET_TEXT\", setValue=repoPath)\n else:\n utility.execLog(\"Selecting 'Import From Dell FTP' Option\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('catalog_FTP'))),\n action=\"CLICK\")\n if defaultRepository:\n utility.execLog(\"Selecting 'Make Default Repository' Option\")\n if not self.handleEvent(\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\n action=\"IS_SELECTED\"):\n self.handleEvent(\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\n action=\"CLICK\")\n else:\n utility.execLog(\"Unselect 'Make Default Repository' Option\")\n if self.handleEvent(\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\n action=\"IS_SELECTED\"):\n self.handleEvent(\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\n action=\"CLICK\")\n if onlyTestConnection and addType != \"Local Drive\":\n utility.execLog(\"Selecting 'Test Connection' Option\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('FW_TC'))), action=\"CLICK\")\n time.sleep(1)\n try:\n utility.execLog(\"Checking for presence of error message\")\n eleError = self.handleEvent(\n EC.presence_of_element_located((By.CLASS_NAME, self.RepositoriesObjects('alert_danger'))), wait_time=5,\n retry=False)\n errorMessage = eleError.find_element_by_tag_name(\"ul\").text\n utility.execLog(errorMessage)\n return self.browserObject, False, \"Failed to Initiate Test Connection for Repository :: Error -> '%s'\" % (\n str(errorMessage))\n except:\n utility.execLog(\"No error message found\")\n utility.execLog(\"Identifying Confirm Dialog box\")\n self.handleEvent(EC.text_to_be_present_in_element((By.XPATH, self.RepositoriesObjects('dialog_box')), \"Success\"))\n utility.execLog(\"Confirming Test Connection\")\n self.handleEvent(EC.element_to_be_clickable((By.XPATH, self.RepositoriesObjects('btn_close'))),\n action=\"CLICK\")\n utility.execLog(\"Test of connection was successful\")\n return self.browserObject, True, \"Successfully Initiated Test Connection for Repository\"\n else:\n utility.execLog(\"Clicking on 'Save' to Add Repository\")\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('FW_save'))),\n action=\"CLICK\")\n time.sleep(1)\n self.handleEvent(EC.invisibility_of_element_located((By.XPATH, self.RepositoriesObjects('loading_in'))))\n utility.execLog(\"Clicked on 'Save' to Add Repository\")\n try:\n utility.execLog(\"Checking for presence of error message\")\n eleError = self.handleEvent(\n EC.presence_of_element_located((By.CLASS_NAME, self.RepositoriesObjects('alert_danger'))), wait_time=5,\n retry=False)\n errorMessage = eleError.find_element_by_tag_name(\"ul\").text\n return self.browserObject, False, \"Failed to Initiate Add Repository :: '%s' :: Error -> '%s'\" % (\n repoPath, str(errorMessage))\n except:\n utility.execLog(\"No error message found\")\n return self.browserObject, True, \"Successfully Initiated Add Repository '%s'\" % repoPath\n except Exception as e:\n utility.execLog(\"Failed to Initiate Add Repository :: '%s' :: Error -> %s\" % (repoPath, str(e)))\n return self.browserObject, False, \"Failed to Initiate Add Repository :: '%s' :: Error -> %s\" % (\n repoPath, str(e))","def event_register_collaborator(request, event_id, employee_id):\n if request.method == 'PUT':\n event = get_object_or_404(Event, pk=event_id, is_registration_open=True)\n collaborator = get_object_or_404(Employee, pk=employee_id)\n event.collaborators.add(collaborator)\n event.save()\n serializer = EventSimpleRegistrationSerializer(event)\n return Response(serializer.data, status=status.HTTP_202_ACCEPTED)","def register_team_members(self, body):\n httpretty.register_uri(\n httpretty.GET,\n re.compile(\n r'^{url}teams/\\d+/members$'.format(\n url=re.escape(self.URL)\n )\n ),\n body=body\n )","def update_from_repo():\n\treturn","def add_distdirs ( self, distdirs ):\n def gen_repos():\n for d in distdirs:\n repo = BasicRepo (\n name=os.path.basename ( d ),\n directory=d,\n distroot=self.distroot\n )\n self.logger.debug ( 'New entry, ' + str ( repo ) )\n yield repo\n # --- end of gen_repos() ---\n self.repos.extend ( gen_repos() )","def install(self: \"Repo\", use_pre_commit_tool: bool = False) -> None:\n from dvc.scm import Git\n\n scm = self.scm\n if not isinstance(scm, Git):\n return\n\n driver = \"dvc git-hook merge-driver --ancestor %O --our %A --their %B \"\n scm.install_merge_driver(\"dvc\", \"DVC merge driver\", driver)\n\n if use_pre_commit_tool:\n return pre_commit_install(scm)\n\n return install_hooks(scm)","def commitRepository(self, repository):\n runCommand(\n [\"git\", \"-C\", repository.path, \"add\"] + glob.glob(repository.path + \"/*\")\n )\n runCommand([\"git\", \"-C\", repository.path, \"commit\", \"-m\", \"hop\"])","def run(self):\n self.update_repos()","def test_assign_managing_team(self):\n pass","def add_org(cmd, *args):\n\n cfg = get_config()\n nick, org = None, None\n if len(args) == 0:\n print(add_org.__doc__)\n if len(args) >= 1:\n nick = args[0]\n if len(args) >= 2:\n org = args[1]\n if len(args) >= 3:\n print(\"only <nick> <org_addr> understood :(\")\n # other param breakdown here\n vcard_fn = nick + '.vcf'\n vcard_fn = os.path.join(cfg['vcard_dir'], vcard_fn)\n vCard = getvcard(vcard_fn)\n infoDict = dict_from_vcard(vCard)\n infoDict['org'] = [org, ] # list-ize. Dunnow why yet\n\n ## make changes to infodict here\n vcard_merge_in_dict(infoDict, vCard)\n rawdata = vCard.serialize()\n with open(vcard_fn, 'w+') as fh:\n fh.write(rawdata)\n return True","def repo(self, user, repo):\r\n return repos.Repo(self, user, repo)"],"string":"[\n \"def add(name, url):\\n click.echo(\\\"registered repo {} at url {}\\\".format(name, url))\",\n \"def _RegisterAmberRepository(self, tuf_repo, remote_port):\\n\\n # Extract the public signing key for inclusion in the config file.\\n root_keys = []\\n root_json_path = os.path.join(tuf_repo, 'repository', 'root.json')\\n root_json = json.load(open(root_json_path, 'r'))\\n for root_key_id in root_json['signed']['roles']['root']['keyids']:\\n root_keys.append({\\n 'Type': root_json['signed']['keys'][root_key_id]['keytype'],\\n 'Value': root_json['signed']['keys'][root_key_id]['keyval']['public']\\n })\\n\\n # \\\"pm serve\\\" can automatically generate a \\\"config.json\\\" file at query time,\\n # but the file is unusable because it specifies URLs with port\\n # numbers that are unreachable from across the port forwarding boundary.\\n # So instead, we generate our own config file with the forwarded port\\n # numbers instead.\\n config_file = open(os.path.join(tuf_repo, 'repository', 'repo_config.json'),\\n 'w')\\n json.dump({\\n 'ID': _MANAGED_REPO_NAME,\\n 'RepoURL': \\\"http://127.0.0.1:%d\\\" % remote_port,\\n 'BlobRepoURL': \\\"http://127.0.0.1:%d/blobs\\\" % remote_port,\\n 'RatePeriod': 10,\\n 'RootKeys': root_keys,\\n 'StatusConfig': {\\n 'Enabled': True\\n },\\n 'Auto': True\\n }, config_file)\\n config_file.close()\\n\\n # Register the repo.\\n return_code = self._target.RunCommand(\\n [('amberctl rm_src -n %s; ' +\\n 'amberctl add_src -f http://127.0.0.1:%d/repo_config.json')\\n % (_MANAGED_REPO_NAME, remote_port)])\\n if return_code != 0:\\n raise Exception('Error code %d when running amberctl.' % return_code)\",\n \"def add(orgname, pat, reponame, branchname):\\n g = Github(pat)\\n repo = g.get_organization(orgname).get_repo(reponame)\\n all_files = []\\n contents = repo.get_contents(\\\"\\\")\\n while contents:\\n file_content = contents.pop(0)\\n if file_content.type == \\\"dir\\\":\\n contents.extend(repo.get_contents(file_content.path))\\n else:\\n file = file_content\\n all_files.append(str(file)\\n .replace('ContentFile(path=\\\"', '')\\n .replace('\\\")', ''))\\n\\n with open('./CODEOWNERS', 'r') as file:\\n content = file.read()\\n\\n # Upload to github\\n git_prefix = '.github/'\\n git_file = git_prefix + 'CODEOWNERS'\\n if git_file in all_files:\\n contents = repo.get_contents(git_file)\\n repo.update_file(contents.path,\\n \\\"updating CODEOWNERS\\\",\\n content,\\n contents.sha,\\n branch=branchname)\\n print(git_file + ' updated for: ' + reponame)\\n else:\\n repo.create_file(git_file,\\n \\\"adding CODEOWNERS\\\",\\n content,\\n branch=branchname)\\n print(git_file + ' created for: ' + reponame)\",\n \"def test_add_team_manager_to_team(self):\\n pass\",\n \"def register(id, name, get_packages, find_installed_packages):\\n repo = Repository()\\n repo.id = id\\n repo.name = name\\n repo.get_packages = get_packages\\n repo.find_installed_packages = find_installed_packages\\n repositories.append(repo)\",\n \"def _add_repo(repo_name, repo_url, index):\\n\\n package_manager = _get_package_manager()\\n package_manager.add_repo(repo_name, repo_url, index)\\n\\n return 0\",\n \"def add_addon_repository(self, repo: str) -> None:\\n if repo in self._data[ATTR_ADDONS_CUSTOM_LIST]:\\n return\\n\\n self._data[ATTR_ADDONS_CUSTOM_LIST].append(repo)\",\n \"def register_repo_create(self, body):\\n httpretty.register_uri(\\n httpretty.POST,\\n '{url}orgs/{org}/repos'.format(\\n url=self.URL,\\n org=self.ORG,\\n ),\\n body=body\\n )\",\n \"def repo_add(self, name, url, **kwargs):\\n\\n self.helm_client.repo_add(name, url, **kwargs)\",\n \"def __add_repo(repo_name, url):\\n\\n conn = sqlite3.connect(DTF_DB)\\n cur = conn.cursor()\\n\\n entry = [(repo_name, url)]\\n\\n sql = ('INSERT INTO repos (repo_name, url)'\\n 'VALUES (?, ?)')\\n\\n cur.executemany(sql, entry)\\n conn.commit()\\n\\n return 0\",\n \"def process_repo(vb, options):\\n if not options.repo:\\n return\\n\\n vb.add_repo(options.repo_os, options.repo_id, options.repo_name, options.repo_url,\\n options.unique, options.repo_tags)\",\n \"def fusion_api_add_repository(self, body, api=None, headers=None):\\n return self.repository.post(body, api, headers)\",\n \"def addRepository(self, name, url):\\n sslVerify = \\\"yes\\\" if url.startswith(\\\"https\\\") else \\\"no\\\"\\n self.manager.addKickstartRepository(self.currentProject, baseurl=url,\\n name=name,\\n ssl_verify=sslVerify)\\n self.manager.saveKickstartFile(self.currentProject)\\n self.refresh()\",\n \"def __gitSubmoduleAdd(self):\\n self.vcs.gitSubmoduleAdd(self.project.getProjectPath())\",\n \"def addRepository(self, uri):\\n pass\",\n \"def __gitAddRemote(self):\\n self.vcs.gitAddRemote(self.project.getProjectPath())\",\n \"def add_team(inp_to_add, type_to_add, host, root, password):\\r\\n team_name = \\\"\\\"\\r\\n\\r\\n if type_to_add == \\\"url\\\":\\r\\n team_soup = BeautifulSoup(requests.get(inp_to_add).text, 'html.parser')\\r\\n team_site = inp_to_add\\r\\n else:\\r\\n team_soup, team_site = get_first_search_result(\\r\\n SOCCER_URL + \\\"/search/teams/?q=\\\" + inp_to_add)\\r\\n\\r\\n if team_soup:\\r\\n # Need to examine if league already exists, if not - add it. Then, get its LEAGUE_ID\\r\\n league_url = SOCCER_URL + team_soup.find('div', id=\\\"page_team_1_block_team_table_9-wrapper\\\").h2.a[\\\"href\\\"]\\r\\n find_league({league_url}, \\\"url\\\", host, root, password)\\r\\n\\r\\n team_name = team_soup.find(\\\"table\\\", class_=\\\"leaguetable sortable table\\\").tbody.find_all(\\r\\n 'tr', class_=[\\\"odd highlight team_rank\\\", \\\"even highlight team_rank\\\"])[0].find(\\r\\n 'td', class_=\\\"text team large-link\\\").a.text\\r\\n\\r\\n return team_name\",\n \"def add_repo(self, id, user, repo):\\n request = self.request_builder('orgs.teams.add_repo',\\n id=id, user=user, repo=repo)\\n return self._put(request)\",\n \"def register_team(self, agents_on_team):\\n self.agents_on_team = agents_on_team\",\n \"def team_add(token_user):\\n if not json_param_exists('name') or \\\\\\n not json_param_exists('type'):\\n abort(400, \\\"one or more required parameter is missing\\\")\\n name = request.json['name']\\n team_type = TeamType.query.filter_by(name=request.json['type']).first()\\n if not team_type:\\n abort(400, \\\"invalid team type\\\")\\n\\n if team_type.name == 'other_team':\\n if not token_user.has_permission('team.create') and \\\\\\n not token_user.has_permission('team.create.elevated'):\\n abort(403, 'team creation is not permitted')\\n else: # creating any team other than 'other_team' requires elevated\\n if not token_user.has_permission('team.create.elevated'):\\n abort(403, 'insufficient permissions to create a team of this type')\\n\\n team = Team(name=name)\\n team.team_type = team_type\\n\\n try:\\n get_db().add(team)\\n get_db().commit()\\n except IntegrityError:\\n abort(409, 'team name is already in use')\\n\\n return '', 201\",\n \"def register(project_id, runner):\\n pass\",\n \"def add(self,path):\\n out, err, code = self.command( [\\\"git\\\", \\\"add\\\", path], self.directory )\",\n \"def add_repo(repo_name, url):\\n\\n # First, validate the URL\\n if not utils.is_valid_url(url):\\n log.e(TAG, \\\"Invalid URL provided (missing http/s)\\\")\\n return -2\\n\\n # Next, make sure this repo doesnt exist\\n if __has_repo(repo_name):\\n log.e(TAG, \\\"Repo name '%s' already exists!\\\" % repo_name)\\n return -3\\n\\n return __add_repo(repo_name, url)\",\n \"def add(self, team):\\n ### INVARIANT: team is a Team class object.\\n if team not in self._conf_teams:\\n self._conf_teams.append(team)\",\n \"async def add_to_team(self, player : Player, team):\\r\\n if player in self.remaining:\\r\\n self.teams[team].append(player)\\r\\n self.remaining.remove(player)\\r\\n return discord.Embed(title=\\\"Valorant 10 Man Bot\\\",\\r\\n description=\\\"{} has been drafted to team {}\\\".format(get_member_name(player,lower=False), \\\":a:\\\" if team == \\\"A\\\" else \\\":b:\\\"))\\r\\n else:\\r\\n return discord.Embed(title=\\\"Valorant 10 Man Bot\\\",description=\\\"Sorry, {} is already drafted\\\".format(get_member_name(player)))\",\n \"def addTag(self, repoType, txt, addSlash=True, project=0):\\n # remove slash\\n while txt.startswith(\\\"/\\\"):\\n txt = txt[1:]\\n \\n # add fix to support & in filename, ampersand is used \\n # as a shortcut for the tab by pyqt\\n txt = txt.replace(\\\"&\\\", \\\"&&\\\")\\n # end of fix\\n \\n if repoType == UCI.REPO_TESTS_LOCAL:\\n repo = \\\"local-tests\\\"\\n elif repoType == UCI.REPO_TESTS:\\n repo = \\\"remote-tests\\\"\\n project_name = self.iRepo.remote().getProjectName(project=project)\\n repo += '(%s)' % project_name\\n elif repoType == UCI.REPO_ADAPTERS:\\n repo = \\\"remote-adapters\\\"\\n elif repoType == UCI.REPO_LIBRARIES:\\n repo = \\\"remote-libraries\\\"\\n elif repoType == UCI.REPO_UNDEFINED:\\n repo = \\\"undefined\\\"\\n else:\\n repo = \\\"unknown\\\"\\n self.error( \\\"repo unknown: %s\\\" % repoType )\\n if addSlash:\\n if repoType == UCI.REPO_TESTS_LOCAL:\\n ret = \\\"%s:%s\\\" % (repo, txt) \\n else:\\n ret = \\\"%s:/%s\\\" % (repo, txt)\\n else:\\n ret = \\\"%s: %s\\\" % (repo, txt) \\n return ret\",\n \"def gitAdd(filename, repo_dir):\\n file_path = \\\"%s/%s\\\" % (repo_dir, filename)\\n git(\\\"add\\\", file_path)\",\n \"def registerTeam(self, agentsOnTeam):\\n\\n self.agentsOnTeam = agentsOnTeam\",\n \"def commit_changes(repo, project = ''):\\n cmd = repo.git\\n cmd.add(all=True)\\n try:\\n cmd.commit(m=\\\"redcap2mysql.py data sync for project \\\" + project)\\n except git.exc.GitCommandError, err:\\n logging.info([traceback.format_exc(limit=1).splitlines()[-1]])\",\n \"def add(self, organisation: Organisation) -> None:\\n ...\",\n \"def create_repo(self, repo):\\n return self.user_con.create_repo(repo=repo)\",\n \"def register_git_repository(args, namespace, notifier=None):\\n\\n tempdir = tempfile.mkdtemp()\\n subprocess.check_call(\\n \\\"\\\"\\\"\\n cd {} &&\\n git clone {} user_code\\n \\\"\\\"\\\".format(tempdir, args.git_repository), shell=True)\\n return register(Service, args, namespace,\\n os.path.join(tempdir, 'user_code'), notifier)\",\n \"def add(self):\\r\\n self._svn('add')\",\n \"def add_user_to_team(self, for_user, to_manager):\\n for_user = User.get_user_by_username(for_user)\\n manager = User.get_user_by_username(to_manager)\\n # @Todo test inheritance of get_user_by_username\\n self.access_handler.check_add_user_to_team(for_user, manager)\\n manager.add_user_to_team(for_user)\",\n \"def newrepo():\\n form = AddRepoForm()\\n if form.validate_on_submit():\\n\\n # make the directory for this package\\n os.mkdir(DATA + form.name.data)\\n\\n flash('Repo created successfully')\\n\\n # redirect to the login page\\n return redirect(url_for('home.dashboard'))\\n\\n # load registration template\\n return render_template('home/add.html', form=form, title='Local Repo', target=\\\"add\\\")\",\n \"def test_teams_add_user_to_team_v2(self):\\n pass\",\n \"def _add_missing_repositories(frozen_repos, ret, **kwargs):\\n repos = __salt__[\\\"pkg.list_repos\\\"](**kwargs)\\n missing_repos = set(frozen_repos) - set(repos)\\n for repo in missing_repos:\\n try:\\n # In Python 2 we cannot do advance destructuring, so we\\n # need to create a temporary dictionary that will merge\\n # all the parameters\\n _tmp_kwargs = frozen_repos[repo].copy()\\n _tmp_kwargs.update(kwargs)\\n __salt__[\\\"pkg.mod_repo\\\"](repo, **_tmp_kwargs)\\n ret[\\\"repos\\\"][\\\"add\\\"].append(repo)\\n log.info(\\\"Added missing repository %s\\\", repo)\\n except Exception as e: # pylint: disable=broad-except\\n msg = \\\"Error adding %s repository: %s\\\"\\n log.error(msg, repo, e)\\n ret[\\\"comment\\\"].append(msg % (repo, e))\",\n \"def on_add(self, project, name, **kwargs):\\n pass\",\n \"def add_repository(self, repo):\\n repo = repo.lower()\\n command = shlex.split(\\\"sudo add-apt-repository -y ppa:\\\"+repo)\\n print subprocess.call(command)\",\n \"def test_teams_add_user_to_team_v1(self):\\n pass\",\n \"def add_team(self, team):\\n return self \\\\\\n .team_identifier(team.identifier) \\\\\\n .fold() \\\\\\n .coalesce(\\n # The team exists.\\n __.unfold()\\n .project('vertex', 'exists')\\n .by(__.identity().elementMap())\\n .by(__.constant(True)),\\n # The team does not exist.\\n __.addV('Team')\\n .property(T.id, str(uuid.uuid4()))\\n .property(Cardinality.single, 'identifier', team.identifier)\\n .property(Cardinality.single, 'name', team.name)\\n .project('vertex', 'exists')\\n .by(__.identity().elementMap())\\n .by(__.constant(False)),\\n )\",\n \"def test_handle_add(self):\\n test_user = User(\\\"userid\\\")\\n test_user.permissions_level = Permissions.admin\\n test_user.github_username = \\\"githubuser\\\"\\n team = Team(\\\"BRS\\\", \\\"brs\\\", \\\"web\\\")\\n team.github_team_id = \\\"githubid\\\"\\n add_user = User(\\\"anotheruser\\\")\\n add_user.github_username = \\\"myuser\\\"\\n add_user.github_id = \\\"otherID\\\"\\n self.db.retrieve.side_effect = [test_user, add_user]\\n self.db.query.return_value = [team]\\n with self.app.app_context():\\n resp, code = self.testcommand.handle(\\\"team add brs ID\\\", user)\\n team_attach = team.get_attachment()\\n expect = {'attachments': [team_attach],\\n 'text': 'Added User to brs'}\\n self.assertDictEqual(resp, expect)\\n self.assertEqual(code, 200)\\n self.db.store.assert_called_with(team)\\n assert team.has_member(\\\"otherID\\\")\\n self.gh.add_team_member.assert_called_once_with(\\\"myuser\\\", \\\"githubid\\\")\",\n \"def add_user(self, team, params={}, **options):\\n path = \\\"/teams/%s/addUser\\\" % (team)\\n return self.client.post(path, params, **options)\",\n \"def team_user_add(token_user, team_id, user_id):\\n team = Team.query.get(team_id)\\n if team is None:\\n abort(404, 'team not found')\\n\\n # check for permissions to update the team\\n if not (token_user.has_permission('team.update.elevated') or\\n (token_user.has_permission('team.update') and\\n team.has_member(token_user))):\\n abort(403, 'insufficient permissions to add user to team')\\n\\n # don't allow adding to 'single' teams\\n if team.team_type == TeamType.query.filter_by(name='single').first():\\n abort(400, 'cannot add a user to a \\\"single\\\" team')\\n\\n user = User.query.get(user_id)\\n if user is None:\\n abort(400, 'invalid user id')\\n\\n if team.has_member(user):\\n abort(409, 'user already in team')\\n\\n user.teams.append(team)\\n get_db().commit()\\n\\n return '', 201\",\n \"def patch_repos(self):\",\n \"def repository_create_hosted():\\n pass\",\n \"def test_add_team_member(self):\\n pass\",\n \"def add_distdir ( self, distdir, src_uri=None, name=None ):\\n self.repos.append ( BasicRepo (\\n name=os.path.basename ( distdir ) if name is None else name,\\n directory=distdir,\\n src_uri=src_uri\\n ) )\",\n \"def command_new_repo(self):\\n repoinit.new_repo(*self.args())\",\n \"def _git_add(repo, path, contents='example!\\\\n'):\\n path.write_text(contents)\\n subprocess.run(['git', '-C', repo, 'add', path], check=True)\",\n \"def register_team_membership(self, body):\\n url_regex = re.compile(r'^{url}teams/\\\\d+/memberships/\\\\w+$'.format(\\n url=re.escape(self.URL),\\n ))\\n httpretty.register_uri(\\n httpretty.PUT, url_regex, body=body\\n )\\n httpretty.register_uri(\\n httpretty.DELETE, url_regex, body=body\\n )\",\n \"def add_team(self):\\n team = Team(self.context, ResourcePath(\\\"team\\\", self.resource_path))\\n team._parent_collection = self.parent_collection\\n qry = ServiceOperationQuery(self, \\\"team\\\", None, team, None, team)\\n self.context.add_query(qry)\\n\\n def _construct_create_team_request(request):\\n cur_qry = self.context.current_query\\n if cur_qry.id == qry.id:\\n request.method = HttpMethod.Put\\n request.set_header('Content-Type', \\\"application/json\\\")\\n request.data = json.dumps(request.data)\\n\\n self.context.before_execute(_construct_create_team_request, False)\\n return team\",\n \"def addTeam(request):\\n registered = False\\n if request.method == 'POST':\\n team_form = TeamForm(data=request.POST)\\n if team_form.is_valid():\\n team = team_form.save()\\n registered = True\\n else:\\n print(team_form.errors)\\n else:\\n team_form = TeamForm()\\n return render(request,'footBallApp/team.html',\\n {'team_form':team_form,\\n 'registered':registered})\",\n \"def callback_team_repo(self, request, uri, headers, status_code=204):\\n self.assertEqual(\\n request.headers['Authorization'],\\n 'token {0}'.format(self.OAUTH2_TOKEN)\\n )\\n self.assertIsNotNone(re.match(\\n '{url}teams/[13]/repos/{org}/({repo}|{rerun_repo})'.format(\\n url=re.escape(self.URL),\\n org=self.ORG,\\n repo=re.escape(self.TEST_REPO),\\n rerun_repo=re.escape(self.TEST_RERUN_REPO)\\n ),\\n uri\\n ))\\n if status_code == 422:\\n return (status_code, headers, json.dumps({\\n \\\"message\\\": \\\"Validation Failed\\\",\\n }))\\n return (status_code, headers, '')\",\n \"def add_team_player(self, team_file, player_file):\\n\\n team_data = self.read_team_data(team_file)\\n team_data['player_files'].append(player_file)\\n self.update_team_data(team_file, team_data)\",\n \"def _register_teams(self):\\n # loop through all agents\\n for agent_id, agent_body in self.registered_agents.items():\\n # find their team name\\n team = agent_body.properties['team']\\n\\n # register the team (if not already done) and the agent in it\\n if team not in self.__teams:\\n self.__teams[team] = []\\n self.__teams[team].append(agent_id)\",\n \"def register_repo_check(self, body):\\n httpretty.register_uri(\\n httpretty.GET,\\n re.compile(\\n '^{url}repos/{org}/({repo}|{repo_rerun})$'.format(\\n url=self.URL,\\n org=self.ORG,\\n repo=re.escape(self.TEST_REPO),\\n repo_rerun=re.escape(self.TEST_RERUN_REPO)\\n )\\n ),\\n body=body\\n )\",\n \"def stage_changes(c):\\n c.run(f\\\"git add -u\\\")\",\n \"def add_all(self, top_repo_path):\\n my_output = subprocess.check_output([\\\"git\\\", \\\"add\\\", \\\"-A\\\"], cwd=top_repo_path)\\n return my_output\",\n \"def add_tag(tag):\\n check_call(['git', 'tag', tag])\",\n \"def addTeam(teaminfo):\\r\\n team, auto, rc_comp, spirit_comp, video_comp = teaminfo\\r\\n if team_exists(team): # Team already exists\\r\\n print(\\\"Team\\\", team, \\\"already exists.\\\")\\r\\n else:\\r\\n with sqlite3.connect(database_file) as conn:\\r\\n #(teamname TEXT, autonomous TEXT, rc TEXT, spirit INT, video INT)\\r\\n conn.execute(\\\"INSERT INTO scores(teamname, autonomous, rc, spirit, video)\\\\\\r\\n VALUES('{0}', '{1}', '{2}', '{3}', '{4}');\\\".format(team, auto, rc_comp, spirit_comp, video_comp))\",\n \"def create_from_git(self, token: Any, repo: str):\\n params = [token, repo, ]\\n method = \\\"ProjectAPI.CreateFromGit\\\"\\n self.__add_request(method, params, lambda payload: Definition.from_json(payload))\",\n \"def add(self, filename, top_repo_path):\\n my_output = subprocess.check_output([\\\"git\\\", \\\"add\\\", filename], cwd=top_repo_path)\\n return my_output\",\n \"async def team_role(self, ctx: commands.Context, *, team: HockeyTeams) -> None:\\n guild = ctx.message.guild\\n if team is None:\\n return await ctx.send(_(\\\"You must provide a valid current team.\\\"))\\n try:\\n role = [\\n role\\n for role in guild.roles\\n if (team.lower() in role.name.lower() and \\\"GOAL\\\" not in role.name)\\n ]\\n if role[0] >= guild.me.top_role:\\n return\\n await ctx.author.add_roles(role[0])\\n await ctx.send(role[0].name + _(\\\" role applied.\\\"))\\n except Exception:\\n log.error(\\\"error adding team role\\\", exc_info=True)\\n await ctx.send(team + _(\\\" is not an available role!\\\"))\",\n \"def install_experiment(self):\\n # read git credentials configuration\\n try:\\n with open('GlobalConfigurations/tokens.json', 'r') as tokens_file:\\n data = json.load(tokens_file)\\n username = data['GitHub']['user']\\n password = data['GitHub']['password']\\n\\n except EnvironmentError:\\n print('Cannot open tokens file')\\n\\n protocol_name = self.protocol_config['protocol']\\n working_directory = self.protocol_config['workingDirectory']\\n cp = list(self.protocol_config['CloudProviders'].keys())\\n git_address = self.protocol_config['CloudProviders'][cp[0]]['git']['gitAddress']\\n git_branch = self.protocol_config['CloudProviders'][cp[0]]['git']['gitBranch']\\n\\n for idx in range(len(working_directory)):\\n os.system(f'fab -f Execution/fabfile.py install_git_project:{username},{password},{git_branch[idx]},'\\n f'{git_address[idx]},{working_directory[idx]} --parallel | '\\n f' tee WebApp/ExecutionLogs/{protocol_name}.log')\",\n \"def add_easyconfig(self, cfg, name, version, stats, append):\\n dest = FileRepository.add_easyconfig(self, cfg, name, version, stats, append)\\n # add it to version control\\n if dest:\\n try:\\n self.client.add(dest)\\n except GitCommandError, err:\\n self.log.warning(\\\"adding %s to git failed: %s\\\" % (dest, err))\",\n \"def _AddRepository(url):\\n name = url.split('/')[-1]\\n\\n if ndb.Key(Repository, name).get():\\n raise AssertionError(\\\"Attempted to add a repository that's already in the \\\"\\n 'Datastore: %s: %s' % (name, url))\\n\\n Repository(id=name, urls=[url]).put()\\n return name\",\n \"def test_register_team_already_team(self):\\n result = self.client.post(\\\"/teams\\\", data={\\\"already_team\\\": \\\"Killers\\\"}, follow_redirects=True)\\n self.assertEqual(result.status_code, 200)\\n # self.assertIn(b\\\"Sorry! That team name is already in use!\\\", result.data) #error:not in /teams, but should be in createTeam\",\n \"def test_add_repo(self):\\r\\n with self.assertRaisesRegexp(GitImportError, GitImportError.NO_DIR):\\r\\n git_import.add_repo(self.TEST_REPO, None, None)\\r\\n\\r\\n os.mkdir(self.GIT_REPO_DIR)\\r\\n self.addCleanup(shutil.rmtree, self.GIT_REPO_DIR)\\r\\n\\r\\n with self.assertRaisesRegexp(GitImportError, GitImportError.URL_BAD):\\r\\n git_import.add_repo('foo', None, None)\\r\\n\\r\\n with self.assertRaisesRegexp(GitImportError, GitImportError.CANNOT_PULL):\\r\\n git_import.add_repo('file:///foobar.git', None, None)\\r\\n\\r\\n # Test git repo that exists, but is \\\"broken\\\"\\r\\n bare_repo = os.path.abspath('{0}/{1}'.format(settings.TEST_ROOT, 'bare.git'))\\r\\n os.mkdir(bare_repo)\\r\\n self.addCleanup(shutil.rmtree, bare_repo)\\r\\n subprocess.check_output(['git', '--bare', 'init', ], stderr=subprocess.STDOUT,\\r\\n cwd=bare_repo)\\r\\n\\r\\n with self.assertRaisesRegexp(GitImportError, GitImportError.BAD_REPO):\\r\\n git_import.add_repo('file://{0}'.format(bare_repo), None, None)\",\n \"def register_packages(self, module_name, extra_package):\\n self.creator_manager.register_packages(module_name, extra_package)\",\n \"def addbot(connection, amount=None, team=None):\\n protocol = connection.protocol\\n if team:\\n bot_team = get_team(connection, team)\\n blue, green = protocol.blue_team, protocol.green_team\\n amount = int(amount or 1)\\n for i in range(amount):\\n if not team:\\n bot_team = blue if blue.count() < green.count() else green\\n bot = protocol.add_bot(bot_team)\\n if not bot:\\n return \\\"Added %s bot(s)\\\" % i\\n return \\\"Added %s bot(s)\\\" % amount\",\n \"def assign_team(self, nickname, team):\\n cmd = '{}assignTeam \\\"{}\\\" {}'.format(self.console, Commands.aquote(nickname), Commands.get_team(team))\\n self.write_command(cmd)\",\n \"def test_add_greenfield_repos(tmpdir, HOME):\\n from homely._errors import ERR_NO_COMMITS, ERR_NOT_A_REPO, ERR_NO_SCRIPT\\n\\n system = getsystemfn(HOME)\\n\\n def _repolist():\\n cmd = HOMELY('repolist') + ['--format', '%(localpath)s']\\n return list(filter(None, system(cmd).strip().split(\\\"\\\\n\\\")))\\n\\n # Target dir is not a git repo\\n notarepo = HOME + '/not_a_repo'\\n os.mkdir(notarepo)\\n contents(notarepo + '/HOMELY.py', \\\"print('YES')\\\\n\\\")\\n output = system(HOMELY('add') + [notarepo], expecterror=1)\\n assert ERR_NOT_A_REPO in output\\n del notarepo, output\\n # this should have resulted in nothing being added to homely\\n assert not len(_repolist())\\n\\n # Target dir doesn't have any commits\\n nocommits = HOME + '/nocommits'\\n os.mkdir(nocommits)\\n contents(nocommits + '/HOMELY.py', \\\"print('YES')\\\\n\\\")\\n system(['git', 'init'], cwd=nocommits)\\n assert os.path.exists(nocommits + '/.git')\\n output = system(HOMELY('add') + [nocommits], expecterror=1)\\n assert ERR_NO_COMMITS in output\\n del nocommits, output\\n # this should have resulted in nothing being added to homely\\n assert not len(_repolist())\\n\\n # Target dir doesn't have a HOMELY.py script - when we add a repo that\\n # doesn't have a HOMELY.py script we should raise an error and provide\\n # instructions on how to write a HOMELY.py script (and not try to do the\\n # homely update).\\n noscript = HOME + '/noscript'\\n os.mkdir(noscript)\\n readme = noscript + '/README.md'\\n contents(readme, \\\"Hello world!\\\\n\\\")\\n system(['git', 'init'], cwd=noscript)\\n system(['git', 'config', 'user.name', \\\"fred\\\"], cwd=noscript)\\n system(['git', 'config', 'user.email', \\\"fred@example\\\"], cwd=noscript)\\n system(['git', 'add', 'README.md'], cwd=noscript)\\n system(['git', 'commit', '-m', \\\"Added readme\\\"], cwd=noscript)\\n output = system(HOMELY('add') + [noscript], expecterror=1)\\n assert ERR_NO_SCRIPT in output\\n # the repo should have added to homely\\n assert [noscript] == _repolist()\",\n \"def add_league_teams(league_diction, team_count, host, root, password):\\r\\n teams_diction = scrape_teams(league_diction, team_count)\\r\\n create_teams(host, root, password, dict_to_read=teams_diction)\\r\\n\\r\\n return teams_diction\",\n \"def add_prod_repo_as_origin_and_push(git_repo_name):\\n local(\\\"\\\"\\\"echo '[remote \\\"origin\\\"]' >> .git/config\\\"\\\"\\\")\\n local(r\\\"echo ' fetch = +refs/heads/*:refs/remotes/origin/*' >> .git/config\\\")\\n local(r\\\"echo ' url = %s:webapps/git/repos/%s.git' >> .git/config\\\" % (env.hosts[0], git_repo_name))\\n local(r\\\"git push origin master\\\")\",\n \"def addOrganisation(SID, name):\\n return call(\\\"addOrganisation\\\", SID, name)\",\n \"def add_team(display_name, indexed_name, game, division, fingerprint, now=None):\\n\\ttry:\\n\\t\\tteam = session.query(Team).filter(Team.fingerprint == fingerprint).one()\\n\\t\\tteam.display_name = display_name\\n\\t\\tteam.indexed_name = indexed_name\\n\\texcept sa_orm.exc.NoResultFound:\\n\\t\\tteam = Team(display_name=display_name, indexed_name=indexed_name,\\n\\t\\t\\t\\tgame=game, division=division, fingerprint=fingerprint)\\n\\t\\tsession.add(team)\\n\\n\\tsession.commit()\\n\\treturn team.id\",\n \"def update_teams(self, team_name, numero, pc):\\n\\n self.execute(TABELLE['teams']['insert'], (team_name, numero, pc))\",\n \"def process_events(gitlab_server, gitlab_token, debug=False):\\n global gitlab, hook_url\\n gitlab = GLSession(gitlab_server, gitlab_token)\\n if debug:\\n logging.basicConfig(stream=sys.stderr, level=logging.DEBUG)\\n\\n group = gitlab.createGroup(\\\"forestscribetest\\\")['id']\\n gitlab.createRepo(group, \\\"test_repo1\\\")\\n gitlab.createRepo(group, \\\"test_repo2\\\")\\n gitlab.createRepo(group, \\\"test_repo3\\\")\",\n \"def pushrepo(projectjson, repourl):\\n try:\\n components = projectjson['components']\\n name = projectjson['name']\\n reponame = name + '_sc'\\n logger.debug(f\\\"repourl is : {repourl}\\\")\\n bb_split = repourl.split(\\\"//\\\")\\n bb_split[1] = f\\\"{username}:{escape_password}@\\\"+bb_split[1]\\n newrepourl = \\\"//\\\".join(bb_split)\\n local_code_setup(reponame, newrepourl)\\n dst_makefile_path = f\\\"/tmp/{reponame}/Makefile\\\"\\n if not os.path.exists(dst_makefile_path):\\n src_makefile_path = f\\\"/tmp/skeleton-build/Makefile\\\"\\n copy2(src_makefile_path, dst_makefile_path)\\n print(\\\"Makefile added\\\")\\n createcomponents(components, reponame, newrepourl, name)\\n bitbucket.push_repo_to_bitbucket(f\\\"/tmp/{reponame}\\\")\\n rmtree('/tmp/skeleton-build')\\n rmtree(f'/tmp/{reponame}')\\n return True\\n except Exception as e:\\n print(\\\"caught exception.: \\\", e)\\n return False\",\n \"def register_manager(self, update, context):\\r\\n new_manager_chat_id = update['message']['chat']['id']\\r\\n new_manager_name = update['message']['chat']['first_name']\\r\\n\\r\\n with open('managers.json') as obj:\\r\\n managers = json.load(obj)\\r\\n\\r\\n managers[new_manager_name] = new_manager_chat_id\\r\\n\\r\\n with open('managers.json', 'w') as obj:\\r\\n json.dump(managers, obj)\\r\\n\\r\\n context.bot.send_message(chat_id=update.message.chat_id, text=f'{new_manager_name} - {new_manager_chat_id}')\",\n \"def test_add_repo_to_empty(tmpdir):\\n # Arange\\n cfg = tmpdir.mkdir(\\\"sub\\\").join(\\\"empty.json\\\")\\n REPO = \\\"foo.bar/foobar\\\"\\n NAME = \\\"foorepo\\\"\\n # Act\\n rm = gcbo.RepoManager(repo=REPO, cfg=cfg)\\n rm.save(NAME)\\n\\n # Assert\\n with open(cfg) as fp:\\n data = json.load(cfg)\\n assert data[NAME][\\\"url\\\"] == REPO\",\n \"def test_handle_add_not_admin(self):\\n test_user = User(\\\"userid\\\")\\n test_user.github_username = \\\"githubuser\\\"\\n team = Team(\\\"BRS\\\", \\\"brs\\\", \\\"web\\\")\\n team.github_team_id = \\\"githubid\\\"\\n self.db.retrieve.return_value = test_user\\n self.db.query.return_value = [team]\\n self.assertTupleEqual(self.testcommand.handle(\\\"team add brs ID\\\", user),\\n (self.testcommand.permission_error, 200))\\n self.db.store.assert_not_called()\\n self.gh.add_team_member.assert_not_called()\",\n \"def add_to_repository(user):\\n try:\\n repository.add(user)\\n except (KeyError, DuplicateIndexError):\\n raise\",\n \"def add(self, add_all=False, filepattern='', loop=None):\\n assert add_all or filepattern\\n\\n yield from _run_command(\\n 'git add {} {}'.format('--all' if add_all else '', filepattern),\\n self._path, loop=loop)\",\n \"async def channel_add(\\n self, ctx: commands.Context, channel: Union[discord.TextChannel, discord.VoiceChannel], *team_ids: int):\\n if set(team_ids) - set(self.teams):\\n await ctx.send('Missing data for the following team IDs: %s' % (\\n ', '.join(map(str, set(team_ids) - set(self.teams))),))\\n return\\n\\n await asyncio.gather(*[\\n self._permit_team_in_channel(self.teams[team_id], channel)\\n for team_id in team_ids],\\n return_exceptions=True)\\n await ctx.send('Added team%s `%s` to channel %s' % (\\n nl.s(len(team_ids)),\\n '`, `'.join(self.teams[team_id].username for team_id in team_ids),\\n channel.mention))\",\n \"def addDevs(repo,name,permissions):\\n #print(\\\"before clientSocket\\\") \\n clientSocket = connectToServer()\\n #print(\\\"after connectToServer\\\")\\n\\n PACKET = {} \\n\\n if repo == \\\".\\\":\\n #print(\\\"inside repo .\\\")\\n repo = getCurrentRepoName()\\n #print(\\\"after repo .\\\") \\n\\n PACKET[\\\"repo\\\"] = repo\\n PACKET[\\\"userData\\\"] = authenticate()\\n \\n #print(f\\\" name : {name} and permissions : {permissions}\\\") \\n\\n if name and permissions: \\n #print(\\\"in side add devs name and permissions\\\") \\n addDevOne(clientSocket,PACKET,name,permissions)\\n \\n elif not name and not permissions:\\n #print(\\\"in side add devs not name and not permissions\\\")\\n addDevMul(clientSocket,PACKET)\\n\\n else:\\n click.secho(\\\"Invalid operation\\\",fg=\\\"red\\\")\",\n \"def test_add_invalid_svn_repo(self):\\n pass\",\n \"def add(ref):\\n cmd = 'qri add %s' % ref\\n print('Fetching from registry...')\\n result, err = shell_exec(cmd)\\n return 'Added %s: %s' % (ref, result)\",\n \"def addRepository(self, addType, repoPath=\\\"\\\", repoUser=\\\"\\\", repoPassword=\\\"\\\", defaultRepository=True,\\n onlyTestConnection=False):\\n try:\\n utility.execLog(\\\"Navigating to Firmware Tab\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('FW_tab'))), action=\\\"CLICK\\\")\\n utility.execLog(\\\"Clicking on 'Add Repository'\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('Add_FW'))), action=\\\"CLICK\\\")\\n utility.execLog(\\\"Verifying 'Add Firmware Repository' Page\\\")\\n pageTitle = self.handleEvent(\\n EC.element_to_be_clickable((By.CLASS_NAME, self.RepositoriesObjects('modal_title'))), action=\\\"GET_TEXT\\\")\\n if \\\"Add Firmware / Software Repository\\\" not in pageTitle:\\n return self.browserObject, False, \\\"Failed to verify 'Add Firmware Repository' Page Actual:'%s' Expected:'%s'\\\" % (\\n pageTitle, \\\"Add Firmware / Software Repository\\\")\\n utility.execLog(\\\"Verified 'Add Firmware Repository' Page Actual:'%s' Expected:'%s'\\\" % (\\n pageTitle, \\\"Add Firmware / Software Repository\\\"))\\n if addType == \\\"Network Path\\\":\\n utility.execLog(\\\"Selecting Network Path Option\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('catalog_local'))),\\n action=\\\"CLICK\\\")\\n utility.execLog(\\\"Setting Network Path '%s'\\\" % repoPath)\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('local_file_path'))),\\n action=\\\"SET_TEXT\\\", setValue=repoPath)\\n if repoUser:\\n utility.execLog(\\\"Setting Network Username '%s'\\\" % repoUser)\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('local_UN'))),\\n action=\\\"SET_TEXT\\\", setValue=repoUser)\\n if repoPassword:\\n utility.execLog(\\\"Setting Network Password '%s'\\\" % repoPassword)\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('password'))),\\n action=\\\"SET_TEXT\\\", setValue=repoPassword)\\n elif addType == \\\"Local Drive\\\":\\n utility.execLog(\\\"Selecting Local Drive Option\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('catalog_file'))),\\n action=\\\"CLICK\\\")\\n utility.execLog(\\\"Setting Local Drive Path '%s'\\\" % repoPath)\\n self.handleEvent(EC.presence_of_element_located((By.ID, self.RepositoriesObjects('file_browse_path'))),\\n action=\\\"SET_TEXT\\\", setValue=repoPath)\\n else:\\n utility.execLog(\\\"Selecting 'Import From Dell FTP' Option\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('catalog_FTP'))),\\n action=\\\"CLICK\\\")\\n if defaultRepository:\\n utility.execLog(\\\"Selecting 'Make Default Repository' Option\\\")\\n if not self.handleEvent(\\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\\n action=\\\"IS_SELECTED\\\"):\\n self.handleEvent(\\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\\n action=\\\"CLICK\\\")\\n else:\\n utility.execLog(\\\"Unselect 'Make Default Repository' Option\\\")\\n if self.handleEvent(\\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\\n action=\\\"IS_SELECTED\\\"):\\n self.handleEvent(\\n EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('set_catalog_default'))),\\n action=\\\"CLICK\\\")\\n if onlyTestConnection and addType != \\\"Local Drive\\\":\\n utility.execLog(\\\"Selecting 'Test Connection' Option\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('FW_TC'))), action=\\\"CLICK\\\")\\n time.sleep(1)\\n try:\\n utility.execLog(\\\"Checking for presence of error message\\\")\\n eleError = self.handleEvent(\\n EC.presence_of_element_located((By.CLASS_NAME, self.RepositoriesObjects('alert_danger'))), wait_time=5,\\n retry=False)\\n errorMessage = eleError.find_element_by_tag_name(\\\"ul\\\").text\\n utility.execLog(errorMessage)\\n return self.browserObject, False, \\\"Failed to Initiate Test Connection for Repository :: Error -> '%s'\\\" % (\\n str(errorMessage))\\n except:\\n utility.execLog(\\\"No error message found\\\")\\n utility.execLog(\\\"Identifying Confirm Dialog box\\\")\\n self.handleEvent(EC.text_to_be_present_in_element((By.XPATH, self.RepositoriesObjects('dialog_box')), \\\"Success\\\"))\\n utility.execLog(\\\"Confirming Test Connection\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.XPATH, self.RepositoriesObjects('btn_close'))),\\n action=\\\"CLICK\\\")\\n utility.execLog(\\\"Test of connection was successful\\\")\\n return self.browserObject, True, \\\"Successfully Initiated Test Connection for Repository\\\"\\n else:\\n utility.execLog(\\\"Clicking on 'Save' to Add Repository\\\")\\n self.handleEvent(EC.element_to_be_clickable((By.ID, self.RepositoriesObjects('FW_save'))),\\n action=\\\"CLICK\\\")\\n time.sleep(1)\\n self.handleEvent(EC.invisibility_of_element_located((By.XPATH, self.RepositoriesObjects('loading_in'))))\\n utility.execLog(\\\"Clicked on 'Save' to Add Repository\\\")\\n try:\\n utility.execLog(\\\"Checking for presence of error message\\\")\\n eleError = self.handleEvent(\\n EC.presence_of_element_located((By.CLASS_NAME, self.RepositoriesObjects('alert_danger'))), wait_time=5,\\n retry=False)\\n errorMessage = eleError.find_element_by_tag_name(\\\"ul\\\").text\\n return self.browserObject, False, \\\"Failed to Initiate Add Repository :: '%s' :: Error -> '%s'\\\" % (\\n repoPath, str(errorMessage))\\n except:\\n utility.execLog(\\\"No error message found\\\")\\n return self.browserObject, True, \\\"Successfully Initiated Add Repository '%s'\\\" % repoPath\\n except Exception as e:\\n utility.execLog(\\\"Failed to Initiate Add Repository :: '%s' :: Error -> %s\\\" % (repoPath, str(e)))\\n return self.browserObject, False, \\\"Failed to Initiate Add Repository :: '%s' :: Error -> %s\\\" % (\\n repoPath, str(e))\",\n \"def event_register_collaborator(request, event_id, employee_id):\\n if request.method == 'PUT':\\n event = get_object_or_404(Event, pk=event_id, is_registration_open=True)\\n collaborator = get_object_or_404(Employee, pk=employee_id)\\n event.collaborators.add(collaborator)\\n event.save()\\n serializer = EventSimpleRegistrationSerializer(event)\\n return Response(serializer.data, status=status.HTTP_202_ACCEPTED)\",\n \"def register_team_members(self, body):\\n httpretty.register_uri(\\n httpretty.GET,\\n re.compile(\\n r'^{url}teams/\\\\d+/members$'.format(\\n url=re.escape(self.URL)\\n )\\n ),\\n body=body\\n )\",\n \"def update_from_repo():\\n\\treturn\",\n \"def add_distdirs ( self, distdirs ):\\n def gen_repos():\\n for d in distdirs:\\n repo = BasicRepo (\\n name=os.path.basename ( d ),\\n directory=d,\\n distroot=self.distroot\\n )\\n self.logger.debug ( 'New entry, ' + str ( repo ) )\\n yield repo\\n # --- end of gen_repos() ---\\n self.repos.extend ( gen_repos() )\",\n \"def install(self: \\\"Repo\\\", use_pre_commit_tool: bool = False) -> None:\\n from dvc.scm import Git\\n\\n scm = self.scm\\n if not isinstance(scm, Git):\\n return\\n\\n driver = \\\"dvc git-hook merge-driver --ancestor %O --our %A --their %B \\\"\\n scm.install_merge_driver(\\\"dvc\\\", \\\"DVC merge driver\\\", driver)\\n\\n if use_pre_commit_tool:\\n return pre_commit_install(scm)\\n\\n return install_hooks(scm)\",\n \"def commitRepository(self, repository):\\n runCommand(\\n [\\\"git\\\", \\\"-C\\\", repository.path, \\\"add\\\"] + glob.glob(repository.path + \\\"/*\\\")\\n )\\n runCommand([\\\"git\\\", \\\"-C\\\", repository.path, \\\"commit\\\", \\\"-m\\\", \\\"hop\\\"])\",\n \"def run(self):\\n self.update_repos()\",\n \"def test_assign_managing_team(self):\\n pass\",\n \"def add_org(cmd, *args):\\n\\n cfg = get_config()\\n nick, org = None, None\\n if len(args) == 0:\\n print(add_org.__doc__)\\n if len(args) >= 1:\\n nick = args[0]\\n if len(args) >= 2:\\n org = args[1]\\n if len(args) >= 3:\\n print(\\\"only <nick> <org_addr> understood :(\\\")\\n # other param breakdown here\\n vcard_fn = nick + '.vcf'\\n vcard_fn = os.path.join(cfg['vcard_dir'], vcard_fn)\\n vCard = getvcard(vcard_fn)\\n infoDict = dict_from_vcard(vCard)\\n infoDict['org'] = [org, ] # list-ize. Dunnow why yet\\n\\n ## make changes to infodict here\\n vcard_merge_in_dict(infoDict, vCard)\\n rawdata = vCard.serialize()\\n with open(vcard_fn, 'w+') as fh:\\n fh.write(rawdata)\\n return True\",\n \"def repo(self, user, repo):\\r\\n return repos.Repo(self, user, repo)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6898738","0.6489705","0.64307415","0.6304983","0.6265113","0.6264515","0.6212561","0.61818516","0.6177951","0.61501896","0.60574985","0.5968487","0.58513224","0.57982254","0.57399786","0.5735879","0.5716812","0.5707634","0.5682229","0.5664063","0.56495","0.5591028","0.5558522","0.5552845","0.5550953","0.5547198","0.5539031","0.5496612","0.54952914","0.5492456","0.5475293","0.5463511","0.5463013","0.542662","0.54198766","0.54134023","0.53858286","0.5382139","0.5381021","0.5376001","0.5372192","0.536643","0.5358183","0.53469324","0.53422683","0.5333249","0.533217","0.5318082","0.5297465","0.5286093","0.5282084","0.52802","0.5266422","0.5243954","0.5233498","0.5211865","0.5180555","0.51798123","0.51740557","0.51392484","0.5134595","0.51211816","0.5107597","0.50632834","0.50500095","0.5042208","0.503729","0.50288606","0.50278866","0.49968773","0.49944767","0.4993421","0.49867612","0.49809533","0.49732164","0.49715143","0.49685973","0.4965436","0.49623948","0.49611634","0.49588633","0.4954433","0.4952513","0.49520025","0.4948761","0.49466386","0.49463174","0.49414116","0.49394274","0.49378568","0.49357578","0.49320808","0.49317518","0.4927403","0.49220216","0.49193016","0.49152696","0.49120298","0.4907048","0.49065444"],"string":"[\n \"0.6898738\",\n \"0.6489705\",\n \"0.64307415\",\n \"0.6304983\",\n \"0.6265113\",\n \"0.6264515\",\n \"0.6212561\",\n \"0.61818516\",\n \"0.6177951\",\n \"0.61501896\",\n \"0.60574985\",\n \"0.5968487\",\n \"0.58513224\",\n \"0.57982254\",\n \"0.57399786\",\n \"0.5735879\",\n \"0.5716812\",\n \"0.5707634\",\n \"0.5682229\",\n \"0.5664063\",\n \"0.56495\",\n \"0.5591028\",\n \"0.5558522\",\n \"0.5552845\",\n \"0.5550953\",\n \"0.5547198\",\n \"0.5539031\",\n \"0.5496612\",\n \"0.54952914\",\n \"0.5492456\",\n \"0.5475293\",\n \"0.5463511\",\n \"0.5463013\",\n \"0.542662\",\n \"0.54198766\",\n \"0.54134023\",\n \"0.53858286\",\n \"0.5382139\",\n \"0.5381021\",\n \"0.5376001\",\n \"0.5372192\",\n \"0.536643\",\n \"0.5358183\",\n \"0.53469324\",\n \"0.53422683\",\n \"0.5333249\",\n \"0.533217\",\n \"0.5318082\",\n \"0.5297465\",\n \"0.5286093\",\n \"0.5282084\",\n \"0.52802\",\n \"0.5266422\",\n \"0.5243954\",\n \"0.5233498\",\n \"0.5211865\",\n \"0.5180555\",\n \"0.51798123\",\n \"0.51740557\",\n \"0.51392484\",\n \"0.5134595\",\n \"0.51211816\",\n \"0.5107597\",\n \"0.50632834\",\n \"0.50500095\",\n \"0.5042208\",\n \"0.503729\",\n \"0.50288606\",\n \"0.50278866\",\n \"0.49968773\",\n \"0.49944767\",\n \"0.4993421\",\n \"0.49867612\",\n \"0.49809533\",\n \"0.49732164\",\n \"0.49715143\",\n \"0.49685973\",\n \"0.4965436\",\n \"0.49623948\",\n \"0.49611634\",\n \"0.49588633\",\n \"0.4954433\",\n \"0.4952513\",\n \"0.49520025\",\n \"0.4948761\",\n \"0.49466386\",\n \"0.49463174\",\n \"0.49414116\",\n \"0.49394274\",\n \"0.49378568\",\n \"0.49357578\",\n \"0.49320808\",\n \"0.49317518\",\n \"0.4927403\",\n \"0.49220216\",\n \"0.49193016\",\n \"0.49152696\",\n \"0.49120298\",\n \"0.4907048\",\n \"0.49065444\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75826085"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20399,"cells":{"query":{"kind":"string","value":"Return tables of cells in neuronPop population name connected to mitrals specified in args, via neuronProj projection name if args is not specified get all."},"document":{"kind":"string","value":"def exportTable(network, neuronProj, neuronPop, colours, \\\n args={}, spikes=True, allcells=True):\n exportDict = {'spikes':spikes,'data_tables':[]}\n if array(colours).shape == (3,): coloursList = False\n else: coloursList = True\n ## get cells connected to mitrals specified in args. if not specified get arbitrary. \n celllist = getCellsByMitralConnection(args, network, neuronProj, neuronPop, allcells)\n for i,cell in enumerate(celllist):\n cellname = cell.path.split('/')[-1]\n ## assumes at least one soma and takes the first!\n cell.soma = moose.Compartment(get_matching_children(cell,['Soma','soma'])[0])\n cellTablePath = cell.soma.path+\"/data/vmTableSoma\"\n if moose.context.exists(cellTablePath):\n cell._vmTableSoma = moose.Table(cellTablePath)\n else:\n print \"SimError: Did not find \"+cellTablePath\n sys.exit(1)\n if coloursList: colour=colours[i]\n else: colour=colours\n exportDict['data_tables'].append((cellname,colour,array(cell._vmTableSoma)))\n return exportDict"},"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 getCellsByMitralConnection(args, network, projection, population, allcells=False):\n cellList = []\n cellUniques = []\n if args.has_key('mitrals'):\n for mitid in args['mitrals']:\n mitpath = 'mitrals_'+str(mitid)\n cellnum = 0\n if projection in network.projectionDict:\n for conn in network.projectionDict[projection][2]:\n if mitpath in conn[2]: # if mitrals_<mitid> is substring of post_seg_path of this connection\n cellpath = string.split(conn[1],'/')[1] # take out cellname from '/cellname/segmentname\n ## Take only those cells that have not been taken before.\n if cellpath not in cellUniques:\n cell = moose.Cell(cellpath)\n cellList.append(cell)\n cellUniques.append(cellpath)\n cellnum += 1\n if not allcells and cellnum == 30: break\n else:\n if allcells: cellList = network.populationDict[population][1].values()\n else: cellList = network.populationDict[population][1].values()[0:60]\n return cellList","def run_simulation(env, pop, nr):\n pop_f = []\n pop_pl = []\n pop_el = []\n\n\n for individual in pop:\n fitness, player_life, enemy_life, time = env.play(pcont=individual)\n pop_f.append(fitness)\n pop_pl.append(player_life)\n pop_el.append(enemy_life)\n\n return pop_f, pop_pl, pop_el","def personnel_projects_table(personnel_search_table_selected_indices, selected_funding, selected_year, rows):\n personnel_outcome_data, personnel_name = personnel_outcomes_helper(personnel_search_table_selected_indices, selected_funding, selected_year, rows)\n if personnel_outcome_data is not None:\n personnel_outcome_data = personnel_outcome_data[[\"type\", \"pub_title\"]]\n return personnel_outcome_data.to_dict('records')\n\n return pd.DataFrame(data=None, columns=[\"type\", \"pub_title\"]).to_dict('records') # None cannot be passed back as it will cause an error.","def tsne_projection(train_file, gen_file, i):\n train_data = pd.read_csv(train_file)\n def get_ori_prom(row):\n if row['gaps'] <= 2 and row['dips'] <=2:\n return 'Model'+str(i)+'_train_promising'\n else:\n return 'Model'+str(i)+'_train'\n train_data['label'] = train_data.apply(get_ori_prom, axis=1)\n train_data = train_data.drop(['id', 'gaps', 'dips'], axis=1)\n gen_prom_smiles = pd.read_csv(gen_file)\n gen_prom_smiles = gen_prom_smiles.drop(['Group', 'Gaps', 'Dips'], axis=1)\n gen_prom_smiles['label'] = 'Generated_promising'\n all_smi = pd.concat([train_data, gen_prom_smiles])\n mols = get_mols(all_smi.SMILES)\n fps, _ = get_fingerprints(mols)\n fp_embeded = TSNE(n_components=2, perplexity=100).fit_transform(fps)\n all_smi['tsne1'] = fp_embeded[:, 0]\n all_smi['tsne2'] = fp_embeded[:, 1]\n return all_smi, len(train_data)","def population(params, n=100):\r\n pops = []\r\n for i in range(n):\r\n pop = []\r\n for param in params:\r\n pop.append(np.random.choice(param))\r\n\r\n individuale = Individuale(pop)\r\n pops.append(individuale)\r\n # print(\"No.{} : {} : {}\".format(i, individuale, individuale.x))\r\n return pops","def population_projection(self):\n population_projection = Worldometers.soup.find_all(class_='years')[1]\n year_rows = population_projection.find_all('tr')\n\n population_projection_dict = {}\n for x in range(1, len(year_rows)):\n columns = year_rows[x].find_all('td')\n population_projection_dict[x-1] = {\n 'year': columns[0].getText().replace(',', ''),\n 'population': columns[1].getText().replace(',', ''),\n 'growth': columns[2].getText().replace(' %', '')\n }\n\n return population_projection_dict","def get_chained_proj(self):\n #non recursive call\n N = self.N_in\n projs = []\n for layer in self.layers:\n proj,N_out = self.get_deprojecter(layer,N)\n projs.append(proj)\n N = N_out\n return projs","def printPop(population: list):\n for p in population:\n print(p)","def run_projections(self):\n self.projection_collection100 = DonorCollection()\n self.projection_collection50 = DonorCollection()\n double_over_100 = dict(list(\n (name, list(map(lambda x: x * 2, donations.donations))) for name, donations in self.donors.items()))\n triple_under_50 = dict(list(\n (name, list(map(lambda x: x * 3, donations.donations))) for name, donations in self.donors.items()))\n for donor, donations in double_over_100.items():\n self.projection_collection100.add(donor, donations)\n for donor, donations in triple_under_50.items():\n self.projection_collection50.add(donor, donations)\n return self.projection_collection50, self.projection_collection100","def get_grid_data_popdiag(grid):\n# indir = '/CESM/bgcwg/obgc_diag/mapping/grids'\n indir = '/glade/p/cesm/bgcwg/obgc_diag/mapping/grids'\n infile = os.path.join(indir, grid + '.nc')\n fp = Nio.open_file(infile,'r')\n nlon, nlat = fp.variables['grid_dims'][:]\n tlat = fp.variables['grid_center_lat'][:]\n tlon = fp.variables['grid_center_lon'][:]\n fp.close()\n tlat = N.reshape(tlat,(nlat,nlon))[:,0]\n tlon = N.reshape(tlon,(nlat,nlon))[0,:]\n return nlon, nlat, tlon, tlat","def star_topology(random, population, args):\r\n for _ in range(len(population)):\r\n yield population[:]","def _projections(self, nvar):\n min_var = self.proje_var.argsort()[:nvar]\n add_coeffs = 1 / self.proje_var[min_var]\n indp_est_proje = np.dot(add_coeffs, self.sep_proje_eval[min_var]) /\\\n np.sum(add_coeffs)\n\n # consider covariance\n coverr = []\n try:\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\n cov_weight = np.sum(proje_cov_inv, axis=0) / np.sum(proje_cov_inv)\n cov_est_proje = np.dot(cov_weight, self.sep_proje_eval[min_var])\n coverr.append(1/np.sum(proje_cov_inv))\n except:\n cov_est_proje = np.ones(self.sep_proje_eval.shape[1])\n cov_est_proje[:] = np.nan\n coverr.append(np.nan)\n return np.array([indp_est_proje, cov_est_proje])","def project_pop(self):\n M = self.N[0:2]\n for x in range(10):\n M.append(self.run_step(M))\n split_N = split_list(M)\n \n fig = self.make_figure(split_N)\n fig.update_layout(title='Projected Fish Population')\n\n return fig","def select(self, m, population):\n pass","def intrapop_connections(n_mitral, n_granule, n_subpop, n_mitral_per_subpop):\n resmat = np.zeros((n_mitral, n_granule))\n for i_subpop in xrange(n_subpop):\n start = i_subpop*n_mitral_per_subpop\n stop = start + n_mitral_per_subpop\n resmat[start:stop, i_subpop] = 1.\n return resmat","def initPopulation(self, task):\n\t\tSol, Fitness, d = Algorithm.initPopulation(self, task)\n\t\tA, S, Q, v = np.full(self.NP, self.A), np.full([self.NP, task.D], 0.0), np.full(self.NP, 0.0), np.full([self.NP, task.D], 0.0)\n\t\td.update({'A': A, 'S': S, 'Q': Q, 'v': v})\n\t\treturn Sol, Fitness, d","def project(data=None, x=None, y=None, z=None, outfile=None, **kwargs):\n\n if kwargs.get(\"C\") is None:\n raise GMTInvalidInput(\"The `center` parameter must be specified.\")\n if kwargs.get(\"G\") is None and data is None:\n raise GMTInvalidInput(\n \"The `data` parameter must be specified unless `generate` is used.\"\n )\n if kwargs.get(\"G\") is not None and kwargs.get(\"F\") is not None:\n raise GMTInvalidInput(\n \"The `convention` parameter is not allowed with `generate`.\"\n )\n\n with GMTTempFile(suffix=\".csv\") as tmpfile:\n if outfile is None: # Output to tmpfile if outfile is not set\n outfile = tmpfile.name\n with Session() as lib:\n if kwargs.get(\"G\") is None:\n # Choose how data will be passed into the module\n table_context = lib.virtualfile_from_data(\n check_kind=\"vector\", data=data, x=x, y=y, z=z, required_z=False\n )\n\n # Run project on the temporary (csv) data table\n with table_context as infile:\n arg_str = build_arg_string(kwargs, infile=infile, outfile=outfile)\n else:\n arg_str = build_arg_string(kwargs, outfile=outfile)\n lib.call_module(module=\"project\", args=arg_str)\n\n # if user did not set outfile, return pd.DataFrame\n if outfile == tmpfile.name:\n if kwargs.get(\"G\") is not None:\n column_names = list(\"rsp\")\n result = pd.read_csv(tmpfile.name, sep=\"\\t\", names=column_names)\n else:\n result = pd.read_csv(tmpfile.name, sep=\"\\t\", header=None, comment=\">\")\n # return None if outfile set, output in outfile\n elif outfile != tmpfile.name:\n result = None\n\n return result","def atlas_projects():\n pass","def FindGrid(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\n ...","def allJPDs(net):\r\n \r\n onodes = net.Outputnodes()\r\n combinations = [i for i in itertools.combinations(onodes,2)]\r\n JPDdata = [] \r\n for c in combinations:\r\n priorA = getPrior(net,c[0])\r\n priorB = getPrior(net,c[1]) \r\n jpd = JPD(net,c)\r\n cov = Covariance (priorA,priorB,jpd)\r\n cor = Correlation (priorA,priorB,cov) \r\n JPDdata.append([c[0],c[1],jpd,cov,cor])\r\n return JPDdata","def get_population_names (f,a,s):\r\n ## a, s not used but needed for function to match general function format\r\n global gv\r\n aa = f.readline().strip()\r\n popnamelist = []\r\n i = 0\r\n foundghost = False\r\n while aa.find(\"Population\") >= 0:\r\n popname = aa.split()[3]\r\n if popname.upper() == \"GHOST\":\r\n foundghost = True\r\n popnamelist.append(popname)\r\n i += 1\r\n aa = f.readline().strip()\r\n if gv[\"useghost\"] == True and foundghost == False: # for compatibility with older output files\r\n popnamelist.append('ghost')\r\n anames = []\r\n if gv[\"usealtnames\"]:\r\n for line in open(gv[\"altnamefilename\"],\"r\"):\r\n temp = line.strip()\r\n if len(temp) > 0:\r\n anames.append(temp)\r\n anames = anames[0:len(popnamelist)]\r\n gv[\"altpopnames\"] = list(anames)\r\n return popnamelist","def population_observer(population, num_generations, num_evaluations, args):\r\n population.sort(reverse=True)\r\n print('----------------------------------------------------------------------------')\r\n print(' Current Population')\r\n print('----------------------------------------------------------------------------')\r\n for ind in population:\r\n print(str(ind))\r\n print('----------------------------------------------------------------------------')","def createGridcells(mapdata, listOfP):\n new_gridcells = GridCells()\n new_gridcells.header = mapdata.header\n new_gridcells.cell_width = mapdata.info.resolution\n new_gridcells.cell_height = mapdata.info.resolution\n new_gridcells.cells = []\n for p in listOfP:\n new_gridcells.cells.append(PathPlanner.grid_to_world(mapdata, p[0], p[1]))\n return new_gridcells","def JPD(net,nodeTuple): \r\n\r\n priorA = getPrior(net,nodeTuple[0]) \r\n statesA = net.NodeStates(nodeTuple[0],naming = 'titlename') \r\n statesB = net.NodeStates(nodeTuple[1],naming = 'titlename')\r\n numstatesA = [float(i) for i in statesA] \r\n numstatesB = [float(i) for i in statesB] \r\n output = np.zeros((len(statesA)+1,len(statesB)+1))\r\n output[0,1:] = numstatesB\r\n output[1:,0] = numstatesA\r\n for n,i in enumerate(statesA):\r\n net.RetractFinding() \r\n output[n+1][1:] = np.array(net.Finding(nodeTuple[0],i,nodeTuple[1],output = 'name'))*priorA[0][n]\r\n return output","def query_settlement_layer(grid):\n path = os.path.join(SHAPEFILE_DIR, f'{COUNTRY_ABBRV}.tif')\n\n grid['population'] = pd.DataFrame(\n zonal_stats(vectors=grid['geometry'], raster=path, stats='sum'))['sum']\n\n grid = grid.replace([np.inf, -np.inf], np.nan)\n\n return grid","def default_selection(random, population, args):\r\n return population","def proj(self, X, G):\n raise NotImplementedError","def init_pop(self):\n genes = np.random.randn( self.population_size * self.individual.gene_count )\n self.population = genes.reshape((self.population_size, -1))\n #print(self.population)","def get_null_proj(self,nsing=None):\n if nsing is None:\n nsing = self.get_nsing()\n if nsing is None:\n raise Exception(\"nsing is None\")\n print(\"using {0} singular components\".format(nsing))\n self.log(\"forming null space projection matrix with \" +\\\n \"{0} of {1} singular components\".format(nsing,self.jco.shape[1]))\n\n v2_proj = (self.xtqx.v[:,nsing:] * self.xtqx.v[:,nsing:].T)\n self.log(\"forming null space projection matrix with \" +\\\n \"{0} of {1} singular components\".format(nsing,self.jco.shape[1]))\n\n return v2_proj","def generate_population(population_size, nn_architecture):\n population = []\n for _ in range(population_size):\n population.append(nn.create_nn_from_arch(nn_architecture))\n\n return population","def projected():\n # pull updated list of donors(class)\n projected_list = create_donors_list()\n print('''Welcome to the Projection Option. Here you can run projections for contributions. \n Help Companies structure their matching donations based on past contribution amounts.\n Simply enter the minumum and maximum donation range that will be matched and see the total contribution:''')\n try:\n minimum_input = float(\n input('Enter a minimum donation amount (0 if none): '))\n maximum_input = float(\n input('Enter a maximum donation amount (0 if none): '))\n factor = float(\n input('Please enter the factor you wish to multiply these donations by >> '))\n except ValueError:\n print('Please follow instructions and enter a number only')\n\n projections = projection(projected_list, factor,\n minimum_input, maximum_input)\n print('\\nProjected contribution value: ${:,.2f}'.format(projections))","def process_pop(pop_path, pop_prefix, external_cols, truncate=False,\r\n index_cols = ['location_id', 'year_id','age_group_id','sex_id']):\r\n\r\n\r\n # Get the data\r\n pop = pandas_read_infer_filetype(pop_path)\r\n\r\n # Identify columns with pop data\r\n pop_cols = [col for col in pop.columns if pop_prefix in col]\r\n\r\n # We don't want to actually duplicate data we dont have\r\n unique_pop_names = pop_cols\r\n\r\n # A few situations:\r\n # 1. We have 1 pop column to match with N external columns,\r\n # so we return a list with the same column repeated N times (just the name, not the data)\r\n # 2. We have N pop columns to match with N external columns, we do nothing spexical\r\n # 3. We have P pop columns to match with N external columns:\r\n # a. If P > N\r\n # i. if truncate is true, return the first N pop columns\r\n # ii. if truncate is false, raise an error\r\n # b. If P < N, raise an error\r\n\r\n\r\n # Double check the pop common prefix\r\n pop_prefix = os.path.commonprefix(pop_cols)\r\n external_prefix = os.path.commonprefix(external_cols)\r\n\r\n if pop_prefix == external_prefix:\r\n\r\n # If they match, rename the pop columns\r\n rename_dict = {pop_col:'_'+pop_col for pop_col in pop_cols}\r\n pop = pop.rename(columns=rename_dict)\r\n pop_cols = ['_'+pop_col for pop_col in pop_cols]\r\n unique_pop_names = pop_cols\r\n\r\n\r\n pop = pop[index_cols+unique_pop_names]\r\n\r\n return pop, pop_cols","def setUp(self):\n N = 10\n pA = 0.5\n pB = 0.5\n qA = 1 - pA\n qB = 1 - pB\n locus_A = (['A'] * int(N * pA)) + (['a'] * int(round(N * qA)))\n locus_B = (['B'] * int(N * pB)) + (['b'] * int(round(N * qB)))\n self.pop = population.Population(N, locus_A, locus_B)","def get_multi(datasource='crubadan', option=\"raw\", collapse=False, verbose=True):\n return MultiDict(get_matrix(n=i,\n datasource=datasource, option=option, collapse=collapse, verbose=verbose)\n for i in range(6))","def get_testing_pop(agegroup_strata: List[str], country: Country, pop: Population):\n testing_region = \"Victoria\" if country.iso3 == \"AUS\" else pop.region\n testing_year = 2020 if country.iso3 == \"AUS\" else pop.year\n testing_pop = inputs.get_population_by_agegroup(\n agegroup_strata, country.iso3, testing_region, year=testing_year\n )\n return testing_pop, testing_region","def explore_db(self, db=None, table=None, col=None):\n\n try:\n self.db_dict\n except AttributeError:\n self._generate_schema()\n\n projects = np.sort(list(self.db_dict.keys()))\n largest = max([len(projects[i]) for i in range(len(projects))])\n t = Table()\n # db not specified\n if not db:\n warnings.warn(\"Must first specify a database.\")\n proj_list = []\n attr_list = []\n info_list = []\n tmp2_largest = 0\n for proj in projects:\n size = len((self.db_dict['{0}'.format(proj)].keys()))\n proj_list += (['@ {}'.format(proj)]\n + ['' for i in range(size - 1)]\n + ['-' * (largest + 2)])\n tmp_largest = max([len(str(key))\n for key in self.db_dict[proj].keys()])\n attr_list += (['@ {}'.format(key)\n if isinstance(self.db_dict[proj][key], dict)\n else '{}:'.format(key)\n for key in self.db_dict[proj].keys()]\n + ['-' * (tmp_largest + 2)])\n tmpinfosize = max([len(self.db_dict[proj][key])\n if isinstance(self.db_dict[proj][key], str)\n else 0\n for key in self.db_dict[proj].keys()])\n if tmpinfosize > tmp2_largest:\n tmp2_largest = tmpinfosize\n for proj in projects:\n info_list += ([self.db_dict[proj][key]\n if isinstance(self.db_dict[proj][key], str)\n else \"\"\n for key in self.db_dict[proj].keys()] + ['-' * tmp2_largest])\n t['Projects'] = proj_list\n t['Project Items'] = attr_list\n t['Information'] = info_list\n t.pprint()\n # db specified\n if db:\n try:\n size1 = len(list(self.db_dict[str(db)].keys()))\n slist = [list(self.db_dict[db][key].keys())\n if isinstance(self.db_dict[db][key], dict)\n else key\n for key in self.db_dict[db].keys()]\n size2 = len(max(slist, key=np.size))\n except (KeyError, NameError):\n log.error(\"Must first specify a valid database.\")\n return\n # if col is specified, table must be specified, and I need to\n # check the max size of any given column in the structure\n if table:\n try:\n size2 = max(size2, len(list(self.db_dict[db]['tables']\n [table]['columns'].keys())))\n if col:\n try:\n size2 = max(size2, len(list(self.db_dict[db]['tables']\n [table]['columns']\n [col].keys())))\n except (KeyError, NameError):\n log.error(\"Must first specify a valid column \"\n \"of the `{0}` table within the `{1}`\"\n \" db\".format(table, db))\n return\n except (KeyError, NameError):\n log.error(\"Must first specify a valid table within \"\n \"the `{0}` db.\".format(db))\n return\n\n t['Projects'] = (['--> @ {}:'.format(db)] + ['' for i in range(size2 - 1)])\n t['Project Items'] = (\n ['--> @ {}:'.format(key)\n if (isinstance(self.db_dict[db][key], dict)\n and (len(list(self.db_dict[db][key].keys()))\n == len(list(self.db_dict[db]['tables'].keys()))))\n else '@ {}'.format(key)\n if (isinstance(self.db_dict[db][key], dict)\n and (len(list(self.db_dict[db][key].keys()))\n != len(self.db_dict[db]['tables'].keys())))\n else str(key)\n for key in self.db_dict[db].keys()] + ['' for i in range(size2 - size1)])\n # if only db is specified\n if not table:\n if not col:\n reordered = sorted(max(slist, key=np.size), key=len)\n t['Tables'] = ['@ {}'.format(i)\n if isinstance(self.db_dict[db]['tables'][i],\n dict)\n else str(i)\n for i in reordered]\n # if table has been specified\n else:\n reordered = (\n [str(table)]\n + sorted([key for key in self.db_dict[db]['tables'].keys()\n if key != table], key=len))\n t['Tables'] = (\n ['--> @ {}:'.format(i)\n if (i == table and isinstance(self.db_dict[db]['tables'][i], dict))\n else '@ {}'.format(i)\n if (i != table and isinstance(self.db_dict[db]['tables'][i], dict))\n else str(i)\n for i in reordered] + ['' for j in range(size2 - len(reordered))])\n\n # if column has been specified\n if col:\n tblcols_dict = self.db_dict[db]['tables'][table].keys()\n t['Table Items'] = (\n ['--> @ columns:']\n + [i for i in tblcols_dict if i != 'columns']\n + ['' for j in range(size2 - len(tblcols_dict))])\n col_dict = (self.db_dict[db]['tables'][table]\n ['columns'].keys())\n reordered = ([str(col)] + [i for i in col_dict if i != col])\n\n temp_columns = []\n\n columns = self.db_dict[db]['tables'][table]['columns']\n for i in reordered:\n c = columns[i]\n if isinstance(c, dict) and i == col:\n temp_columns.append('--> @ {}:'.format(i))\n elif not isinstance(c, dict) and i == col:\n temp_columns.append('--> {}:'.format(i))\n elif isinstance(c, dict) and i != col:\n temp_columns.append('@ {}'.format(i))\n else:\n temp_columns.append(str(i))\n\n if len(col_dict) < size2:\n size_diff = size2 - len(col_dict)\n t['Columns'] = (temp_columns + ['' for j in range(size_diff)])\n\n colinfo_dict = col_dict = columns[col]\n t['Col. Info'] = (\n ['{} : {}'.format(i, colinfo_dict[i])\n for i in colinfo_dict.keys()] + ['' for j in range(size2 - len(colinfo_dict))])\n else:\n t['Columns'] = temp_columns\n\n # if column has not been specified\n else:\n tblcols_dict = self.db_dict[db]['tables'][table].keys()\n col_dict = (\n self.db_dict[db]['tables'][table]['columns'].keys())\n reordered = sorted(col_dict, key=len)\n if len(tblcols_dict) < size2:\n size_diff = size2 - len(tblcols_dict)\n tmp_table = self.db_dict[db]['tables'][table]\n t['Table Items'] = (\n ['@ {}'.format(i) if isinstance(tmp_table[i], dict)\n else '{}:'.format(i) for i in tblcols_dict] + ['' for i in range(size_diff)])\n t['Table Info'] = (\n [str(tmp_table[i])\n if not isinstance(tmp_table[i], dict)\n else '' for i in tblcols_dict] + ['' for i in range(size_diff)])\n if len(col_dict) < size2:\n t['Columns'] = (\n ['@ {}'.format(i)\n if isinstance(tmp_table['columns'][i], dict)\n else str(i)\n for i in reordered] + ['' for i in range(size2 - len(col_dict))])\n else:\n t['Columns'] = reordered\n else:\n t['Table Items'] = tblcols_dict\n t.pprint()","def copy_grid (grid):\r\n c=[]\r\n for i in range(len(grid)):\r\n c.append(grid[i])\r\n return eval(str(c))","def get_data(n):\n data = pd.read_csv('map_data/lior_results_2.csv')\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\n data = data[data.binomial != 'Sus bucculentus'] # EX\n data = data[data.binomial != 'Melomys rubicola'] # EX\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\n total_mass_density=data.AdultBodyMassG * data.pop_density)\n data = data.sort_values(by='total_mass_density', ascending=False)\n data = data.iloc[0:n - 1]\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\"EPSG:6933\")\n geo_data = geo_data[geo_data.category != 'EX']\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\n (geo_data['legend'] == 'Extant (non breeding)') |\n (geo_data['legend'] == 'Extant (resident)') |\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\n (geo_data['legend'] == 'Probably Extant (resident)') |\n (geo_data['legend'] == 'Reintroduced')]\n range_polygons = range_polygons.merge(data, on='binomial')\n range_polygons = range_polygons.to_crs(\"EPSG:6933\")\n return range_polygons","def build_tweaks(mitralsclub, nospineinh, nosingles,\n nojoints, nomultis, nopgs, onlytwomits, \n includeProjections=[], twomitrals=(0,2), nolateral=False):\n excludePopulations = []\n excludeProjections = ['SA']\n ## In odor_pulses, odor_morphs, scaled_pulses, I have not specified to include \n ## file-based inputs to 2nd order cells as below. If not specified, force include:\n if 'granule_baseline' not in includeProjections: includeProjections.append('granule_baseline')\n if 'ORN_PG' not in includeProjections: includeProjections.append('ORN_PG')\n if not mitralsclub:\n excludeProjections.append('mitral_granule_extra_exc')\n if nospineinh:\n excludeProjections.append('_spinesingles')\n excludeProjections.append('_spinejoints')\n excludeProjections.append('_spinemultis')\n if nosingles:\n excludePopulations.append('singles')\n excludeProjections.append('_singles') # _ to avoid deleting spinesingles\n if nojoints:\n excludePopulations.append('joints')\n excludeProjections.append('_joints') # _ to avoid deleting spinejoints\n if nomultis:\n excludePopulations.append('multis')\n excludeProjections.append('_multis') # _ to avoid deleting spinemultis\n if nopgs:\n excludePopulations.append('PGs')\n excludeProjections.append('PG')\n if onlytwomits:\n onlyInclude = {'includePopulation':('mitrals',[str(twomitrals[0]),str(twomitrals[1])]),\n 'includeProjections':includeProjections}\n return {'excludePopulations':excludePopulations,\n 'excludeProjections':excludeProjections,'onlyInclude':onlyInclude}\n else:\n if nolateral:\n ## remove other mitrals so that there is no lateral inhibition\n ## differs from nojoints, in keeping the joints self-inhibition\n print \"EXCLUDING OTHER MITS, KEEPING ONLY mits 0 and 1\"\n onlyInclude = {'includePopulation':('mitrals',['0','1']),\n 'includeProjections':includeProjections}\n return {'excludePopulations':excludePopulations,\n 'excludeProjections':excludeProjections,'onlyInclude':onlyInclude}\n else:\n return {'excludePopulations':excludePopulations,\\\n 'excludeProjections':excludeProjections}","def get_neighborhood_probabilities(labels, model_grid_path, model_names, proj_str, obj=False, json_path=None):\n ds_list = []\n storm_grid = xr.open_dataset(model_grid_path)\n for coord in ['lon', 'lat']:\n storm_grid[coord].values = storm_grid[coord].astype('float32')\n\n for run_date in sorted(labels['Run_Date'].unique()):\n print(run_date)\n run_labels = labels.loc[labels['Run_Date'] == run_date]\n if obj:\n start = pd.to_datetime(run_labels['Run_Date'].min()).strftime(\"%Y%m%d-%H%M\")\n end = pd.to_datetime(run_labels['Run_Date'].max()).strftime(\"%Y%m%d-%H%M\")\n gdf = load_geojson_objs(start, end, json_path, \"hourly\")\n\n for forecast_hour in run_labels['Forecast_Hour'].unique():\n\n fh_labels = run_labels[run_labels[\"Forecast_Hour\"] == forecast_hour]\n valid_time = pd.to_datetime(fh_labels['Valid_Date'].unique()[0])\n ds = storm_grid.expand_dims('time').assign_coords(init_time=('time', [pd.to_datetime(run_date)]),\n valid_time=('time', [valid_time]),\n forecast_hour=('time', [forecast_hour]))\n if obj:\n gdf_sub = gdf[gdf['valid_time'] == forecast_hour]\n for model in model_names:\n\n for storm_type in ['Supercell', 'QLCS', 'Disorganized']:\n\n model_mode = f'{model}_{storm_type}'\n mode_prob = f'{model}_{storm_type}_prob'\n df_storms = fh_labels[fh_labels[f'{model}_label'] == storm_type]\n counts = np.zeros(shape=(1, storm_grid.y.size, storm_grid.x.size)).astype('float32')\n raw_probs = counts.copy()\n label_indxs = find_coord_indices(ds['lon'].values,\n ds['lat'].values,\n df_storms['Centroid_Lon'],\n df_storms['Centroid_Lat'],\n proj_str)\n for c, i in zip(df_storms.index, label_indxs):\n p = df_storms.loc[c, mode_prob]\n counts[0, i[0], i[1]] = 1\n raw_probs[0, i[0], i[1]] = p\n if obj:\n mask_indices = retrieve_mask_indices(gdf_sub.loc[df_storms.index], storm_grid)\n for index in mask_indices:\n for j in index:\n counts[0, j[0], j[1]] = 1\n raw_probs[0, j[0], j[1]] = p\n\n probabilities = compute_neighborhood_prob(counts, sigma=1)\n\n ds[mode_prob] = (['time', 'y', 'x'], raw_probs)\n ds[model_mode] = (['time', 'y', 'x'], counts)\n ds[f'{model_mode}_nprob'] = (['time', 'y', 'x'], probabilities)\n\n ds[mode_prob].attrs['Description'] = f'ML Probability of {storm_type}'\n ds[model_mode].attrs['Description'] = f'Categorical Classification of {storm_type}'\n ds[model_mode + '_nprob'].attrs['Description'] = f'Neighborhood Probabilities for {storm_type}'\n\n ds_list.append(ds)\n\n merged_ds = xr.concat(ds_list, dim='time')\n\n # if run_labels['Forecast_Hour'].nunique() < 17:\n # merged_ds = add_missing_forecast_hours(merged_ds, 17)\n # elif (run_labels['Forecast_Hour'].nunique() > 17) & (run_labels['Forecast_Hour'].nunique() < 47):\n # merged_ds = add_missing_forecast_hours(merged_ds, 47)\n\n return merged_ds","def pospdf(self, neurons='all', dim='y', edges=None, nbins=10, stats=False, labels=True,\n a=None, figsize=(7.5, 6.5)):\n if neurons == 'all':\n neurons = list(self.alln.values())\n elif neurons == 'quiet':\n neurons = list(self.qn.values())\n elif neurons == 'active':\n neurons = list(self.n.values())\n dimi = {'x':0, 'y':1}[dim]\n p = [ n.pos[dimi] for n in neurons ] # all position values\n if edges != None:\n nbins = len(edges) - 1\n bins = edges # assume it includes rightmost bin edge\n else:\n nbins = max(nbins, 2*intround(np.sqrt(self.nneurons)))\n bins = nbins\n n, p = np.histogram(p, bins=bins) # p includes rightmost bin edge\n binwidth = p[1] - p[0] # take width of first bin in p\n\n if stats:\n mean = np.mean(p)\n median = np.median(p)\n argmode = n.argmax()\n mode = p[argmode] + binwidth / 2 # middle of tallest bin\n stdev = np.std(p)\n\n if a == None:\n f = pl.figure(figsize=figsize)\n a = f.add_subplot(111)\n else: # add to existing axes\n a.hold(True)\n f = pl.gcf()\n\n # use CCWHITEDICT1 for familiarity with len 10 1-based id to colour mapping\n #color = CCWHITEDICT1[int(self.id)]\n color = 'k'\n\n # exclude rightmost bin edge in p\n a.bar(left=p[:-1], height=n, width=binwidth, bottom=0, color=color, ec=color)\n titlestr = lastcmd()\n gcfm().window.setWindowTitle(titlestr)\n if labels:\n a.set_title(titlestr)\n a.set_xlabel('neuron %s position (um)' % dim)\n a.set_ylabel('neuron count')\n\n if stats:\n # add stuff to top right of plot:\n uns = get_ipython().user_ns\n a.text(0.99, 0.99, 'mean = %.3f\\n'\n 'median = %.3f\\n'\n 'mode = %.3f\\n'\n 'stdev = %.3f\\n'\n 'minrate = %.2f Hz\\n'\n 'nneurons = %d\\n'\n 'dt = %d min'\n % (mean, median, mode, stdev,\n uns['MINRATE'], self.nneurons, intround(self.dtmin)),\n transform = a.transAxes,\n horizontalalignment='right',\n verticalalignment='top')\n f.tight_layout(pad=0.3) # crop figure to contents\n f.canvas.draw() # this is needed if a != None when passed as arg\n return a","def population_information(self):\n outstr = [\"Primary population: {}\\n\".format(self.population.population),\n \"Individuals: {}\\n\".format(self.total),\n \"Discovery populations: {}; Total: {}\\n\".format(\n self.disc_pops.to_simple_str(), self.total_disc\n )]\n for pop in ['european', 'african', 'east_asian',\n 'south_asian', 'hispanic', 'native',\n 'micronesian', 'arab', 'unspecified',\n 'filipino', 'indonesian']:\n outstr.append('\\t{}: {}\\n'.format(pop, eval('self.' + pop)))\n\n outstr.append(\"Replication populations: {}; Total: {}\\n\".format(\n self.rep_pops.to_simple_str(), self.total_rep\n ))\n for pop in ['european', 'african', 'east_asian',\n 'south_asian', 'hispanic', 'native',\n 'micronesian', 'arab', 'unspecified',\n 'filipino', 'indonesian']:\n outstr.append('\\t{}: {}\\n'.format(pop, eval('self.rep_' + pop)))","def get_random_population():\r\n return [ get_random_individual() for _ in range(POPULATION_COUNT) ]","def get_population(simu, size, loci, info_fields='self_gen'):\n return simu.Population(size=size,\n ploidy=2,\n loci=loci,\n infoFields=str(info_fields))","def generatePopulations(num_pops):\n distGenerator = DistributionGenerator()\n populations = []\n for i in range(num_pops):\n dist_type = random.sample(config.dist_types, 1)[0]\n populations.append(distGenerator.generateDistributions(dist_type, config.MaxDistributionSize))\n return populations","def form_population_matrix(N, hb, Nb, ht, Nt, pac, age_and_gender):\n \n # 1 allocated to iso-boxes and tents\n household_column = create_household_column(hb, Nb, ht, Nt)\n # 2 allocate an infector\n disease_column = create_diseasestate_column(N)\n # 3 weibull distribution\n dsymptom_column = create_daystosymptoms_column(N)\n # 4 np.zeros(num_ppl)\n daycount_column = create_daycount_column(N)\n # 5 hard coded number of chronics\n asymp_column = create_asymp_column(N, pac)\n # 6 age\n age_column = create_age_column(age_and_gender[:,0])\n # 7 gender\n gender_column = create_gender_column(age_and_gender[:,1])\n # 8 formula based on age\n chronic_column = create_chronic_column(N, age_column)\n # 5 new_asymp_column[chronic_column==1]=0\n new_asymp_column = adjust_asymp_with_chronic(asymp_column, chronic_column)\n # 9\n wanderer_column = create_wanderer_column(gender_column, age_column)\n\n pop_matrix = np.column_stack((household_column, disease_column, dsymptom_column,\n daycount_column, new_asymp_column, age_column,\n gender_column, chronic_column, wanderer_column))\n \n assert pop_matrix.shape == (N, 9)\n return pop_matrix","def subdAutoProjection(*args, caching: bool=True, nodeState: Union[int, bool]=0,\n constructionHistory: bool=True, layout: Union[int, bool]=0,\n layoutMethod: Union[int, bool]=0, name: AnyStr=\"\", optimize: Union[int,\n bool]=0, percentageSpace: Union[float, bool]=0.0, planes: Union[int,\n bool]=6, scale: Union[int, bool]=0, skipIntersect: bool=True,\n worldSpace: bool=True, q=True, query=True, e=True, edit=True,\n **kwargs)->Union[AnyStr, Any]:\n pass","def main(N,N_p,T,lb,ub,prob,N_vars,F_min,F_const,P_c_min,P_c_max):\n\n lb,ub,f,fu,D,U,P = initDE(N_p,lb,ub,prob)\n if N_p < 4:\n raise Exception(\"Sorry, there must be atleast a population of 4. Reccomended 20\")\n for t in np.arange(T):\n for i in np.arange(N_p):\n V = mutation(i,N_p,t,T,P,N_vars,F_min,F_const)\n\n U=crossover(f,P_c_min,P_c_max,i,D,V,P,U)\n\n for j in np.arange(N_p): \n N,f,P = boundgreed(N,j,U,P,f,fu,ub,lb,prob)\n\t\n\t\t#if N == 500:\n\t\t\t#break\n best_of_f= min(f)\n globopt = P[f.argmin()]\n return N,best_of_f, globopt[:N_vars]","def simplex_proj_mat(P):\n P_proj = np.zeros_like(P)\n for i in range(P.shape[0]):\n P_proj[i,:] = simplex_proj(P[i,:])\n \n return P_proj","def Build(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_Build(self, *args)","def prj(self,method):\n valid_methods={\"max\",\"sum\",\"mean\"}\n if method not in valid_methods:\n warnings.warn(\"Projection method is not valid, pick from following valid methods: {valid_methods}\", UserWarning)\n elif method==\"max\":\n self.maxprj=(np.amax(self.pixels,axis=0))\n elif method==\"sum\":\n self.sumprj=(np.sum(self.pixels,axis=0))\n elif method==\"mean\":\n self.meanprj=(np.mean(self.pixels,axis=0))","def island_procreate(self):\n for y in self.island_map:\n for cell in y:\n cell.procreate()","def obs_ijpos(gridfile,lons,lats,coor):\n\n gfh= netCDF4.Dataset(gridfile)\n cartesian=0\n if (coor=='r'):\n try:\n \n latr=gfh.variables['lat_rho'][:,:]\n lonr=gfh.variables['lon_rho'][:,:]\n except:\n latr=gfh.variables['latitude'][:,:]\n lonr=gfh.variables['longitude'][:,:]\n \n\n try:\n xr=gfh.variables['xi_rho'][:]\n yr=gfh.variables['eta_rho'][:]\n except:\n try:\n xr=gfh.variables['x_rho'][:]\n yr=gfh.variables['y_rho'][:]\n except:\n print('Neither xi_rho/eta_rho or x_rho/y_rho on file.')\n print('This might slow down the calculations')\n\n\n elif (coor=='u'):\n latr=gfh.variables['lat_u'][:,:]\n lonr=gfh.variables['lon_u'][:,:]\n try:\n xr=gfh.variables['xi_u'][:]\n yr=gfh.variables['eta_u'][:]\n except:\n xr=gfh.variables['x_u'][:]\n yr=gfh.variables['y_u'][:]\n elif (coor=='v'):\n latr=gfh.variables['lat_v'][:,:]\n lonr=gfh.variables['lon_v'][:,:]\n try:\n xr=gfh.variables['xi_v'][:]\n yr=gfh.variables['eta_v'][:]\n except:\n xr=gfh.variables['x_v'][:]\n yr=gfh.variables['y_v'][:]\n\n IN = point_in_polygon(lonr, latr, lons, lats)\n ind=np.where(IN)[0]\n \n if lats.size >1: \n lons=lons[ind]; lats=lats[ind]\n # If there's no lons, lats left at this stage, return oipos, ojpos with -999 everywhere\n if not len(lons):\n return np.ones_like(IN)*-999, np.ones_like(IN)*-999\n \n try:\n try:\n mapstr=str(gfh.variables['h'].getncattr('mapping'))\n except:\n try:\n mapstr=str(gfh.variables['h'].getncattr('grid_mapping'))\n except:\n pass\n try:\n projstring=(gfh.variables[mapstr]).getncattr('proj4')\n except:\n try:\n projstring=(gfh.variables[mapstr]).getncattr('proj4string')\n except:\n pass\n try:\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4')\n except:\n try:\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4string')\n except:\n pass\n\n gridproj=proj.Proj(str(projstring))\n hasproj=1\n except:\n hasproj=0\n\n # Check if lat, lon spacing is uniform\n dx1=np.abs(lonr[0,1]-lonr[0,0])\n dx2=np.abs(lonr[0,-1]-lonr[0,-2])\n n=int(np.round(lonr.shape[1]/2))\n dx3=np.abs(lonr[0,n]-lonr[0,n-1])\n\n dy1=np.abs(latr[1,0]-latr[0,0])\n dy2=np.abs(latr[-1,0]-latr[-2,0])\n n=int(np.round(latr.shape[0]/2))\n dy3=np.abs(latr[n,0]-latr[n-1,0])\n\n if ( (dx1 == dx2) & (dx1==dx3) & (dx2==dx3) & (dy1 == dy2) & (dy1==dy3) & (dy2==dy3) ):\n cartesian=1\n gridproj=proj.Proj(\"+proj=latlong +datum=WGS84\")\n \n\n \n if hasproj:\n dx=xr[1]-xr[0]\n dy=yr[1]-yr[0]\n [x,y]=gridproj(lons,lats)\n ipos=(x-xr[0])/dx\n jpos=(y-yr[0])/dy\n\n elif cartesian:\n [x1,y1]=gridproj(lonr[0,0],latr[0,0])\n [x2,y2]=gridproj(lonr[0,1],latr[0,1])\n dx=x2-x1\n [x2,y2]=gridproj(lonr[1,0],latr[1,0])\n dy=y2-y1\n [x,y]=gridproj(lons,lats)\n [x0,y0]=gridproj(lonr[0,0],latr[0,0])\n\n ipos=(x-x0)/dx\n jpos=(y-y0)/dy\n\n else:\n x=np.linspace(0,lonr.shape[1]-1,lonr.shape[1])\n y=np.linspace(0,lonr.shape[0]-1,lonr.shape[0])\n xi=np.zeros_like(lonr); yi=np.zeros([lonr.shape[1],lonr.shape[0]])\n xi[:,:]=x; yi[:,:]=y; yi=np.swapaxes(yi,1,0)\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),xi.flatten(),(lons,lats))\n ipos=zi\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),yi.flatten(),(lons,lats))\n jpos=zi\n \n if 'ind' in locals():\n oipos=np.ones(IN.shape)*-999.; ojpos=np.ones(IN.shape)*-999.\n oipos[ind]=ipos; ojpos[ind]=jpos\n else:\n oipos=ipos\n ojpos=jpos\n if not IN:\n oipos = np.array([-999.])\n ojpos = np.array([-999.])\n gfh.close()\n return oipos,ojpos","def projection(self):\n pass","def projection(self):\n return [row[2:-2] for row in self[2:-2]]","def get_params_proj(ima, xform = \"xform.projection\"):\n\tt = ima.get_attr(xform)\n\td = t.get_params(\"spider\")\n\treturn d[\"phi\"],d[\"theta\"],d[\"psi\"],-d[\"tx\"],-d[\"ty\"]","def get_population_by_race_columns():\n return {\n 'DP05_0070E': 'Population (Total)',\n 'DP05_0071E': 'Population (Hispanic or Latino)',\n 'DP05_0077E': 'Population (White alone, Non-Hispanic)',\n 'DP05_0078E': 'Population (Black or African American alone, Non-Hispanic)',\n 'DP05_0080E': 'Population (Asian alone, Non-Hispanic)',\n\n # These will be grouped into an \"Other\" category\n 'DP05_0079E': 'Population (American Indian and Alaska Native alone, Non-Hispanic)',\n 'DP05_0081E': 'Population (Native Hawaiian and Other Pacific Islander alone, Non-Hispanic)',\n 'DP05_0082E': 'Population (Some other race alone, Non-Hispanic)',\n 'DP05_0083E': 'Population (Two or more races, Non-Hispanic)'\n }","def Projection(W, TYPE_PROJ = proj_l11ball, ETA = 100, AXIS = 0, ETA_STAR = 100, device = \"cpu\" ): \n \n #global TYPE_PROJ, ETA, ETA_STAR, AXIS, device \n if TYPE_PROJ == 'No_proj':\n W_new = W\n if (TYPE_PROJ == proj_l1ball or TYPE_PROJ == proj_l11ball or TYPE_PROJ == proj_l11ball_line ):\n W_new = TYPE_PROJ(W, ETA, device)\n if TYPE_PROJ == proj_l21ball or TYPE_PROJ == proj_l12ball:\n W_new = TYPE_PROJ(W, ETA, AXIS, device = device)\n if TYPE_PROJ == proj_nuclear:\n W_new = TYPE_PROJ(W, ETA_STAR, device=device)\n return W_new","def Couple(self, *args):\n return _BRepAlgo.BRepAlgo_NormalProjection_Couple(self, *args)","def get_projection(attrs):\n df = load_df()\n\n X = get_all_vectors(df, attrs)\n logger.info('- Data shape original: {}'.format(X.shape))\n\n X = X if isinstance(X, np.ndarray) else X.toarray()\n X = dimension_reduction(X, attrs['decomposition'], attrs['distanceMetric'])\n return X, df","def combine_all_populations(folder: str,\n max_v: int = None,\n neat: bool = False,\n neat_gru: bool = False,\n neat_lstm: bool = False,\n neat_sru: bool = False,\n neat_sru_s: bool = False,\n ):\n # Collect all the populations\n populations = []\n if neat: populations.append(D_NEAT)\n if neat_gru: populations.append(D_NEAT_GRU)\n if neat_lstm: populations.append(D_NEAT_LSTM)\n if neat_sru: populations.append(D_NEAT_SRU)\n if neat_sru_s: populations.append(D_NEAT_SRU_S)\n if len(populations) == 0: return\n \n # Collect all the measure options\n OPTIONS = ['distance', 'finished', 'fitness', 'score', 'time', 'training']\n # OPTIONS = ['fitness']\n \n # Go over all possibilities\n print(f\"\\n===> COMBINING POPULATIONS OF FOLDER {folder} <===\")\n path = f\"population_backup/storage/{folder}/\"\n path_images = get_subfolder(path, 'images')\n for option in OPTIONS:\n plt.figure(figsize=(8, 2.5))\n max_data = 0\n max_gen = 0\n for pop in populations:\n # Load the dictionary\n d = load_dict(f\"{path}{pop}/evaluation/{option}\")\n size = len(list(d.values())[0])\n if max_v: assert size == max_v\n \n # Prepare the data containers\n q1 = []\n q2 = [] # Median\n q3 = []\n idx_q1 = int(round(1 / 4 * size))\n idx_q2 = int(round(2 / 4 * size))\n idx_q3 = int(round(3 / 4 * size))\n \n # Loop over each iteration\n x = sorted([int(k) for k in d.keys()])\n for g in x:\n if g > max_gen: max_gen = g\n lst = sorted(d[str(g)]) # Sort values from low to high\n q1.append(lst[idx_q1])\n q2.append(lst[idx_q2])\n q3.append(lst[idx_q3])\n \n # Plot the results\n plt.plot(x, q1, color=COLORS[pop], linestyle=\":\", linewidth=.5)\n plt.plot(x, q3, color=COLORS[pop], linestyle=\":\", linewidth=.5)\n plt.plot(x, q2, color=COLORS[pop], linestyle=\"-\", linewidth=2, label=pop)\n plt.fill_between(x, q1, q3, color=COLORS[pop], alpha=0.2)\n \n # Update the max-counter\n if max(q3) > max_data: max_data = max(q3)\n \n # Finalize the figure\n leg = plt.legend(loc='upper center',\n bbox_to_anchor=(0.5, 1.25),\n fancybox=True,\n fontsize=10,\n ncol=len(populations))\n for line in leg.get_lines():\n line.set_linewidth(4.0)\n # plt.xticks([i * 100 for i in range(11)]) # TODO\n plt.xlabel(\"generation\")\n plt.xlim(0, max_gen)\n # plt.yticks([i for i in range(7)]) # TODO\n plt.ylabel(option)\n plt.ylim(0, max(max_data * 1.05, 1.05))\n # plt.ylim(0, 6) # TODO\n plt.grid()\n plt.tight_layout()\n plt.savefig(f\"{path_images}comb_{option}.png\", bbox_inches='tight', pad_inches=0.02, dpi=500)\n # plt.savefig(f\"{path_images}comb_{option}.eps\", format=\"eps\", bbox_inches='tight', pad_inches=0.02)\n # plt.show()\n plt.close()","def interactive_grid(mols, *args, molsPerRow=5, **kwargs):\n \n import mols2grid\n \n return mols2grid.display(mols, *args, n_cols=molsPerRow, **kwargs)","def get_personnel():\r\n if len(exe) == 0:\r\n print(\"There are no executives\")\r\n else:\r\n for i in exe:\r\n print(str(i))","def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\n\n lat_grid = np.linspace(latS, latN, latlen)\n lon_grid = np.linspace(lonW, lonE, lonlen)\n\n return lat_grid,lon_grid","def get_grid_data(grid):\n indir = '/home/ivan/Tools/scrip/mapping/grids'\n infile = os.path.join(indir, grid + '.nc')\n fp = Nio.open_file(infile,'r')\n nlon, nlat = fp.variables['grid_dims'][:]\n tlat = fp.variables['grid_center_lat'][:]\n tlon = fp.variables['grid_center_lon'][:]\n fp.close()\n tlat = N.reshape(tlat,(nlat,nlon))[:,0]\n tlon = N.reshape(tlon,(nlat,nlon))[0,:]\n return nlon, nlat, tlon, tlat","def koopman_prob(data, observables, ncp):\n def _wrapper(func, args):\n \"\"\"\n Wrapper function to be able to call the function `func` with\n arguments inside a list.\n \"\"\"\n return func(*args)\n\n # Structure data as we want to\n data = {'x1': data[0,:], 'x2': data[1,:]}\n\n # Extract interesting simulation results\n snapshots = np.zeros((len(observables),ncp+1))\n for i, obs in enumerate(observables):\n syms = obs.free_symbols # Get args in this observable\n states = [sym.name for sym in list(syms)] # Get the names of the args, i.e. our states\n f = lambdify(syms, obs, 'numpy') # Vectorize the observable function\n values = [data[state] for state in states] # Get simulation result for each state\n val = _wrapper(f, values) # Computes g_i(x)\n snapshots[i,:] = val\n\n return snapshots","def genPopulation(self):\r\n self.population_list = []\r\n for i in xrange(0, self.pop_size):\r\n individual = bitarray(self.indv_size)\r\n # Loop for randomizing the 'individual' string.\r\n for j in xrange(0, self.board_size):\r\n vert_pos = random.randint(0, self.board_size-1)\r\n vert_pos_bitnum = toBitArray(vert_pos, self.pos_bits_size)\r\n # print \"\\t\\t\", j, vert_pos_bitnum, vert_pos\r\n for k in range(0, self.pos_bits_size):\r\n individual[j * self.pos_bits_size + k] = vert_pos_bitnum[k]\r\n self.population_list.append(individual)\r\n # print \"\\t\", i, individual\r","def get_genes_and_gpr(model,gene_outfile,gpr_outfile):\n model_dict = model_to_dict(model, sort=False)\n genes = pd.DataFrame(model_dict['genes']).set_index(['id'])\n genes.to_csv(gene_outfile)\n all_gpr = pd.DataFrame(model_dict['reactions']).set_index(['id'])\n all_gpr.to_csv(gpr_outfile)\n return [genes, all_gpr]","def read_population_assignation(namefile):\n db = shelve.open(namefile)\n hashes = db['hashes']\n key_firms = db['nif']\n year = db['year']\n population_value = db['population']\n methodvalues = db['methodvalues']\n db.close()\n return hashes, key_firms, year, population_value, methodvalues","def reproduce(population:list):\n new_gen = []\n probs = []\n for p in population:\n probs.append(p[3])\n while len(new_gen) != len(probs):\n parents = selection(probs)\n son,eval_son,daughter,eval_daughter = xo(population[parents[0]][0],population[parents[0]][1], population[parents[1]][0],population[parents[1]][1],2)\n new_gen.append([son,eval_son])\n new_gen.append([daughter,eval_daughter])\n # mutation\n # lets say 5% of the population gets mutated\n how_many_to_mutate = int(NUM_OF_CHROMOZOMS * (1/100))\n t = [i for i in range(NUM_OF_CHROMOZOMS)]\n # choose percent of the population randomly, uniformly\n indices_to_mutate = choice(t, how_many_to_mutate, replace=False)\n for i in range(len(indices_to_mutate)):\n mutate(new_gen[indices_to_mutate[i]])\n\n evaluateAll(new_gen)\n return new_gen","def simple_projections(self, to_negative=True):\n assert to_negative == True # Not implemented otherwise!!!!!\n res = self.alpha().zip(self.projection, self.alphacheck())\n # Should this use rename to set a nice name for this family?\n res.rename(\"pi\")\n return res","def create_populations(self, nb:int=1):\n self.populations.append(self.config.create(self.pop_size))","def project_parensemble(self,par_file=None,nsing=None,\n inplace=True,enforce_bounds='reset'):\n assert self.jco is not None,\"MonteCarlo.project_parensemble()\" +\\\n \"requires a jacobian attribute\"\n if par_file is not None:\n assert os.path.exists(par_file),\"monte_carlo.draw() error: par_file not found:\" +\\\n par_file\n self.parensemble.pst.parrep(par_file)\n\n # project the ensemble\n self.log(\"projecting parameter ensemble\")\n en = self.parensemble.project(self.get_null_proj(nsing),inplace=inplace,log=self.log)\n self.log(\"projecting parameter ensemble\")\n return en","def gotop(net, namet, go_file, goa_file, n=100, **ka):\n\timport numpy as np\n\tnt = len(namet)\n\tif net.shape != (nt, nt) or nt <= 1:\n\t\traise ValueError('Wrong shape for net or namet.')\n\tif n <= 1 or n >= nt:\n\t\traise ValueError(\n\t\t\t'Number of principal genes must be from 1 to the number of all genes (exclusive).'\n\t\t)\n\n\t# Find principal genes\n\tt1 = net.sum(axis=1)\n\tt2 = t1[t1.argsort()[::-1][n]]\n\n\tif t2 == 0:\n\t\traise RuntimeError('Not enough principal genes that have co-expression')\n\tt2 = np.nonzero(t1 >= t2)[0]\n\tassert len(t2) >= n\n\tassert len(t2) < nt\n\tt1 = [str(x) for x in namet[t2]]\n\tt2 = [str(x) for x in namet]\n\treturn tuple([t1] + list(goe(t1, go_file, goa_file, bg=t2, **ka)))","def test_choropleth_pass():\n m = view(world, column=\"pop_est\")","def __call__(self, *columns, test_size, random_state=42):\n # print(quad_size, columns) if print is to stay, then use logging\n w = self.quad_size\n dataset = columns[1]\n print(self.quad_size)\n if w == 0:\n train_ids, test_ids = train_test_split([i for i in range(len(dataset))], test_size=test_size, random_state=random_state)\n else:\n r = np.random.RandomState(random_state)\n d_lon = r.random_sample()\n r_lat = np.random.RandomState(random_state + 10)\n d_lat = r_lat.random_sample()\n\n proj = OrderedDict()\n print('ici')\n for i, coor in enumerate(dataset):\n lon, lat = self._project(coor[0], coor[1])\n proj_lon = (lon + d_lon * w) // w\n proj_lat = (lat + d_lat * w) // w\n if (proj_lon, proj_lat) in proj:\n proj[(proj_lon, proj_lat)].append(i)\n else:\n proj[(proj_lon, proj_lat)] = [i]\n\n train_map, test_map = train_test_split(list(proj.keys()), test_size=test_size, random_state=random_state)\n\n train_ids = [i for quadra in train_map for i in proj[quadra]]\n test_ids = [i for quadra in test_map for i in proj[quadra]]\n # creating output\n r = []\n for col in columns:\n r.extend((col[train_ids], col[test_ids]))\n return r","def jupiteNetwork(): \n \n # Build a graph for large clos topo\n tor_cut, aggr_cut, spine_cut = 512, 256, 256\n #2048, 4096, 4096 #32*4*2, 64*2, 16*2\n switches, edges = tp.jupiter_topo(\n tor_cut=tor_cut, aggr_cut=aggr_cut, spine_cut=spine_cut\n )\n \n G = build_graph(edges)\n external_edges = []\n for node in G.nodes():\n if 'sh' in node:\n G.add_edge(node, 'e1')\n \n \"\"\"\n paths = list(nx.all_shortest_paths(G, 'tor385', 'tor1'))\n #print(paths)\n #eee\n paths = list(nx.all_shortest_paths(G, 'tor129', 'tor257'))\n #print(paths)\n paths = list(nx.all_shortest_paths(G, 'tor257', 'tor385'))\n #print(paths)\n #eee\n \"\"\"\n switch_nodes, hnodes, tors, anodes, snodes = tp.getJupiternNodes(\n tors_num=tor_cut, aggr_num=aggr_cut, spine_num=spine_cut\n )\n print('**** is_connected(G)', nx.is_connected(G))\n print('**** number of components', nx.number_connected_components(G))\n \n tors = tors[0:512] + ['e1']\n\n # Get the routing path of all nodes\n table_file_name = '../outputs/jupiter_routing_table_anodes_cut4.txt'\n\n if((os.path.isfile(table_file_name)) == False):\n table = all_routing(G, tors, table_file_name)\n else:\n json_data = open(table_file_name).read()\n table = json.loads(json_data)\n \n seeds, polys = cf.get_seeds_table_jupiter(switch_nodes + ['e1']) #\n \n return G, tors, edges, table, seeds, polys, anodes","def read_population() -> pd.DataFrame:\n\n pop_df = pd.read_csv(\"data/API_SP.POP.TOTL_DS2_en_csv_v2_988606.csv\",\n header=2, usecols=[0,62], names=[\"Country\", \"Population\"])\n\n index = pop_df[pop_df[\"Country\"]==\"Iran, Islamic Rep.\"].index.values[0]\n pop_df.loc[index, \"Country\"] = \"Iran\"\n index = pop_df[pop_df[\"Country\"] == \"United States\"].index.values[0]\n pop_df.loc[index, \"Country\"] = \"US\"\n index = pop_df[pop_df[\"Country\"] == \"Russian Federation\"].index.values[0]\n pop_df.loc[index, \"Country\"] = \"Russia\"\n\n pop_df = pop_df.dropna()\n\n return pop_df","def explore(self, T, *args):\n nparams = T.param.size\n if hasattr(T, 'copy'):\n T = T.copy()\n deltas = [[0] for i in range(nparams)]\n for a in args:\n deltas[a[0]] = a[1]\n grids = np.mgrid[[slice(0, len(d)) for d in deltas]]\n ntrials = np.prod(grids.shape[1:])\n Deltas = [np.asarray(deltas[i])[grids[i, :]].ravel()\\\n for i in range(nparams)]\n simis = np.zeros(ntrials)\n params = np.zeros([nparams, ntrials])\n\n Tv = ChainTransform(T, pre=self._from_affine,\n post=self._to_inv_affine)\n param0 = Tv.param\n for i in range(ntrials):\n param = param0 + np.array([D[i] for D in Deltas])\n Tv.param = param\n simis[i] = self._eval(Tv)\n params[:, i] = param\n\n return simis, params","def create_tables(*args):\n import pandas\n tables = {}\n for locus in args[0].index:\n tables[locus] = get_table(*args, locus)\n return tables","def protons ( self ) :\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\n ## \n if self['NOPIDHADRONS'] :\n from StandardParticles import StdAllNoPIDsProtons as inpts\n protoncut = self['ProtonCut']\n else :\n from StandardParticles import StdAllLooseANNProtons as inpts \n protoncut = \"(%s)&(%s)\" % ( self['ProtonCut'] , self['ProtonPIDCut'] ) \n #\n ##\n return self.make_selection (\n 'Proton' ,\n FilterDesktop ,\n [ inpts ] ,\n Code = protoncut ,\n )","def select_random(pops, fit_pop):\n random_index_d = {}\n random_fit_inds_d = {}\n random_pop_inds_d = {}\n for i in range(n_islands):\n random_index_d[i] = random.sample(range(npop), n_migrate)\n random_fit_inds_d[i] = list(map(lambda x: fit_pop[i][x], random_index_d[i]))\n random_pop_inds_d[i] = list(map(lambda y: pops[i][y], random_index_d[i]))\n\n return random_index_d, random_fit_inds_d, random_pop_inds_d","def _read_pops(self, sheet) -> None:\n\n # TODO - can modify _read_pops() and _write_pops() if there are more population attributes\n tables = read_tables(sheet)[0]\n assert len(tables) == 1, \"Population Definitions page should only contain one table\"\n\n self.pops = sc.odict()\n assert cell_get_string(tables[0][0][0]).lower() == \"abbreviation\"\n assert cell_get_string(tables[0][0][1]).lower() == \"full name\"\n\n # If pop typ column exists, check the heading is correct\n if len(tables[0][0]) > 2:\n assert cell_get_string(tables[0][0][2]).lower() == \"population type\"\n\n for row in tables[0][1:]:\n\n pop_name = cell_get_string(row[0])\n assert len(pop_name) > 1, 'Population code name (abbreviation) \"%s\" is not valid - it must be at least two characters long' % (pop_name)\n\n label = cell_get_string(row[1])\n assert len(label) > 1, 'Population full name \"%s\" is not valid - it must be at least two characters long' % (label)\n\n if pop_name.lower() in FS.RESERVED_KEYWORDS:\n raise Exception('Population name \"%s\" is a reserved keyword' % (pop_name.lower()))\n\n poptype = None\n if len(row) > 2 and row[2].value is not None:\n poptype = cell_get_string(row[2])\n\n self.pops[pop_name] = {\"label\": label, \"type\": poptype}","def getProjectionMatchingArgs(self, iterN):\n \n args = ' --Ri %(innerRadius)s'\n args += ' --Ro %(outerRadius)s --max_shift %(maxShift)s --search5d_shift %(search5dShift)s'\n args += ' --search5d_step %(search5dStep)s --append'\n \n params = {\n 'innerRadius' : self._innerRadius[iterN],\n 'outerRadius' : self._outerRadius[iterN],\n 'maxShift' : self._maxChangeOffset[iterN],\n 'search5dShift' : self._search5DShift[iterN],\n 'search5dStep' : self._search5DStep[iterN],\n }\n \n if self.doScale:\n args += ' --scale %(scaleStep)s %(scaleNumberOfSteps)s'\n params['scaleStep'] = self._scaleStep[iterN]\n params['scaleNumberOfSteps'] = self._scaleNumberOfSteps[iterN]\n \n if self.doCTFCorrection and self._referenceIsCtfCorrected[iterN]:\n args += ' --pad %(pad)s'\n params['pad'] = self.paddingFactor.get()\n\n if self.numberOfMpi > 1:\n params['mpiJobSize'] = self.mpiJobSize.get()\n args += ' --mpi_job_size %(mpiJobSize)s'\n \n return args % params","def main():\n national_university_table()","def calc_population(self, vars_int, vars_float, problem_results, components=None):\n n_pop = problem_results[\"n_pop\"].values\n n_states = problem_results[\"n_org_states\"].values\n n_turbines = problem_results.dims[FC.TURBINE]\n data = (\n problem_results[self.variable]\n .to_numpy()\n .reshape(n_pop, n_states, n_turbines)\n )\n data = xr.DataArray(data, dims=(FC.POP, FC.STATE, FC.TURBINE))\n\n if self.n_sel_turbines < self.farm.n_turbines:\n data = data[:, self.sel_turbines]\n\n return self._contract(data / self.scale).to_numpy()[:, None]","def get_station_projects(stn_df, proj_df, engine): \n # Get stn IDs\n assert len(stn_df) > 0, 'ERROR: Please select at least one station.'\n stn_df['station_id'].drop_duplicates(inplace=True)\n stn_ids = stn_df['station_id'].values.astype(int).tolist()\n\n # Get proj IDs\n assert len(proj_df) > 0, 'ERROR: At least one project must already be selected.'\n proj_df['project_id'].drop_duplicates(inplace=True)\n proj_ids = proj_df['project_id'].values.astype(int).tolist() \n\n # Number from 0 to n_stns\n bind_stns = ','.join(':%d' % i for i in range(len(stn_ids)))\n \n # Number from n_stns to (n_stns+n_projs)\n bind_prjs = ','.join(':%d' % i for i in range(len(stn_ids), \n len(stn_ids) + len(proj_ids)))\n \n # Query db\n sql = (\"SELECT a.project_id, \"\n \" b.o_number, \"\n \" a.project_name, \"\n \" a.project_description \"\n \"FROM nivadatabase.projects a, \"\n \" nivadatabase.projects_o_numbers b \"\n \"WHERE a.project_id = b.project_id \"\n \"AND a.project_id IN \"\n \" (SELECT project_id \"\n \" FROM nivadatabase.projects_stations \"\n \" WHERE station_id IN (%s) \"\n \" AND project_id IN (%s) \"\n \" ) \"\n \"ORDER BY a.project_id\" % (bind_stns, bind_prjs))\n\n bind_dict = {'%d' % idx:item for idx, item in enumerate(stn_ids)}\n bind_prj_dict = {'%d' % (idx + len(stn_ids)):item \n for idx, item in enumerate(proj_ids)}\n bind_dict.update(bind_prj_dict) \n df = pd.read_sql(sql, params=bind_dict, con=engine)\n \n return df","def compound_generator(pop):\n gen = -1\n while True:\n ngen = pop.dvars().gen\n if gen != ngen:\n # At the beginning of a generation, extract the\n # sex-specific subpopulations from a parental\n # population. The sex-specific subpopulations are used\n # throughout mating events in one generation.\n gen = ngen\n males = pop.extractSubPops(subPops=[(0, 0)])\n herms = pop.extractSubPops(subPops=[(0, 1)])\n nmale = males.popSize()\n nherm = herms.popSize()\n\n if runif() < sstar: # uniparental\n yield herms.individual(rint(nherm))\n else: # biparental\n yield [males.individual(rint(nmale)), herms.individual(rint(nherm))]","def init_population(pop_number, variables, domains):\n population = []\n for i in range(pop_number):\n new_individual = {}\n for v in variables:\n # randomly choose an assignment from this variable's domain\n ind = np.random.choice(len(domains[v]))\n new_individual[v] = domains[v][ind]\n population.append(OrderedDict(sorted(new_individual.items())) )\n\n return population","def test_population_movements_with_compilation(self):\n self._pystepx = PySTEPXIsland(nb_islands=4, init_script=init_script)\n print self._pystepx._rc[0]['gp_engine']\n self._pystepx._rc[0].execute('elems = gp_engine.get_evolver().select_and_remove_individuals(0.01)',\n block=True)\n print self._pystepx._rc[0]['elems']","def find_population(self, x, pops):\n M = sum([len(pops[pop]) for pop in pops])\n N = len(x)\n\n survival_values = []\n intersections = []\n lens = []\n\n rsv, rpop, rk = 2, -1, 0\n\n for pop in pops:\n n = len(pops[pop])\n intersec = np.intersect1d(x, pops[pop])\n k = len(intersec)\n sv = hypergeom.sf(k-1, M=M, n=n, N=N) if k > 0 else 1\n\n survival_values.append(sv)\n intersections.append(intersec)\n lens.append(len(pops[pop]))\n\n if sv <= rsv or (rsv == 2 and k > 0):\n rsv, rpop, rk = sv, pop, k\n\n all_pops = {'svs': np.array(survival_values),\n 'intersecs': np.array(intersections),\n 'lens': np.array(lens)}\n\n if rk == 0: # in case of no intersection, return -1\n return \"None\", 1, np.array([]), 0, all_pops\n else:\n return rpop, rsv, np.intersect1d(x, pops[rpop]), len(pops[rpop]), all_pops","def gatherData(data,neat,gen,iter_i,hyp,savePop=False):\n data.gatherData(neat.pop, neat.species)\n\n if savePop is True: # Get a sample pop to play with in notebooks\n global fileName\n pref = output_dir + '/iter_{}'.format(iter_i) + '/gen_' + str(gen).zfill(4)\n import pickle\n with open(pref+'.obj', 'wb') as fp:\n pickle.dump(neat.pop,fp)\n\n return data","def get_projection_params(fname):\n # Read strings from the region file\n with open(fname, 'r') as f:\n lines = f.readlines()\n wcs = lines[2][:-1] # Coordinate system TODO bad variable name\n if lines[0] != '# Region file format: DS9 version 4.1\\n':\n print 'Warning: potentially invalid region file!'\n print 'First line was: ' + lines[0]\n if wcs != 'fk5':\n raise Exception('Regions must be in sky (fk5) coordinates; got ' +\n wcs + 'instead')\n\n # Manipulate each string and save to list\n lines = filter(lambda x: '# projection' in x, lines[3:])\n projspecs = []\n for ln in lines:\n lnsplit = ln[2:-1].split(')') # Remove leading '#', trailing '\\n'\n if lnsplit[1] == '':\n r = lnsplit[0] + ')' # No optional arguments\n else:\n r = lnsplit[0] + ') #' + lnsplit[1] # Add octothorpe\n projspecs.append('%s; %s' % (wcs, r))\n\n return projspecs","def create_grid_queries(all_data_dicts, smod=2):\n rf_width_y, rf_width_x = [], []\n rf_y, rf_x = [], []\n for dat in all_data_dicts:\n rf_width_y += [dat['on_width_y']]\n rf_width_x += [dat['on_width_x']]\n cre_line = dat['cre_line']\n structure = dat['structure']\n rf_y += [dat['on_center_y']]\n rf_x += [dat['on_center_x']]\n\n # Get 95th percentile x and y width\n y_width = int(np.ceil(np.percentile(rf_width_y, 95)))\n x_width = int(np.ceil(np.percentile(rf_width_x, 95)))\n\n # Stride of the neuron bins\n y_stride = int(y_width/smod)\n x_stride = int(x_width/smod)\n\n # Create queries that have width and height by the receptive field size\n y_limit = int(np.floor(np.max(rf_y)))\n x_limit = int(np.floor(np.max(rf_x)))\n queries = []\n for x1 in (range(0, x_limit, x_stride)):\n for y1 in range(0, y_limit, y_stride):\n\n # Add width to each x1 as long as it's not more than x_max\n x2 = x1 + x_width\n # Add width to each y1 as long as it's not more than y_max\n y2 = y1 + y_width\n\n # add new coordinate range to queries\n queries += [[{\n 'rf_coordinate_range': { # Get all cells\n 'x_min': x1,\n 'x_max': x2,\n 'y_min': y1,\n 'y_max': y2,\n },\n 'cre_line': cre_line,\n 'structure': structure}]]\n return queries, max([x_width, y_width])","def main():\n population = 1000\n print(\"Welcome to the Gopher Population Simulator!\")\n print(\"Starting population: {0}\".format(population))\n print(\"Year 1\\n\")\n for year in range(2, YEARS + 1, 1):\n population_print(population, year)","def getProjections(self): \n x, y, z = self.XYZCoordinate\n origin = self.SkeletonPoints[0]\n self.coorOrigin = origin\n self.XYProjections = [GeometryToolBox.projected_point(p, origin, x, y) for p in self.SkeletonPoints]\n self.XZProjections = [GeometryToolBox.projected_point(p, origin, x, z) for p in self.SkeletonPoints]","def get_xProj(self, iproj):\n return self.xProj[iproj]","def eval_genomes(population, conf):\n for (_, g) in population:\n eval_genome(g, conf)","def displayPathtoPrincess(n, grid):\n solution = SavePrincess(grid)\n print \"{0}\".format(solution)","def get_parameter_grid(model_name, momentum=False, size=10, randomize=True, seed=1234321):\n try:\n param_space = model_param_space[model_name]\n except KeyError:\n raise ValueError('Parameter space for model {} is not defined.'.format(model_name))\n values_grid = pd.DataFrame.from_records(itertools.product(*param_space.values()), columns=param_space.keys())\n if momentum:\n values_grid = add_momentum(values_grid, 'once', seed=seed)\n if randomize:\n values_grid = values_grid.sample(frac=1, random_state=seed).reset_index(drop=True)\n return values_grid.head(size) # Limit number of experiments"],"string":"[\n \"def getCellsByMitralConnection(args, network, projection, population, allcells=False):\\n cellList = []\\n cellUniques = []\\n if args.has_key('mitrals'):\\n for mitid in args['mitrals']:\\n mitpath = 'mitrals_'+str(mitid)\\n cellnum = 0\\n if projection in network.projectionDict:\\n for conn in network.projectionDict[projection][2]:\\n if mitpath in conn[2]: # if mitrals_<mitid> is substring of post_seg_path of this connection\\n cellpath = string.split(conn[1],'/')[1] # take out cellname from '/cellname/segmentname\\n ## Take only those cells that have not been taken before.\\n if cellpath not in cellUniques:\\n cell = moose.Cell(cellpath)\\n cellList.append(cell)\\n cellUniques.append(cellpath)\\n cellnum += 1\\n if not allcells and cellnum == 30: break\\n else:\\n if allcells: cellList = network.populationDict[population][1].values()\\n else: cellList = network.populationDict[population][1].values()[0:60]\\n return cellList\",\n \"def run_simulation(env, pop, nr):\\n pop_f = []\\n pop_pl = []\\n pop_el = []\\n\\n\\n for individual in pop:\\n fitness, player_life, enemy_life, time = env.play(pcont=individual)\\n pop_f.append(fitness)\\n pop_pl.append(player_life)\\n pop_el.append(enemy_life)\\n\\n return pop_f, pop_pl, pop_el\",\n \"def personnel_projects_table(personnel_search_table_selected_indices, selected_funding, selected_year, rows):\\n personnel_outcome_data, personnel_name = personnel_outcomes_helper(personnel_search_table_selected_indices, selected_funding, selected_year, rows)\\n if personnel_outcome_data is not None:\\n personnel_outcome_data = personnel_outcome_data[[\\\"type\\\", \\\"pub_title\\\"]]\\n return personnel_outcome_data.to_dict('records')\\n\\n return pd.DataFrame(data=None, columns=[\\\"type\\\", \\\"pub_title\\\"]).to_dict('records') # None cannot be passed back as it will cause an error.\",\n \"def tsne_projection(train_file, gen_file, i):\\n train_data = pd.read_csv(train_file)\\n def get_ori_prom(row):\\n if row['gaps'] <= 2 and row['dips'] <=2:\\n return 'Model'+str(i)+'_train_promising'\\n else:\\n return 'Model'+str(i)+'_train'\\n train_data['label'] = train_data.apply(get_ori_prom, axis=1)\\n train_data = train_data.drop(['id', 'gaps', 'dips'], axis=1)\\n gen_prom_smiles = pd.read_csv(gen_file)\\n gen_prom_smiles = gen_prom_smiles.drop(['Group', 'Gaps', 'Dips'], axis=1)\\n gen_prom_smiles['label'] = 'Generated_promising'\\n all_smi = pd.concat([train_data, gen_prom_smiles])\\n mols = get_mols(all_smi.SMILES)\\n fps, _ = get_fingerprints(mols)\\n fp_embeded = TSNE(n_components=2, perplexity=100).fit_transform(fps)\\n all_smi['tsne1'] = fp_embeded[:, 0]\\n all_smi['tsne2'] = fp_embeded[:, 1]\\n return all_smi, len(train_data)\",\n \"def population(params, n=100):\\r\\n pops = []\\r\\n for i in range(n):\\r\\n pop = []\\r\\n for param in params:\\r\\n pop.append(np.random.choice(param))\\r\\n\\r\\n individuale = Individuale(pop)\\r\\n pops.append(individuale)\\r\\n # print(\\\"No.{} : {} : {}\\\".format(i, individuale, individuale.x))\\r\\n return pops\",\n \"def population_projection(self):\\n population_projection = Worldometers.soup.find_all(class_='years')[1]\\n year_rows = population_projection.find_all('tr')\\n\\n population_projection_dict = {}\\n for x in range(1, len(year_rows)):\\n columns = year_rows[x].find_all('td')\\n population_projection_dict[x-1] = {\\n 'year': columns[0].getText().replace(',', ''),\\n 'population': columns[1].getText().replace(',', ''),\\n 'growth': columns[2].getText().replace(' %', '')\\n }\\n\\n return population_projection_dict\",\n \"def get_chained_proj(self):\\n #non recursive call\\n N = self.N_in\\n projs = []\\n for layer in self.layers:\\n proj,N_out = self.get_deprojecter(layer,N)\\n projs.append(proj)\\n N = N_out\\n return projs\",\n \"def printPop(population: list):\\n for p in population:\\n print(p)\",\n \"def run_projections(self):\\n self.projection_collection100 = DonorCollection()\\n self.projection_collection50 = DonorCollection()\\n double_over_100 = dict(list(\\n (name, list(map(lambda x: x * 2, donations.donations))) for name, donations in self.donors.items()))\\n triple_under_50 = dict(list(\\n (name, list(map(lambda x: x * 3, donations.donations))) for name, donations in self.donors.items()))\\n for donor, donations in double_over_100.items():\\n self.projection_collection100.add(donor, donations)\\n for donor, donations in triple_under_50.items():\\n self.projection_collection50.add(donor, donations)\\n return self.projection_collection50, self.projection_collection100\",\n \"def get_grid_data_popdiag(grid):\\n# indir = '/CESM/bgcwg/obgc_diag/mapping/grids'\\n indir = '/glade/p/cesm/bgcwg/obgc_diag/mapping/grids'\\n infile = os.path.join(indir, grid + '.nc')\\n fp = Nio.open_file(infile,'r')\\n nlon, nlat = fp.variables['grid_dims'][:]\\n tlat = fp.variables['grid_center_lat'][:]\\n tlon = fp.variables['grid_center_lon'][:]\\n fp.close()\\n tlat = N.reshape(tlat,(nlat,nlon))[:,0]\\n tlon = N.reshape(tlon,(nlat,nlon))[0,:]\\n return nlon, nlat, tlon, tlat\",\n \"def star_topology(random, population, args):\\r\\n for _ in range(len(population)):\\r\\n yield population[:]\",\n \"def _projections(self, nvar):\\n min_var = self.proje_var.argsort()[:nvar]\\n add_coeffs = 1 / self.proje_var[min_var]\\n indp_est_proje = np.dot(add_coeffs, self.sep_proje_eval[min_var]) /\\\\\\n np.sum(add_coeffs)\\n\\n # consider covariance\\n coverr = []\\n try:\\n proje_cov_inv = np.linalg.inv(self.proje_cov[min_var][:, min_var])\\n cov_weight = np.sum(proje_cov_inv, axis=0) / np.sum(proje_cov_inv)\\n cov_est_proje = np.dot(cov_weight, self.sep_proje_eval[min_var])\\n coverr.append(1/np.sum(proje_cov_inv))\\n except:\\n cov_est_proje = np.ones(self.sep_proje_eval.shape[1])\\n cov_est_proje[:] = np.nan\\n coverr.append(np.nan)\\n return np.array([indp_est_proje, cov_est_proje])\",\n \"def project_pop(self):\\n M = self.N[0:2]\\n for x in range(10):\\n M.append(self.run_step(M))\\n split_N = split_list(M)\\n \\n fig = self.make_figure(split_N)\\n fig.update_layout(title='Projected Fish Population')\\n\\n return fig\",\n \"def select(self, m, population):\\n pass\",\n \"def intrapop_connections(n_mitral, n_granule, n_subpop, n_mitral_per_subpop):\\n resmat = np.zeros((n_mitral, n_granule))\\n for i_subpop in xrange(n_subpop):\\n start = i_subpop*n_mitral_per_subpop\\n stop = start + n_mitral_per_subpop\\n resmat[start:stop, i_subpop] = 1.\\n return resmat\",\n \"def initPopulation(self, task):\\n\\t\\tSol, Fitness, d = Algorithm.initPopulation(self, task)\\n\\t\\tA, S, Q, v = np.full(self.NP, self.A), np.full([self.NP, task.D], 0.0), np.full(self.NP, 0.0), np.full([self.NP, task.D], 0.0)\\n\\t\\td.update({'A': A, 'S': S, 'Q': Q, 'v': v})\\n\\t\\treturn Sol, Fitness, d\",\n \"def project(data=None, x=None, y=None, z=None, outfile=None, **kwargs):\\n\\n if kwargs.get(\\\"C\\\") is None:\\n raise GMTInvalidInput(\\\"The `center` parameter must be specified.\\\")\\n if kwargs.get(\\\"G\\\") is None and data is None:\\n raise GMTInvalidInput(\\n \\\"The `data` parameter must be specified unless `generate` is used.\\\"\\n )\\n if kwargs.get(\\\"G\\\") is not None and kwargs.get(\\\"F\\\") is not None:\\n raise GMTInvalidInput(\\n \\\"The `convention` parameter is not allowed with `generate`.\\\"\\n )\\n\\n with GMTTempFile(suffix=\\\".csv\\\") as tmpfile:\\n if outfile is None: # Output to tmpfile if outfile is not set\\n outfile = tmpfile.name\\n with Session() as lib:\\n if kwargs.get(\\\"G\\\") is None:\\n # Choose how data will be passed into the module\\n table_context = lib.virtualfile_from_data(\\n check_kind=\\\"vector\\\", data=data, x=x, y=y, z=z, required_z=False\\n )\\n\\n # Run project on the temporary (csv) data table\\n with table_context as infile:\\n arg_str = build_arg_string(kwargs, infile=infile, outfile=outfile)\\n else:\\n arg_str = build_arg_string(kwargs, outfile=outfile)\\n lib.call_module(module=\\\"project\\\", args=arg_str)\\n\\n # if user did not set outfile, return pd.DataFrame\\n if outfile == tmpfile.name:\\n if kwargs.get(\\\"G\\\") is not None:\\n column_names = list(\\\"rsp\\\")\\n result = pd.read_csv(tmpfile.name, sep=\\\"\\\\t\\\", names=column_names)\\n else:\\n result = pd.read_csv(tmpfile.name, sep=\\\"\\\\t\\\", header=None, comment=\\\">\\\")\\n # return None if outfile set, output in outfile\\n elif outfile != tmpfile.name:\\n result = None\\n\\n return result\",\n \"def atlas_projects():\\n pass\",\n \"def FindGrid(self, p_float=..., p_float=..., p_float=..., *args, **kwargs):\\n ...\",\n \"def allJPDs(net):\\r\\n \\r\\n onodes = net.Outputnodes()\\r\\n combinations = [i for i in itertools.combinations(onodes,2)]\\r\\n JPDdata = [] \\r\\n for c in combinations:\\r\\n priorA = getPrior(net,c[0])\\r\\n priorB = getPrior(net,c[1]) \\r\\n jpd = JPD(net,c)\\r\\n cov = Covariance (priorA,priorB,jpd)\\r\\n cor = Correlation (priorA,priorB,cov) \\r\\n JPDdata.append([c[0],c[1],jpd,cov,cor])\\r\\n return JPDdata\",\n \"def get_population_names (f,a,s):\\r\\n ## a, s not used but needed for function to match general function format\\r\\n global gv\\r\\n aa = f.readline().strip()\\r\\n popnamelist = []\\r\\n i = 0\\r\\n foundghost = False\\r\\n while aa.find(\\\"Population\\\") >= 0:\\r\\n popname = aa.split()[3]\\r\\n if popname.upper() == \\\"GHOST\\\":\\r\\n foundghost = True\\r\\n popnamelist.append(popname)\\r\\n i += 1\\r\\n aa = f.readline().strip()\\r\\n if gv[\\\"useghost\\\"] == True and foundghost == False: # for compatibility with older output files\\r\\n popnamelist.append('ghost')\\r\\n anames = []\\r\\n if gv[\\\"usealtnames\\\"]:\\r\\n for line in open(gv[\\\"altnamefilename\\\"],\\\"r\\\"):\\r\\n temp = line.strip()\\r\\n if len(temp) > 0:\\r\\n anames.append(temp)\\r\\n anames = anames[0:len(popnamelist)]\\r\\n gv[\\\"altpopnames\\\"] = list(anames)\\r\\n return popnamelist\",\n \"def population_observer(population, num_generations, num_evaluations, args):\\r\\n population.sort(reverse=True)\\r\\n print('----------------------------------------------------------------------------')\\r\\n print(' Current Population')\\r\\n print('----------------------------------------------------------------------------')\\r\\n for ind in population:\\r\\n print(str(ind))\\r\\n print('----------------------------------------------------------------------------')\",\n \"def createGridcells(mapdata, listOfP):\\n new_gridcells = GridCells()\\n new_gridcells.header = mapdata.header\\n new_gridcells.cell_width = mapdata.info.resolution\\n new_gridcells.cell_height = mapdata.info.resolution\\n new_gridcells.cells = []\\n for p in listOfP:\\n new_gridcells.cells.append(PathPlanner.grid_to_world(mapdata, p[0], p[1]))\\n return new_gridcells\",\n \"def JPD(net,nodeTuple): \\r\\n\\r\\n priorA = getPrior(net,nodeTuple[0]) \\r\\n statesA = net.NodeStates(nodeTuple[0],naming = 'titlename') \\r\\n statesB = net.NodeStates(nodeTuple[1],naming = 'titlename')\\r\\n numstatesA = [float(i) for i in statesA] \\r\\n numstatesB = [float(i) for i in statesB] \\r\\n output = np.zeros((len(statesA)+1,len(statesB)+1))\\r\\n output[0,1:] = numstatesB\\r\\n output[1:,0] = numstatesA\\r\\n for n,i in enumerate(statesA):\\r\\n net.RetractFinding() \\r\\n output[n+1][1:] = np.array(net.Finding(nodeTuple[0],i,nodeTuple[1],output = 'name'))*priorA[0][n]\\r\\n return output\",\n \"def query_settlement_layer(grid):\\n path = os.path.join(SHAPEFILE_DIR, f'{COUNTRY_ABBRV}.tif')\\n\\n grid['population'] = pd.DataFrame(\\n zonal_stats(vectors=grid['geometry'], raster=path, stats='sum'))['sum']\\n\\n grid = grid.replace([np.inf, -np.inf], np.nan)\\n\\n return grid\",\n \"def default_selection(random, population, args):\\r\\n return population\",\n \"def proj(self, X, G):\\n raise NotImplementedError\",\n \"def init_pop(self):\\n genes = np.random.randn( self.population_size * self.individual.gene_count )\\n self.population = genes.reshape((self.population_size, -1))\\n #print(self.population)\",\n \"def get_null_proj(self,nsing=None):\\n if nsing is None:\\n nsing = self.get_nsing()\\n if nsing is None:\\n raise Exception(\\\"nsing is None\\\")\\n print(\\\"using {0} singular components\\\".format(nsing))\\n self.log(\\\"forming null space projection matrix with \\\" +\\\\\\n \\\"{0} of {1} singular components\\\".format(nsing,self.jco.shape[1]))\\n\\n v2_proj = (self.xtqx.v[:,nsing:] * self.xtqx.v[:,nsing:].T)\\n self.log(\\\"forming null space projection matrix with \\\" +\\\\\\n \\\"{0} of {1} singular components\\\".format(nsing,self.jco.shape[1]))\\n\\n return v2_proj\",\n \"def generate_population(population_size, nn_architecture):\\n population = []\\n for _ in range(population_size):\\n population.append(nn.create_nn_from_arch(nn_architecture))\\n\\n return population\",\n \"def projected():\\n # pull updated list of donors(class)\\n projected_list = create_donors_list()\\n print('''Welcome to the Projection Option. Here you can run projections for contributions. \\n Help Companies structure their matching donations based on past contribution amounts.\\n Simply enter the minumum and maximum donation range that will be matched and see the total contribution:''')\\n try:\\n minimum_input = float(\\n input('Enter a minimum donation amount (0 if none): '))\\n maximum_input = float(\\n input('Enter a maximum donation amount (0 if none): '))\\n factor = float(\\n input('Please enter the factor you wish to multiply these donations by >> '))\\n except ValueError:\\n print('Please follow instructions and enter a number only')\\n\\n projections = projection(projected_list, factor,\\n minimum_input, maximum_input)\\n print('\\\\nProjected contribution value: ${:,.2f}'.format(projections))\",\n \"def process_pop(pop_path, pop_prefix, external_cols, truncate=False,\\r\\n index_cols = ['location_id', 'year_id','age_group_id','sex_id']):\\r\\n\\r\\n\\r\\n # Get the data\\r\\n pop = pandas_read_infer_filetype(pop_path)\\r\\n\\r\\n # Identify columns with pop data\\r\\n pop_cols = [col for col in pop.columns if pop_prefix in col]\\r\\n\\r\\n # We don't want to actually duplicate data we dont have\\r\\n unique_pop_names = pop_cols\\r\\n\\r\\n # A few situations:\\r\\n # 1. We have 1 pop column to match with N external columns,\\r\\n # so we return a list with the same column repeated N times (just the name, not the data)\\r\\n # 2. We have N pop columns to match with N external columns, we do nothing spexical\\r\\n # 3. We have P pop columns to match with N external columns:\\r\\n # a. If P > N\\r\\n # i. if truncate is true, return the first N pop columns\\r\\n # ii. if truncate is false, raise an error\\r\\n # b. If P < N, raise an error\\r\\n\\r\\n\\r\\n # Double check the pop common prefix\\r\\n pop_prefix = os.path.commonprefix(pop_cols)\\r\\n external_prefix = os.path.commonprefix(external_cols)\\r\\n\\r\\n if pop_prefix == external_prefix:\\r\\n\\r\\n # If they match, rename the pop columns\\r\\n rename_dict = {pop_col:'_'+pop_col for pop_col in pop_cols}\\r\\n pop = pop.rename(columns=rename_dict)\\r\\n pop_cols = ['_'+pop_col for pop_col in pop_cols]\\r\\n unique_pop_names = pop_cols\\r\\n\\r\\n\\r\\n pop = pop[index_cols+unique_pop_names]\\r\\n\\r\\n return pop, pop_cols\",\n \"def setUp(self):\\n N = 10\\n pA = 0.5\\n pB = 0.5\\n qA = 1 - pA\\n qB = 1 - pB\\n locus_A = (['A'] * int(N * pA)) + (['a'] * int(round(N * qA)))\\n locus_B = (['B'] * int(N * pB)) + (['b'] * int(round(N * qB)))\\n self.pop = population.Population(N, locus_A, locus_B)\",\n \"def get_multi(datasource='crubadan', option=\\\"raw\\\", collapse=False, verbose=True):\\n return MultiDict(get_matrix(n=i,\\n datasource=datasource, option=option, collapse=collapse, verbose=verbose)\\n for i in range(6))\",\n \"def get_testing_pop(agegroup_strata: List[str], country: Country, pop: Population):\\n testing_region = \\\"Victoria\\\" if country.iso3 == \\\"AUS\\\" else pop.region\\n testing_year = 2020 if country.iso3 == \\\"AUS\\\" else pop.year\\n testing_pop = inputs.get_population_by_agegroup(\\n agegroup_strata, country.iso3, testing_region, year=testing_year\\n )\\n return testing_pop, testing_region\",\n \"def explore_db(self, db=None, table=None, col=None):\\n\\n try:\\n self.db_dict\\n except AttributeError:\\n self._generate_schema()\\n\\n projects = np.sort(list(self.db_dict.keys()))\\n largest = max([len(projects[i]) for i in range(len(projects))])\\n t = Table()\\n # db not specified\\n if not db:\\n warnings.warn(\\\"Must first specify a database.\\\")\\n proj_list = []\\n attr_list = []\\n info_list = []\\n tmp2_largest = 0\\n for proj in projects:\\n size = len((self.db_dict['{0}'.format(proj)].keys()))\\n proj_list += (['@ {}'.format(proj)]\\n + ['' for i in range(size - 1)]\\n + ['-' * (largest + 2)])\\n tmp_largest = max([len(str(key))\\n for key in self.db_dict[proj].keys()])\\n attr_list += (['@ {}'.format(key)\\n if isinstance(self.db_dict[proj][key], dict)\\n else '{}:'.format(key)\\n for key in self.db_dict[proj].keys()]\\n + ['-' * (tmp_largest + 2)])\\n tmpinfosize = max([len(self.db_dict[proj][key])\\n if isinstance(self.db_dict[proj][key], str)\\n else 0\\n for key in self.db_dict[proj].keys()])\\n if tmpinfosize > tmp2_largest:\\n tmp2_largest = tmpinfosize\\n for proj in projects:\\n info_list += ([self.db_dict[proj][key]\\n if isinstance(self.db_dict[proj][key], str)\\n else \\\"\\\"\\n for key in self.db_dict[proj].keys()] + ['-' * tmp2_largest])\\n t['Projects'] = proj_list\\n t['Project Items'] = attr_list\\n t['Information'] = info_list\\n t.pprint()\\n # db specified\\n if db:\\n try:\\n size1 = len(list(self.db_dict[str(db)].keys()))\\n slist = [list(self.db_dict[db][key].keys())\\n if isinstance(self.db_dict[db][key], dict)\\n else key\\n for key in self.db_dict[db].keys()]\\n size2 = len(max(slist, key=np.size))\\n except (KeyError, NameError):\\n log.error(\\\"Must first specify a valid database.\\\")\\n return\\n # if col is specified, table must be specified, and I need to\\n # check the max size of any given column in the structure\\n if table:\\n try:\\n size2 = max(size2, len(list(self.db_dict[db]['tables']\\n [table]['columns'].keys())))\\n if col:\\n try:\\n size2 = max(size2, len(list(self.db_dict[db]['tables']\\n [table]['columns']\\n [col].keys())))\\n except (KeyError, NameError):\\n log.error(\\\"Must first specify a valid column \\\"\\n \\\"of the `{0}` table within the `{1}`\\\"\\n \\\" db\\\".format(table, db))\\n return\\n except (KeyError, NameError):\\n log.error(\\\"Must first specify a valid table within \\\"\\n \\\"the `{0}` db.\\\".format(db))\\n return\\n\\n t['Projects'] = (['--> @ {}:'.format(db)] + ['' for i in range(size2 - 1)])\\n t['Project Items'] = (\\n ['--> @ {}:'.format(key)\\n if (isinstance(self.db_dict[db][key], dict)\\n and (len(list(self.db_dict[db][key].keys()))\\n == len(list(self.db_dict[db]['tables'].keys()))))\\n else '@ {}'.format(key)\\n if (isinstance(self.db_dict[db][key], dict)\\n and (len(list(self.db_dict[db][key].keys()))\\n != len(self.db_dict[db]['tables'].keys())))\\n else str(key)\\n for key in self.db_dict[db].keys()] + ['' for i in range(size2 - size1)])\\n # if only db is specified\\n if not table:\\n if not col:\\n reordered = sorted(max(slist, key=np.size), key=len)\\n t['Tables'] = ['@ {}'.format(i)\\n if isinstance(self.db_dict[db]['tables'][i],\\n dict)\\n else str(i)\\n for i in reordered]\\n # if table has been specified\\n else:\\n reordered = (\\n [str(table)]\\n + sorted([key for key in self.db_dict[db]['tables'].keys()\\n if key != table], key=len))\\n t['Tables'] = (\\n ['--> @ {}:'.format(i)\\n if (i == table and isinstance(self.db_dict[db]['tables'][i], dict))\\n else '@ {}'.format(i)\\n if (i != table and isinstance(self.db_dict[db]['tables'][i], dict))\\n else str(i)\\n for i in reordered] + ['' for j in range(size2 - len(reordered))])\\n\\n # if column has been specified\\n if col:\\n tblcols_dict = self.db_dict[db]['tables'][table].keys()\\n t['Table Items'] = (\\n ['--> @ columns:']\\n + [i for i in tblcols_dict if i != 'columns']\\n + ['' for j in range(size2 - len(tblcols_dict))])\\n col_dict = (self.db_dict[db]['tables'][table]\\n ['columns'].keys())\\n reordered = ([str(col)] + [i for i in col_dict if i != col])\\n\\n temp_columns = []\\n\\n columns = self.db_dict[db]['tables'][table]['columns']\\n for i in reordered:\\n c = columns[i]\\n if isinstance(c, dict) and i == col:\\n temp_columns.append('--> @ {}:'.format(i))\\n elif not isinstance(c, dict) and i == col:\\n temp_columns.append('--> {}:'.format(i))\\n elif isinstance(c, dict) and i != col:\\n temp_columns.append('@ {}'.format(i))\\n else:\\n temp_columns.append(str(i))\\n\\n if len(col_dict) < size2:\\n size_diff = size2 - len(col_dict)\\n t['Columns'] = (temp_columns + ['' for j in range(size_diff)])\\n\\n colinfo_dict = col_dict = columns[col]\\n t['Col. Info'] = (\\n ['{} : {}'.format(i, colinfo_dict[i])\\n for i in colinfo_dict.keys()] + ['' for j in range(size2 - len(colinfo_dict))])\\n else:\\n t['Columns'] = temp_columns\\n\\n # if column has not been specified\\n else:\\n tblcols_dict = self.db_dict[db]['tables'][table].keys()\\n col_dict = (\\n self.db_dict[db]['tables'][table]['columns'].keys())\\n reordered = sorted(col_dict, key=len)\\n if len(tblcols_dict) < size2:\\n size_diff = size2 - len(tblcols_dict)\\n tmp_table = self.db_dict[db]['tables'][table]\\n t['Table Items'] = (\\n ['@ {}'.format(i) if isinstance(tmp_table[i], dict)\\n else '{}:'.format(i) for i in tblcols_dict] + ['' for i in range(size_diff)])\\n t['Table Info'] = (\\n [str(tmp_table[i])\\n if not isinstance(tmp_table[i], dict)\\n else '' for i in tblcols_dict] + ['' for i in range(size_diff)])\\n if len(col_dict) < size2:\\n t['Columns'] = (\\n ['@ {}'.format(i)\\n if isinstance(tmp_table['columns'][i], dict)\\n else str(i)\\n for i in reordered] + ['' for i in range(size2 - len(col_dict))])\\n else:\\n t['Columns'] = reordered\\n else:\\n t['Table Items'] = tblcols_dict\\n t.pprint()\",\n \"def copy_grid (grid):\\r\\n c=[]\\r\\n for i in range(len(grid)):\\r\\n c.append(grid[i])\\r\\n return eval(str(c))\",\n \"def get_data(n):\\n data = pd.read_csv('map_data/lior_results_2.csv')\\n data = data.drop(['estimated_mass', 'estimated_pop'], axis=1)\\n data = data[data.binomial != 'Sus scrofa'] # Wild Boar\\n data = data[data.binomial != 'Ursus maritimus'] # Polar bear\\n data = data[data.binomial != 'Sus bucculentus'] # EX\\n data = data[data.binomial != 'Melomys rubicola'] # EX\\n data = data.assign(total_mass=data.AdultBodyMassG * data.pop_density * data.Range,\\n total_mass_density=data.AdultBodyMassG * data.pop_density)\\n data = data.sort_values(by='total_mass_density', ascending=False)\\n data = data.iloc[0:n - 1]\\n geo_data = gpd.read_file('TERRESTRIAL_MAMMALS/TERRESTRIAL_MAMMALS.shp').to_crs(\\\"EPSG:6933\\\")\\n geo_data = geo_data[geo_data.category != 'EX']\\n range_polygons = geo_data.loc[(geo_data['legend'] == 'Extant & Introduced (resident)') |\\n (geo_data['legend'] == 'Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Extant & Reintroduced (resident)') |\\n (geo_data['legend'] == 'Extant & Vagrant (seasonality uncertain)') |\\n (geo_data['legend'] == 'Extant (non breeding)') |\\n (geo_data['legend'] == 'Extant (resident)') |\\n (geo_data['legend'] == 'Probably Extant & Origin Uncertain (resident)') |\\n (geo_data['legend'] == 'Probably Extant (resident)') |\\n (geo_data['legend'] == 'Reintroduced')]\\n range_polygons = range_polygons.merge(data, on='binomial')\\n range_polygons = range_polygons.to_crs(\\\"EPSG:6933\\\")\\n return range_polygons\",\n \"def build_tweaks(mitralsclub, nospineinh, nosingles,\\n nojoints, nomultis, nopgs, onlytwomits, \\n includeProjections=[], twomitrals=(0,2), nolateral=False):\\n excludePopulations = []\\n excludeProjections = ['SA']\\n ## In odor_pulses, odor_morphs, scaled_pulses, I have not specified to include \\n ## file-based inputs to 2nd order cells as below. If not specified, force include:\\n if 'granule_baseline' not in includeProjections: includeProjections.append('granule_baseline')\\n if 'ORN_PG' not in includeProjections: includeProjections.append('ORN_PG')\\n if not mitralsclub:\\n excludeProjections.append('mitral_granule_extra_exc')\\n if nospineinh:\\n excludeProjections.append('_spinesingles')\\n excludeProjections.append('_spinejoints')\\n excludeProjections.append('_spinemultis')\\n if nosingles:\\n excludePopulations.append('singles')\\n excludeProjections.append('_singles') # _ to avoid deleting spinesingles\\n if nojoints:\\n excludePopulations.append('joints')\\n excludeProjections.append('_joints') # _ to avoid deleting spinejoints\\n if nomultis:\\n excludePopulations.append('multis')\\n excludeProjections.append('_multis') # _ to avoid deleting spinemultis\\n if nopgs:\\n excludePopulations.append('PGs')\\n excludeProjections.append('PG')\\n if onlytwomits:\\n onlyInclude = {'includePopulation':('mitrals',[str(twomitrals[0]),str(twomitrals[1])]),\\n 'includeProjections':includeProjections}\\n return {'excludePopulations':excludePopulations,\\n 'excludeProjections':excludeProjections,'onlyInclude':onlyInclude}\\n else:\\n if nolateral:\\n ## remove other mitrals so that there is no lateral inhibition\\n ## differs from nojoints, in keeping the joints self-inhibition\\n print \\\"EXCLUDING OTHER MITS, KEEPING ONLY mits 0 and 1\\\"\\n onlyInclude = {'includePopulation':('mitrals',['0','1']),\\n 'includeProjections':includeProjections}\\n return {'excludePopulations':excludePopulations,\\n 'excludeProjections':excludeProjections,'onlyInclude':onlyInclude}\\n else:\\n return {'excludePopulations':excludePopulations,\\\\\\n 'excludeProjections':excludeProjections}\",\n \"def get_neighborhood_probabilities(labels, model_grid_path, model_names, proj_str, obj=False, json_path=None):\\n ds_list = []\\n storm_grid = xr.open_dataset(model_grid_path)\\n for coord in ['lon', 'lat']:\\n storm_grid[coord].values = storm_grid[coord].astype('float32')\\n\\n for run_date in sorted(labels['Run_Date'].unique()):\\n print(run_date)\\n run_labels = labels.loc[labels['Run_Date'] == run_date]\\n if obj:\\n start = pd.to_datetime(run_labels['Run_Date'].min()).strftime(\\\"%Y%m%d-%H%M\\\")\\n end = pd.to_datetime(run_labels['Run_Date'].max()).strftime(\\\"%Y%m%d-%H%M\\\")\\n gdf = load_geojson_objs(start, end, json_path, \\\"hourly\\\")\\n\\n for forecast_hour in run_labels['Forecast_Hour'].unique():\\n\\n fh_labels = run_labels[run_labels[\\\"Forecast_Hour\\\"] == forecast_hour]\\n valid_time = pd.to_datetime(fh_labels['Valid_Date'].unique()[0])\\n ds = storm_grid.expand_dims('time').assign_coords(init_time=('time', [pd.to_datetime(run_date)]),\\n valid_time=('time', [valid_time]),\\n forecast_hour=('time', [forecast_hour]))\\n if obj:\\n gdf_sub = gdf[gdf['valid_time'] == forecast_hour]\\n for model in model_names:\\n\\n for storm_type in ['Supercell', 'QLCS', 'Disorganized']:\\n\\n model_mode = f'{model}_{storm_type}'\\n mode_prob = f'{model}_{storm_type}_prob'\\n df_storms = fh_labels[fh_labels[f'{model}_label'] == storm_type]\\n counts = np.zeros(shape=(1, storm_grid.y.size, storm_grid.x.size)).astype('float32')\\n raw_probs = counts.copy()\\n label_indxs = find_coord_indices(ds['lon'].values,\\n ds['lat'].values,\\n df_storms['Centroid_Lon'],\\n df_storms['Centroid_Lat'],\\n proj_str)\\n for c, i in zip(df_storms.index, label_indxs):\\n p = df_storms.loc[c, mode_prob]\\n counts[0, i[0], i[1]] = 1\\n raw_probs[0, i[0], i[1]] = p\\n if obj:\\n mask_indices = retrieve_mask_indices(gdf_sub.loc[df_storms.index], storm_grid)\\n for index in mask_indices:\\n for j in index:\\n counts[0, j[0], j[1]] = 1\\n raw_probs[0, j[0], j[1]] = p\\n\\n probabilities = compute_neighborhood_prob(counts, sigma=1)\\n\\n ds[mode_prob] = (['time', 'y', 'x'], raw_probs)\\n ds[model_mode] = (['time', 'y', 'x'], counts)\\n ds[f'{model_mode}_nprob'] = (['time', 'y', 'x'], probabilities)\\n\\n ds[mode_prob].attrs['Description'] = f'ML Probability of {storm_type}'\\n ds[model_mode].attrs['Description'] = f'Categorical Classification of {storm_type}'\\n ds[model_mode + '_nprob'].attrs['Description'] = f'Neighborhood Probabilities for {storm_type}'\\n\\n ds_list.append(ds)\\n\\n merged_ds = xr.concat(ds_list, dim='time')\\n\\n # if run_labels['Forecast_Hour'].nunique() < 17:\\n # merged_ds = add_missing_forecast_hours(merged_ds, 17)\\n # elif (run_labels['Forecast_Hour'].nunique() > 17) & (run_labels['Forecast_Hour'].nunique() < 47):\\n # merged_ds = add_missing_forecast_hours(merged_ds, 47)\\n\\n return merged_ds\",\n \"def pospdf(self, neurons='all', dim='y', edges=None, nbins=10, stats=False, labels=True,\\n a=None, figsize=(7.5, 6.5)):\\n if neurons == 'all':\\n neurons = list(self.alln.values())\\n elif neurons == 'quiet':\\n neurons = list(self.qn.values())\\n elif neurons == 'active':\\n neurons = list(self.n.values())\\n dimi = {'x':0, 'y':1}[dim]\\n p = [ n.pos[dimi] for n in neurons ] # all position values\\n if edges != None:\\n nbins = len(edges) - 1\\n bins = edges # assume it includes rightmost bin edge\\n else:\\n nbins = max(nbins, 2*intround(np.sqrt(self.nneurons)))\\n bins = nbins\\n n, p = np.histogram(p, bins=bins) # p includes rightmost bin edge\\n binwidth = p[1] - p[0] # take width of first bin in p\\n\\n if stats:\\n mean = np.mean(p)\\n median = np.median(p)\\n argmode = n.argmax()\\n mode = p[argmode] + binwidth / 2 # middle of tallest bin\\n stdev = np.std(p)\\n\\n if a == None:\\n f = pl.figure(figsize=figsize)\\n a = f.add_subplot(111)\\n else: # add to existing axes\\n a.hold(True)\\n f = pl.gcf()\\n\\n # use CCWHITEDICT1 for familiarity with len 10 1-based id to colour mapping\\n #color = CCWHITEDICT1[int(self.id)]\\n color = 'k'\\n\\n # exclude rightmost bin edge in p\\n a.bar(left=p[:-1], height=n, width=binwidth, bottom=0, color=color, ec=color)\\n titlestr = lastcmd()\\n gcfm().window.setWindowTitle(titlestr)\\n if labels:\\n a.set_title(titlestr)\\n a.set_xlabel('neuron %s position (um)' % dim)\\n a.set_ylabel('neuron count')\\n\\n if stats:\\n # add stuff to top right of plot:\\n uns = get_ipython().user_ns\\n a.text(0.99, 0.99, 'mean = %.3f\\\\n'\\n 'median = %.3f\\\\n'\\n 'mode = %.3f\\\\n'\\n 'stdev = %.3f\\\\n'\\n 'minrate = %.2f Hz\\\\n'\\n 'nneurons = %d\\\\n'\\n 'dt = %d min'\\n % (mean, median, mode, stdev,\\n uns['MINRATE'], self.nneurons, intround(self.dtmin)),\\n transform = a.transAxes,\\n horizontalalignment='right',\\n verticalalignment='top')\\n f.tight_layout(pad=0.3) # crop figure to contents\\n f.canvas.draw() # this is needed if a != None when passed as arg\\n return a\",\n \"def population_information(self):\\n outstr = [\\\"Primary population: {}\\\\n\\\".format(self.population.population),\\n \\\"Individuals: {}\\\\n\\\".format(self.total),\\n \\\"Discovery populations: {}; Total: {}\\\\n\\\".format(\\n self.disc_pops.to_simple_str(), self.total_disc\\n )]\\n for pop in ['european', 'african', 'east_asian',\\n 'south_asian', 'hispanic', 'native',\\n 'micronesian', 'arab', 'unspecified',\\n 'filipino', 'indonesian']:\\n outstr.append('\\\\t{}: {}\\\\n'.format(pop, eval('self.' + pop)))\\n\\n outstr.append(\\\"Replication populations: {}; Total: {}\\\\n\\\".format(\\n self.rep_pops.to_simple_str(), self.total_rep\\n ))\\n for pop in ['european', 'african', 'east_asian',\\n 'south_asian', 'hispanic', 'native',\\n 'micronesian', 'arab', 'unspecified',\\n 'filipino', 'indonesian']:\\n outstr.append('\\\\t{}: {}\\\\n'.format(pop, eval('self.rep_' + pop)))\",\n \"def get_random_population():\\r\\n return [ get_random_individual() for _ in range(POPULATION_COUNT) ]\",\n \"def get_population(simu, size, loci, info_fields='self_gen'):\\n return simu.Population(size=size,\\n ploidy=2,\\n loci=loci,\\n infoFields=str(info_fields))\",\n \"def generatePopulations(num_pops):\\n distGenerator = DistributionGenerator()\\n populations = []\\n for i in range(num_pops):\\n dist_type = random.sample(config.dist_types, 1)[0]\\n populations.append(distGenerator.generateDistributions(dist_type, config.MaxDistributionSize))\\n return populations\",\n \"def form_population_matrix(N, hb, Nb, ht, Nt, pac, age_and_gender):\\n \\n # 1 allocated to iso-boxes and tents\\n household_column = create_household_column(hb, Nb, ht, Nt)\\n # 2 allocate an infector\\n disease_column = create_diseasestate_column(N)\\n # 3 weibull distribution\\n dsymptom_column = create_daystosymptoms_column(N)\\n # 4 np.zeros(num_ppl)\\n daycount_column = create_daycount_column(N)\\n # 5 hard coded number of chronics\\n asymp_column = create_asymp_column(N, pac)\\n # 6 age\\n age_column = create_age_column(age_and_gender[:,0])\\n # 7 gender\\n gender_column = create_gender_column(age_and_gender[:,1])\\n # 8 formula based on age\\n chronic_column = create_chronic_column(N, age_column)\\n # 5 new_asymp_column[chronic_column==1]=0\\n new_asymp_column = adjust_asymp_with_chronic(asymp_column, chronic_column)\\n # 9\\n wanderer_column = create_wanderer_column(gender_column, age_column)\\n\\n pop_matrix = np.column_stack((household_column, disease_column, dsymptom_column,\\n daycount_column, new_asymp_column, age_column,\\n gender_column, chronic_column, wanderer_column))\\n \\n assert pop_matrix.shape == (N, 9)\\n return pop_matrix\",\n \"def subdAutoProjection(*args, caching: bool=True, nodeState: Union[int, bool]=0,\\n constructionHistory: bool=True, layout: Union[int, bool]=0,\\n layoutMethod: Union[int, bool]=0, name: AnyStr=\\\"\\\", optimize: Union[int,\\n bool]=0, percentageSpace: Union[float, bool]=0.0, planes: Union[int,\\n bool]=6, scale: Union[int, bool]=0, skipIntersect: bool=True,\\n worldSpace: bool=True, q=True, query=True, e=True, edit=True,\\n **kwargs)->Union[AnyStr, Any]:\\n pass\",\n \"def main(N,N_p,T,lb,ub,prob,N_vars,F_min,F_const,P_c_min,P_c_max):\\n\\n lb,ub,f,fu,D,U,P = initDE(N_p,lb,ub,prob)\\n if N_p < 4:\\n raise Exception(\\\"Sorry, there must be atleast a population of 4. Reccomended 20\\\")\\n for t in np.arange(T):\\n for i in np.arange(N_p):\\n V = mutation(i,N_p,t,T,P,N_vars,F_min,F_const)\\n\\n U=crossover(f,P_c_min,P_c_max,i,D,V,P,U)\\n\\n for j in np.arange(N_p): \\n N,f,P = boundgreed(N,j,U,P,f,fu,ub,lb,prob)\\n\\t\\n\\t\\t#if N == 500:\\n\\t\\t\\t#break\\n best_of_f= min(f)\\n globopt = P[f.argmin()]\\n return N,best_of_f, globopt[:N_vars]\",\n \"def simplex_proj_mat(P):\\n P_proj = np.zeros_like(P)\\n for i in range(P.shape[0]):\\n P_proj[i,:] = simplex_proj(P[i,:])\\n \\n return P_proj\",\n \"def Build(self, *args):\\n return _BRepAlgo.BRepAlgo_NormalProjection_Build(self, *args)\",\n \"def prj(self,method):\\n valid_methods={\\\"max\\\",\\\"sum\\\",\\\"mean\\\"}\\n if method not in valid_methods:\\n warnings.warn(\\\"Projection method is not valid, pick from following valid methods: {valid_methods}\\\", UserWarning)\\n elif method==\\\"max\\\":\\n self.maxprj=(np.amax(self.pixels,axis=0))\\n elif method==\\\"sum\\\":\\n self.sumprj=(np.sum(self.pixels,axis=0))\\n elif method==\\\"mean\\\":\\n self.meanprj=(np.mean(self.pixels,axis=0))\",\n \"def island_procreate(self):\\n for y in self.island_map:\\n for cell in y:\\n cell.procreate()\",\n \"def obs_ijpos(gridfile,lons,lats,coor):\\n\\n gfh= netCDF4.Dataset(gridfile)\\n cartesian=0\\n if (coor=='r'):\\n try:\\n \\n latr=gfh.variables['lat_rho'][:,:]\\n lonr=gfh.variables['lon_rho'][:,:]\\n except:\\n latr=gfh.variables['latitude'][:,:]\\n lonr=gfh.variables['longitude'][:,:]\\n \\n\\n try:\\n xr=gfh.variables['xi_rho'][:]\\n yr=gfh.variables['eta_rho'][:]\\n except:\\n try:\\n xr=gfh.variables['x_rho'][:]\\n yr=gfh.variables['y_rho'][:]\\n except:\\n print('Neither xi_rho/eta_rho or x_rho/y_rho on file.')\\n print('This might slow down the calculations')\\n\\n\\n elif (coor=='u'):\\n latr=gfh.variables['lat_u'][:,:]\\n lonr=gfh.variables['lon_u'][:,:]\\n try:\\n xr=gfh.variables['xi_u'][:]\\n yr=gfh.variables['eta_u'][:]\\n except:\\n xr=gfh.variables['x_u'][:]\\n yr=gfh.variables['y_u'][:]\\n elif (coor=='v'):\\n latr=gfh.variables['lat_v'][:,:]\\n lonr=gfh.variables['lon_v'][:,:]\\n try:\\n xr=gfh.variables['xi_v'][:]\\n yr=gfh.variables['eta_v'][:]\\n except:\\n xr=gfh.variables['x_v'][:]\\n yr=gfh.variables['y_v'][:]\\n\\n IN = point_in_polygon(lonr, latr, lons, lats)\\n ind=np.where(IN)[0]\\n \\n if lats.size >1: \\n lons=lons[ind]; lats=lats[ind]\\n # If there's no lons, lats left at this stage, return oipos, ojpos with -999 everywhere\\n if not len(lons):\\n return np.ones_like(IN)*-999, np.ones_like(IN)*-999\\n \\n try:\\n try:\\n mapstr=str(gfh.variables['h'].getncattr('mapping'))\\n except:\\n try:\\n mapstr=str(gfh.variables['h'].getncattr('grid_mapping'))\\n except:\\n pass\\n try:\\n projstring=(gfh.variables[mapstr]).getncattr('proj4')\\n except:\\n try:\\n projstring=(gfh.variables[mapstr]).getncattr('proj4string')\\n except:\\n pass\\n try:\\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4')\\n except:\\n try:\\n projstring=(gfh.variables['grid_mapping']).getncattr('proj4string')\\n except:\\n pass\\n\\n gridproj=proj.Proj(str(projstring))\\n hasproj=1\\n except:\\n hasproj=0\\n\\n # Check if lat, lon spacing is uniform\\n dx1=np.abs(lonr[0,1]-lonr[0,0])\\n dx2=np.abs(lonr[0,-1]-lonr[0,-2])\\n n=int(np.round(lonr.shape[1]/2))\\n dx3=np.abs(lonr[0,n]-lonr[0,n-1])\\n\\n dy1=np.abs(latr[1,0]-latr[0,0])\\n dy2=np.abs(latr[-1,0]-latr[-2,0])\\n n=int(np.round(latr.shape[0]/2))\\n dy3=np.abs(latr[n,0]-latr[n-1,0])\\n\\n if ( (dx1 == dx2) & (dx1==dx3) & (dx2==dx3) & (dy1 == dy2) & (dy1==dy3) & (dy2==dy3) ):\\n cartesian=1\\n gridproj=proj.Proj(\\\"+proj=latlong +datum=WGS84\\\")\\n \\n\\n \\n if hasproj:\\n dx=xr[1]-xr[0]\\n dy=yr[1]-yr[0]\\n [x,y]=gridproj(lons,lats)\\n ipos=(x-xr[0])/dx\\n jpos=(y-yr[0])/dy\\n\\n elif cartesian:\\n [x1,y1]=gridproj(lonr[0,0],latr[0,0])\\n [x2,y2]=gridproj(lonr[0,1],latr[0,1])\\n dx=x2-x1\\n [x2,y2]=gridproj(lonr[1,0],latr[1,0])\\n dy=y2-y1\\n [x,y]=gridproj(lons,lats)\\n [x0,y0]=gridproj(lonr[0,0],latr[0,0])\\n\\n ipos=(x-x0)/dx\\n jpos=(y-y0)/dy\\n\\n else:\\n x=np.linspace(0,lonr.shape[1]-1,lonr.shape[1])\\n y=np.linspace(0,lonr.shape[0]-1,lonr.shape[0])\\n xi=np.zeros_like(lonr); yi=np.zeros([lonr.shape[1],lonr.shape[0]])\\n xi[:,:]=x; yi[:,:]=y; yi=np.swapaxes(yi,1,0)\\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),xi.flatten(),(lons,lats))\\n ipos=zi\\n zi=scipy.interpolate.griddata((lonr.flatten(),latr.flatten()),yi.flatten(),(lons,lats))\\n jpos=zi\\n \\n if 'ind' in locals():\\n oipos=np.ones(IN.shape)*-999.; ojpos=np.ones(IN.shape)*-999.\\n oipos[ind]=ipos; ojpos[ind]=jpos\\n else:\\n oipos=ipos\\n ojpos=jpos\\n if not IN:\\n oipos = np.array([-999.])\\n ojpos = np.array([-999.])\\n gfh.close()\\n return oipos,ojpos\",\n \"def projection(self):\\n pass\",\n \"def projection(self):\\n return [row[2:-2] for row in self[2:-2]]\",\n \"def get_params_proj(ima, xform = \\\"xform.projection\\\"):\\n\\tt = ima.get_attr(xform)\\n\\td = t.get_params(\\\"spider\\\")\\n\\treturn d[\\\"phi\\\"],d[\\\"theta\\\"],d[\\\"psi\\\"],-d[\\\"tx\\\"],-d[\\\"ty\\\"]\",\n \"def get_population_by_race_columns():\\n return {\\n 'DP05_0070E': 'Population (Total)',\\n 'DP05_0071E': 'Population (Hispanic or Latino)',\\n 'DP05_0077E': 'Population (White alone, Non-Hispanic)',\\n 'DP05_0078E': 'Population (Black or African American alone, Non-Hispanic)',\\n 'DP05_0080E': 'Population (Asian alone, Non-Hispanic)',\\n\\n # These will be grouped into an \\\"Other\\\" category\\n 'DP05_0079E': 'Population (American Indian and Alaska Native alone, Non-Hispanic)',\\n 'DP05_0081E': 'Population (Native Hawaiian and Other Pacific Islander alone, Non-Hispanic)',\\n 'DP05_0082E': 'Population (Some other race alone, Non-Hispanic)',\\n 'DP05_0083E': 'Population (Two or more races, Non-Hispanic)'\\n }\",\n \"def Projection(W, TYPE_PROJ = proj_l11ball, ETA = 100, AXIS = 0, ETA_STAR = 100, device = \\\"cpu\\\" ): \\n \\n #global TYPE_PROJ, ETA, ETA_STAR, AXIS, device \\n if TYPE_PROJ == 'No_proj':\\n W_new = W\\n if (TYPE_PROJ == proj_l1ball or TYPE_PROJ == proj_l11ball or TYPE_PROJ == proj_l11ball_line ):\\n W_new = TYPE_PROJ(W, ETA, device)\\n if TYPE_PROJ == proj_l21ball or TYPE_PROJ == proj_l12ball:\\n W_new = TYPE_PROJ(W, ETA, AXIS, device = device)\\n if TYPE_PROJ == proj_nuclear:\\n W_new = TYPE_PROJ(W, ETA_STAR, device=device)\\n return W_new\",\n \"def Couple(self, *args):\\n return _BRepAlgo.BRepAlgo_NormalProjection_Couple(self, *args)\",\n \"def get_projection(attrs):\\n df = load_df()\\n\\n X = get_all_vectors(df, attrs)\\n logger.info('- Data shape original: {}'.format(X.shape))\\n\\n X = X if isinstance(X, np.ndarray) else X.toarray()\\n X = dimension_reduction(X, attrs['decomposition'], attrs['distanceMetric'])\\n return X, df\",\n \"def combine_all_populations(folder: str,\\n max_v: int = None,\\n neat: bool = False,\\n neat_gru: bool = False,\\n neat_lstm: bool = False,\\n neat_sru: bool = False,\\n neat_sru_s: bool = False,\\n ):\\n # Collect all the populations\\n populations = []\\n if neat: populations.append(D_NEAT)\\n if neat_gru: populations.append(D_NEAT_GRU)\\n if neat_lstm: populations.append(D_NEAT_LSTM)\\n if neat_sru: populations.append(D_NEAT_SRU)\\n if neat_sru_s: populations.append(D_NEAT_SRU_S)\\n if len(populations) == 0: return\\n \\n # Collect all the measure options\\n OPTIONS = ['distance', 'finished', 'fitness', 'score', 'time', 'training']\\n # OPTIONS = ['fitness']\\n \\n # Go over all possibilities\\n print(f\\\"\\\\n===> COMBINING POPULATIONS OF FOLDER {folder} <===\\\")\\n path = f\\\"population_backup/storage/{folder}/\\\"\\n path_images = get_subfolder(path, 'images')\\n for option in OPTIONS:\\n plt.figure(figsize=(8, 2.5))\\n max_data = 0\\n max_gen = 0\\n for pop in populations:\\n # Load the dictionary\\n d = load_dict(f\\\"{path}{pop}/evaluation/{option}\\\")\\n size = len(list(d.values())[0])\\n if max_v: assert size == max_v\\n \\n # Prepare the data containers\\n q1 = []\\n q2 = [] # Median\\n q3 = []\\n idx_q1 = int(round(1 / 4 * size))\\n idx_q2 = int(round(2 / 4 * size))\\n idx_q3 = int(round(3 / 4 * size))\\n \\n # Loop over each iteration\\n x = sorted([int(k) for k in d.keys()])\\n for g in x:\\n if g > max_gen: max_gen = g\\n lst = sorted(d[str(g)]) # Sort values from low to high\\n q1.append(lst[idx_q1])\\n q2.append(lst[idx_q2])\\n q3.append(lst[idx_q3])\\n \\n # Plot the results\\n plt.plot(x, q1, color=COLORS[pop], linestyle=\\\":\\\", linewidth=.5)\\n plt.plot(x, q3, color=COLORS[pop], linestyle=\\\":\\\", linewidth=.5)\\n plt.plot(x, q2, color=COLORS[pop], linestyle=\\\"-\\\", linewidth=2, label=pop)\\n plt.fill_between(x, q1, q3, color=COLORS[pop], alpha=0.2)\\n \\n # Update the max-counter\\n if max(q3) > max_data: max_data = max(q3)\\n \\n # Finalize the figure\\n leg = plt.legend(loc='upper center',\\n bbox_to_anchor=(0.5, 1.25),\\n fancybox=True,\\n fontsize=10,\\n ncol=len(populations))\\n for line in leg.get_lines():\\n line.set_linewidth(4.0)\\n # plt.xticks([i * 100 for i in range(11)]) # TODO\\n plt.xlabel(\\\"generation\\\")\\n plt.xlim(0, max_gen)\\n # plt.yticks([i for i in range(7)]) # TODO\\n plt.ylabel(option)\\n plt.ylim(0, max(max_data * 1.05, 1.05))\\n # plt.ylim(0, 6) # TODO\\n plt.grid()\\n plt.tight_layout()\\n plt.savefig(f\\\"{path_images}comb_{option}.png\\\", bbox_inches='tight', pad_inches=0.02, dpi=500)\\n # plt.savefig(f\\\"{path_images}comb_{option}.eps\\\", format=\\\"eps\\\", bbox_inches='tight', pad_inches=0.02)\\n # plt.show()\\n plt.close()\",\n \"def interactive_grid(mols, *args, molsPerRow=5, **kwargs):\\n \\n import mols2grid\\n \\n return mols2grid.display(mols, *args, n_cols=molsPerRow, **kwargs)\",\n \"def get_personnel():\\r\\n if len(exe) == 0:\\r\\n print(\\\"There are no executives\\\")\\r\\n else:\\r\\n for i in exe:\\r\\n print(str(i))\",\n \"def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\\n\\n lat_grid = np.linspace(latS, latN, latlen)\\n lon_grid = np.linspace(lonW, lonE, lonlen)\\n\\n return lat_grid,lon_grid\",\n \"def get_grid_data(grid):\\n indir = '/home/ivan/Tools/scrip/mapping/grids'\\n infile = os.path.join(indir, grid + '.nc')\\n fp = Nio.open_file(infile,'r')\\n nlon, nlat = fp.variables['grid_dims'][:]\\n tlat = fp.variables['grid_center_lat'][:]\\n tlon = fp.variables['grid_center_lon'][:]\\n fp.close()\\n tlat = N.reshape(tlat,(nlat,nlon))[:,0]\\n tlon = N.reshape(tlon,(nlat,nlon))[0,:]\\n return nlon, nlat, tlon, tlat\",\n \"def koopman_prob(data, observables, ncp):\\n def _wrapper(func, args):\\n \\\"\\\"\\\"\\n Wrapper function to be able to call the function `func` with\\n arguments inside a list.\\n \\\"\\\"\\\"\\n return func(*args)\\n\\n # Structure data as we want to\\n data = {'x1': data[0,:], 'x2': data[1,:]}\\n\\n # Extract interesting simulation results\\n snapshots = np.zeros((len(observables),ncp+1))\\n for i, obs in enumerate(observables):\\n syms = obs.free_symbols # Get args in this observable\\n states = [sym.name for sym in list(syms)] # Get the names of the args, i.e. our states\\n f = lambdify(syms, obs, 'numpy') # Vectorize the observable function\\n values = [data[state] for state in states] # Get simulation result for each state\\n val = _wrapper(f, values) # Computes g_i(x)\\n snapshots[i,:] = val\\n\\n return snapshots\",\n \"def genPopulation(self):\\r\\n self.population_list = []\\r\\n for i in xrange(0, self.pop_size):\\r\\n individual = bitarray(self.indv_size)\\r\\n # Loop for randomizing the 'individual' string.\\r\\n for j in xrange(0, self.board_size):\\r\\n vert_pos = random.randint(0, self.board_size-1)\\r\\n vert_pos_bitnum = toBitArray(vert_pos, self.pos_bits_size)\\r\\n # print \\\"\\\\t\\\\t\\\", j, vert_pos_bitnum, vert_pos\\r\\n for k in range(0, self.pos_bits_size):\\r\\n individual[j * self.pos_bits_size + k] = vert_pos_bitnum[k]\\r\\n self.population_list.append(individual)\\r\\n # print \\\"\\\\t\\\", i, individual\\r\",\n \"def get_genes_and_gpr(model,gene_outfile,gpr_outfile):\\n model_dict = model_to_dict(model, sort=False)\\n genes = pd.DataFrame(model_dict['genes']).set_index(['id'])\\n genes.to_csv(gene_outfile)\\n all_gpr = pd.DataFrame(model_dict['reactions']).set_index(['id'])\\n all_gpr.to_csv(gpr_outfile)\\n return [genes, all_gpr]\",\n \"def read_population_assignation(namefile):\\n db = shelve.open(namefile)\\n hashes = db['hashes']\\n key_firms = db['nif']\\n year = db['year']\\n population_value = db['population']\\n methodvalues = db['methodvalues']\\n db.close()\\n return hashes, key_firms, year, population_value, methodvalues\",\n \"def reproduce(population:list):\\n new_gen = []\\n probs = []\\n for p in population:\\n probs.append(p[3])\\n while len(new_gen) != len(probs):\\n parents = selection(probs)\\n son,eval_son,daughter,eval_daughter = xo(population[parents[0]][0],population[parents[0]][1], population[parents[1]][0],population[parents[1]][1],2)\\n new_gen.append([son,eval_son])\\n new_gen.append([daughter,eval_daughter])\\n # mutation\\n # lets say 5% of the population gets mutated\\n how_many_to_mutate = int(NUM_OF_CHROMOZOMS * (1/100))\\n t = [i for i in range(NUM_OF_CHROMOZOMS)]\\n # choose percent of the population randomly, uniformly\\n indices_to_mutate = choice(t, how_many_to_mutate, replace=False)\\n for i in range(len(indices_to_mutate)):\\n mutate(new_gen[indices_to_mutate[i]])\\n\\n evaluateAll(new_gen)\\n return new_gen\",\n \"def simple_projections(self, to_negative=True):\\n assert to_negative == True # Not implemented otherwise!!!!!\\n res = self.alpha().zip(self.projection, self.alphacheck())\\n # Should this use rename to set a nice name for this family?\\n res.rename(\\\"pi\\\")\\n return res\",\n \"def create_populations(self, nb:int=1):\\n self.populations.append(self.config.create(self.pop_size))\",\n \"def project_parensemble(self,par_file=None,nsing=None,\\n inplace=True,enforce_bounds='reset'):\\n assert self.jco is not None,\\\"MonteCarlo.project_parensemble()\\\" +\\\\\\n \\\"requires a jacobian attribute\\\"\\n if par_file is not None:\\n assert os.path.exists(par_file),\\\"monte_carlo.draw() error: par_file not found:\\\" +\\\\\\n par_file\\n self.parensemble.pst.parrep(par_file)\\n\\n # project the ensemble\\n self.log(\\\"projecting parameter ensemble\\\")\\n en = self.parensemble.project(self.get_null_proj(nsing),inplace=inplace,log=self.log)\\n self.log(\\\"projecting parameter ensemble\\\")\\n return en\",\n \"def gotop(net, namet, go_file, goa_file, n=100, **ka):\\n\\timport numpy as np\\n\\tnt = len(namet)\\n\\tif net.shape != (nt, nt) or nt <= 1:\\n\\t\\traise ValueError('Wrong shape for net or namet.')\\n\\tif n <= 1 or n >= nt:\\n\\t\\traise ValueError(\\n\\t\\t\\t'Number of principal genes must be from 1 to the number of all genes (exclusive).'\\n\\t\\t)\\n\\n\\t# Find principal genes\\n\\tt1 = net.sum(axis=1)\\n\\tt2 = t1[t1.argsort()[::-1][n]]\\n\\n\\tif t2 == 0:\\n\\t\\traise RuntimeError('Not enough principal genes that have co-expression')\\n\\tt2 = np.nonzero(t1 >= t2)[0]\\n\\tassert len(t2) >= n\\n\\tassert len(t2) < nt\\n\\tt1 = [str(x) for x in namet[t2]]\\n\\tt2 = [str(x) for x in namet]\\n\\treturn tuple([t1] + list(goe(t1, go_file, goa_file, bg=t2, **ka)))\",\n \"def test_choropleth_pass():\\n m = view(world, column=\\\"pop_est\\\")\",\n \"def __call__(self, *columns, test_size, random_state=42):\\n # print(quad_size, columns) if print is to stay, then use logging\\n w = self.quad_size\\n dataset = columns[1]\\n print(self.quad_size)\\n if w == 0:\\n train_ids, test_ids = train_test_split([i for i in range(len(dataset))], test_size=test_size, random_state=random_state)\\n else:\\n r = np.random.RandomState(random_state)\\n d_lon = r.random_sample()\\n r_lat = np.random.RandomState(random_state + 10)\\n d_lat = r_lat.random_sample()\\n\\n proj = OrderedDict()\\n print('ici')\\n for i, coor in enumerate(dataset):\\n lon, lat = self._project(coor[0], coor[1])\\n proj_lon = (lon + d_lon * w) // w\\n proj_lat = (lat + d_lat * w) // w\\n if (proj_lon, proj_lat) in proj:\\n proj[(proj_lon, proj_lat)].append(i)\\n else:\\n proj[(proj_lon, proj_lat)] = [i]\\n\\n train_map, test_map = train_test_split(list(proj.keys()), test_size=test_size, random_state=random_state)\\n\\n train_ids = [i for quadra in train_map for i in proj[quadra]]\\n test_ids = [i for quadra in test_map for i in proj[quadra]]\\n # creating output\\n r = []\\n for col in columns:\\n r.extend((col[train_ids], col[test_ids]))\\n return r\",\n \"def jupiteNetwork(): \\n \\n # Build a graph for large clos topo\\n tor_cut, aggr_cut, spine_cut = 512, 256, 256\\n #2048, 4096, 4096 #32*4*2, 64*2, 16*2\\n switches, edges = tp.jupiter_topo(\\n tor_cut=tor_cut, aggr_cut=aggr_cut, spine_cut=spine_cut\\n )\\n \\n G = build_graph(edges)\\n external_edges = []\\n for node in G.nodes():\\n if 'sh' in node:\\n G.add_edge(node, 'e1')\\n \\n \\\"\\\"\\\"\\n paths = list(nx.all_shortest_paths(G, 'tor385', 'tor1'))\\n #print(paths)\\n #eee\\n paths = list(nx.all_shortest_paths(G, 'tor129', 'tor257'))\\n #print(paths)\\n paths = list(nx.all_shortest_paths(G, 'tor257', 'tor385'))\\n #print(paths)\\n #eee\\n \\\"\\\"\\\"\\n switch_nodes, hnodes, tors, anodes, snodes = tp.getJupiternNodes(\\n tors_num=tor_cut, aggr_num=aggr_cut, spine_num=spine_cut\\n )\\n print('**** is_connected(G)', nx.is_connected(G))\\n print('**** number of components', nx.number_connected_components(G))\\n \\n tors = tors[0:512] + ['e1']\\n\\n # Get the routing path of all nodes\\n table_file_name = '../outputs/jupiter_routing_table_anodes_cut4.txt'\\n\\n if((os.path.isfile(table_file_name)) == False):\\n table = all_routing(G, tors, table_file_name)\\n else:\\n json_data = open(table_file_name).read()\\n table = json.loads(json_data)\\n \\n seeds, polys = cf.get_seeds_table_jupiter(switch_nodes + ['e1']) #\\n \\n return G, tors, edges, table, seeds, polys, anodes\",\n \"def read_population() -> pd.DataFrame:\\n\\n pop_df = pd.read_csv(\\\"data/API_SP.POP.TOTL_DS2_en_csv_v2_988606.csv\\\",\\n header=2, usecols=[0,62], names=[\\\"Country\\\", \\\"Population\\\"])\\n\\n index = pop_df[pop_df[\\\"Country\\\"]==\\\"Iran, Islamic Rep.\\\"].index.values[0]\\n pop_df.loc[index, \\\"Country\\\"] = \\\"Iran\\\"\\n index = pop_df[pop_df[\\\"Country\\\"] == \\\"United States\\\"].index.values[0]\\n pop_df.loc[index, \\\"Country\\\"] = \\\"US\\\"\\n index = pop_df[pop_df[\\\"Country\\\"] == \\\"Russian Federation\\\"].index.values[0]\\n pop_df.loc[index, \\\"Country\\\"] = \\\"Russia\\\"\\n\\n pop_df = pop_df.dropna()\\n\\n return pop_df\",\n \"def explore(self, T, *args):\\n nparams = T.param.size\\n if hasattr(T, 'copy'):\\n T = T.copy()\\n deltas = [[0] for i in range(nparams)]\\n for a in args:\\n deltas[a[0]] = a[1]\\n grids = np.mgrid[[slice(0, len(d)) for d in deltas]]\\n ntrials = np.prod(grids.shape[1:])\\n Deltas = [np.asarray(deltas[i])[grids[i, :]].ravel()\\\\\\n for i in range(nparams)]\\n simis = np.zeros(ntrials)\\n params = np.zeros([nparams, ntrials])\\n\\n Tv = ChainTransform(T, pre=self._from_affine,\\n post=self._to_inv_affine)\\n param0 = Tv.param\\n for i in range(ntrials):\\n param = param0 + np.array([D[i] for D in Deltas])\\n Tv.param = param\\n simis[i] = self._eval(Tv)\\n params[:, i] = param\\n\\n return simis, params\",\n \"def create_tables(*args):\\n import pandas\\n tables = {}\\n for locus in args[0].index:\\n tables[locus] = get_table(*args, locus)\\n return tables\",\n \"def protons ( self ) :\\n from GaudiConfUtils.ConfigurableGenerators import FilterDesktop\\n ## \\n if self['NOPIDHADRONS'] :\\n from StandardParticles import StdAllNoPIDsProtons as inpts\\n protoncut = self['ProtonCut']\\n else :\\n from StandardParticles import StdAllLooseANNProtons as inpts \\n protoncut = \\\"(%s)&(%s)\\\" % ( self['ProtonCut'] , self['ProtonPIDCut'] ) \\n #\\n ##\\n return self.make_selection (\\n 'Proton' ,\\n FilterDesktop ,\\n [ inpts ] ,\\n Code = protoncut ,\\n )\",\n \"def select_random(pops, fit_pop):\\n random_index_d = {}\\n random_fit_inds_d = {}\\n random_pop_inds_d = {}\\n for i in range(n_islands):\\n random_index_d[i] = random.sample(range(npop), n_migrate)\\n random_fit_inds_d[i] = list(map(lambda x: fit_pop[i][x], random_index_d[i]))\\n random_pop_inds_d[i] = list(map(lambda y: pops[i][y], random_index_d[i]))\\n\\n return random_index_d, random_fit_inds_d, random_pop_inds_d\",\n \"def _read_pops(self, sheet) -> None:\\n\\n # TODO - can modify _read_pops() and _write_pops() if there are more population attributes\\n tables = read_tables(sheet)[0]\\n assert len(tables) == 1, \\\"Population Definitions page should only contain one table\\\"\\n\\n self.pops = sc.odict()\\n assert cell_get_string(tables[0][0][0]).lower() == \\\"abbreviation\\\"\\n assert cell_get_string(tables[0][0][1]).lower() == \\\"full name\\\"\\n\\n # If pop typ column exists, check the heading is correct\\n if len(tables[0][0]) > 2:\\n assert cell_get_string(tables[0][0][2]).lower() == \\\"population type\\\"\\n\\n for row in tables[0][1:]:\\n\\n pop_name = cell_get_string(row[0])\\n assert len(pop_name) > 1, 'Population code name (abbreviation) \\\"%s\\\" is not valid - it must be at least two characters long' % (pop_name)\\n\\n label = cell_get_string(row[1])\\n assert len(label) > 1, 'Population full name \\\"%s\\\" is not valid - it must be at least two characters long' % (label)\\n\\n if pop_name.lower() in FS.RESERVED_KEYWORDS:\\n raise Exception('Population name \\\"%s\\\" is a reserved keyword' % (pop_name.lower()))\\n\\n poptype = None\\n if len(row) > 2 and row[2].value is not None:\\n poptype = cell_get_string(row[2])\\n\\n self.pops[pop_name] = {\\\"label\\\": label, \\\"type\\\": poptype}\",\n \"def getProjectionMatchingArgs(self, iterN):\\n \\n args = ' --Ri %(innerRadius)s'\\n args += ' --Ro %(outerRadius)s --max_shift %(maxShift)s --search5d_shift %(search5dShift)s'\\n args += ' --search5d_step %(search5dStep)s --append'\\n \\n params = {\\n 'innerRadius' : self._innerRadius[iterN],\\n 'outerRadius' : self._outerRadius[iterN],\\n 'maxShift' : self._maxChangeOffset[iterN],\\n 'search5dShift' : self._search5DShift[iterN],\\n 'search5dStep' : self._search5DStep[iterN],\\n }\\n \\n if self.doScale:\\n args += ' --scale %(scaleStep)s %(scaleNumberOfSteps)s'\\n params['scaleStep'] = self._scaleStep[iterN]\\n params['scaleNumberOfSteps'] = self._scaleNumberOfSteps[iterN]\\n \\n if self.doCTFCorrection and self._referenceIsCtfCorrected[iterN]:\\n args += ' --pad %(pad)s'\\n params['pad'] = self.paddingFactor.get()\\n\\n if self.numberOfMpi > 1:\\n params['mpiJobSize'] = self.mpiJobSize.get()\\n args += ' --mpi_job_size %(mpiJobSize)s'\\n \\n return args % params\",\n \"def main():\\n national_university_table()\",\n \"def calc_population(self, vars_int, vars_float, problem_results, components=None):\\n n_pop = problem_results[\\\"n_pop\\\"].values\\n n_states = problem_results[\\\"n_org_states\\\"].values\\n n_turbines = problem_results.dims[FC.TURBINE]\\n data = (\\n problem_results[self.variable]\\n .to_numpy()\\n .reshape(n_pop, n_states, n_turbines)\\n )\\n data = xr.DataArray(data, dims=(FC.POP, FC.STATE, FC.TURBINE))\\n\\n if self.n_sel_turbines < self.farm.n_turbines:\\n data = data[:, self.sel_turbines]\\n\\n return self._contract(data / self.scale).to_numpy()[:, None]\",\n \"def get_station_projects(stn_df, proj_df, engine): \\n # Get stn IDs\\n assert len(stn_df) > 0, 'ERROR: Please select at least one station.'\\n stn_df['station_id'].drop_duplicates(inplace=True)\\n stn_ids = stn_df['station_id'].values.astype(int).tolist()\\n\\n # Get proj IDs\\n assert len(proj_df) > 0, 'ERROR: At least one project must already be selected.'\\n proj_df['project_id'].drop_duplicates(inplace=True)\\n proj_ids = proj_df['project_id'].values.astype(int).tolist() \\n\\n # Number from 0 to n_stns\\n bind_stns = ','.join(':%d' % i for i in range(len(stn_ids)))\\n \\n # Number from n_stns to (n_stns+n_projs)\\n bind_prjs = ','.join(':%d' % i for i in range(len(stn_ids), \\n len(stn_ids) + len(proj_ids)))\\n \\n # Query db\\n sql = (\\\"SELECT a.project_id, \\\"\\n \\\" b.o_number, \\\"\\n \\\" a.project_name, \\\"\\n \\\" a.project_description \\\"\\n \\\"FROM nivadatabase.projects a, \\\"\\n \\\" nivadatabase.projects_o_numbers b \\\"\\n \\\"WHERE a.project_id = b.project_id \\\"\\n \\\"AND a.project_id IN \\\"\\n \\\" (SELECT project_id \\\"\\n \\\" FROM nivadatabase.projects_stations \\\"\\n \\\" WHERE station_id IN (%s) \\\"\\n \\\" AND project_id IN (%s) \\\"\\n \\\" ) \\\"\\n \\\"ORDER BY a.project_id\\\" % (bind_stns, bind_prjs))\\n\\n bind_dict = {'%d' % idx:item for idx, item in enumerate(stn_ids)}\\n bind_prj_dict = {'%d' % (idx + len(stn_ids)):item \\n for idx, item in enumerate(proj_ids)}\\n bind_dict.update(bind_prj_dict) \\n df = pd.read_sql(sql, params=bind_dict, con=engine)\\n \\n return df\",\n \"def compound_generator(pop):\\n gen = -1\\n while True:\\n ngen = pop.dvars().gen\\n if gen != ngen:\\n # At the beginning of a generation, extract the\\n # sex-specific subpopulations from a parental\\n # population. The sex-specific subpopulations are used\\n # throughout mating events in one generation.\\n gen = ngen\\n males = pop.extractSubPops(subPops=[(0, 0)])\\n herms = pop.extractSubPops(subPops=[(0, 1)])\\n nmale = males.popSize()\\n nherm = herms.popSize()\\n\\n if runif() < sstar: # uniparental\\n yield herms.individual(rint(nherm))\\n else: # biparental\\n yield [males.individual(rint(nmale)), herms.individual(rint(nherm))]\",\n \"def init_population(pop_number, variables, domains):\\n population = []\\n for i in range(pop_number):\\n new_individual = {}\\n for v in variables:\\n # randomly choose an assignment from this variable's domain\\n ind = np.random.choice(len(domains[v]))\\n new_individual[v] = domains[v][ind]\\n population.append(OrderedDict(sorted(new_individual.items())) )\\n\\n return population\",\n \"def test_population_movements_with_compilation(self):\\n self._pystepx = PySTEPXIsland(nb_islands=4, init_script=init_script)\\n print self._pystepx._rc[0]['gp_engine']\\n self._pystepx._rc[0].execute('elems = gp_engine.get_evolver().select_and_remove_individuals(0.01)',\\n block=True)\\n print self._pystepx._rc[0]['elems']\",\n \"def find_population(self, x, pops):\\n M = sum([len(pops[pop]) for pop in pops])\\n N = len(x)\\n\\n survival_values = []\\n intersections = []\\n lens = []\\n\\n rsv, rpop, rk = 2, -1, 0\\n\\n for pop in pops:\\n n = len(pops[pop])\\n intersec = np.intersect1d(x, pops[pop])\\n k = len(intersec)\\n sv = hypergeom.sf(k-1, M=M, n=n, N=N) if k > 0 else 1\\n\\n survival_values.append(sv)\\n intersections.append(intersec)\\n lens.append(len(pops[pop]))\\n\\n if sv <= rsv or (rsv == 2 and k > 0):\\n rsv, rpop, rk = sv, pop, k\\n\\n all_pops = {'svs': np.array(survival_values),\\n 'intersecs': np.array(intersections),\\n 'lens': np.array(lens)}\\n\\n if rk == 0: # in case of no intersection, return -1\\n return \\\"None\\\", 1, np.array([]), 0, all_pops\\n else:\\n return rpop, rsv, np.intersect1d(x, pops[rpop]), len(pops[rpop]), all_pops\",\n \"def gatherData(data,neat,gen,iter_i,hyp,savePop=False):\\n data.gatherData(neat.pop, neat.species)\\n\\n if savePop is True: # Get a sample pop to play with in notebooks\\n global fileName\\n pref = output_dir + '/iter_{}'.format(iter_i) + '/gen_' + str(gen).zfill(4)\\n import pickle\\n with open(pref+'.obj', 'wb') as fp:\\n pickle.dump(neat.pop,fp)\\n\\n return data\",\n \"def get_projection_params(fname):\\n # Read strings from the region file\\n with open(fname, 'r') as f:\\n lines = f.readlines()\\n wcs = lines[2][:-1] # Coordinate system TODO bad variable name\\n if lines[0] != '# Region file format: DS9 version 4.1\\\\n':\\n print 'Warning: potentially invalid region file!'\\n print 'First line was: ' + lines[0]\\n if wcs != 'fk5':\\n raise Exception('Regions must be in sky (fk5) coordinates; got ' +\\n wcs + 'instead')\\n\\n # Manipulate each string and save to list\\n lines = filter(lambda x: '# projection' in x, lines[3:])\\n projspecs = []\\n for ln in lines:\\n lnsplit = ln[2:-1].split(')') # Remove leading '#', trailing '\\\\n'\\n if lnsplit[1] == '':\\n r = lnsplit[0] + ')' # No optional arguments\\n else:\\n r = lnsplit[0] + ') #' + lnsplit[1] # Add octothorpe\\n projspecs.append('%s; %s' % (wcs, r))\\n\\n return projspecs\",\n \"def create_grid_queries(all_data_dicts, smod=2):\\n rf_width_y, rf_width_x = [], []\\n rf_y, rf_x = [], []\\n for dat in all_data_dicts:\\n rf_width_y += [dat['on_width_y']]\\n rf_width_x += [dat['on_width_x']]\\n cre_line = dat['cre_line']\\n structure = dat['structure']\\n rf_y += [dat['on_center_y']]\\n rf_x += [dat['on_center_x']]\\n\\n # Get 95th percentile x and y width\\n y_width = int(np.ceil(np.percentile(rf_width_y, 95)))\\n x_width = int(np.ceil(np.percentile(rf_width_x, 95)))\\n\\n # Stride of the neuron bins\\n y_stride = int(y_width/smod)\\n x_stride = int(x_width/smod)\\n\\n # Create queries that have width and height by the receptive field size\\n y_limit = int(np.floor(np.max(rf_y)))\\n x_limit = int(np.floor(np.max(rf_x)))\\n queries = []\\n for x1 in (range(0, x_limit, x_stride)):\\n for y1 in range(0, y_limit, y_stride):\\n\\n # Add width to each x1 as long as it's not more than x_max\\n x2 = x1 + x_width\\n # Add width to each y1 as long as it's not more than y_max\\n y2 = y1 + y_width\\n\\n # add new coordinate range to queries\\n queries += [[{\\n 'rf_coordinate_range': { # Get all cells\\n 'x_min': x1,\\n 'x_max': x2,\\n 'y_min': y1,\\n 'y_max': y2,\\n },\\n 'cre_line': cre_line,\\n 'structure': structure}]]\\n return queries, max([x_width, y_width])\",\n \"def main():\\n population = 1000\\n print(\\\"Welcome to the Gopher Population Simulator!\\\")\\n print(\\\"Starting population: {0}\\\".format(population))\\n print(\\\"Year 1\\\\n\\\")\\n for year in range(2, YEARS + 1, 1):\\n population_print(population, year)\",\n \"def getProjections(self): \\n x, y, z = self.XYZCoordinate\\n origin = self.SkeletonPoints[0]\\n self.coorOrigin = origin\\n self.XYProjections = [GeometryToolBox.projected_point(p, origin, x, y) for p in self.SkeletonPoints]\\n self.XZProjections = [GeometryToolBox.projected_point(p, origin, x, z) for p in self.SkeletonPoints]\",\n \"def get_xProj(self, iproj):\\n return self.xProj[iproj]\",\n \"def eval_genomes(population, conf):\\n for (_, g) in population:\\n eval_genome(g, conf)\",\n \"def displayPathtoPrincess(n, grid):\\n solution = SavePrincess(grid)\\n print \\\"{0}\\\".format(solution)\",\n \"def get_parameter_grid(model_name, momentum=False, size=10, randomize=True, seed=1234321):\\n try:\\n param_space = model_param_space[model_name]\\n except KeyError:\\n raise ValueError('Parameter space for model {} is not defined.'.format(model_name))\\n values_grid = pd.DataFrame.from_records(itertools.product(*param_space.values()), columns=param_space.keys())\\n if momentum:\\n values_grid = add_momentum(values_grid, 'once', seed=seed)\\n if randomize:\\n values_grid = values_grid.sample(frac=1, random_state=seed).reset_index(drop=True)\\n return values_grid.head(size) # Limit number of experiments\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5612893","0.5285766","0.5185361","0.5045113","0.5007588","0.49609387","0.49419475","0.48437467","0.48161486","0.48034397","0.47943878","0.4792616","0.4761036","0.4739973","0.4637608","0.45978764","0.45735255","0.45684016","0.45425737","0.45364887","0.45320395","0.45264566","0.45124856","0.45041758","0.44981605","0.44906053","0.4479938","0.44782987","0.4456257","0.44456545","0.44324908","0.44266894","0.4424818","0.44223246","0.44196865","0.44186735","0.44119537","0.43964222","0.43777475","0.43776992","0.43635166","0.43614984","0.43589276","0.43564114","0.43455014","0.43442416","0.43375748","0.43263614","0.43096215","0.4307493","0.43073845","0.4307001","0.4301945","0.42973208","0.4294476","0.4293759","0.42921928","0.42902073","0.4286636","0.4283694","0.42819956","0.42697796","0.4254155","0.42522398","0.42449856","0.42429557","0.4240992","0.42349797","0.42333522","0.4232818","0.42304507","0.42298192","0.42285344","0.4228341","0.42245778","0.42245114","0.4220269","0.4220006","0.4219922","0.42134938","0.4206386","0.4202413","0.42022792","0.42009097","0.41960597","0.4196056","0.41859996","0.41858888","0.4185715","0.4185472","0.41835934","0.41808888","0.41730177","0.41683337","0.41676012","0.41621724","0.4155451","0.41498807","0.41434723","0.41406462"],"string":"[\n \"0.5612893\",\n \"0.5285766\",\n \"0.5185361\",\n \"0.5045113\",\n \"0.5007588\",\n \"0.49609387\",\n \"0.49419475\",\n \"0.48437467\",\n \"0.48161486\",\n \"0.48034397\",\n \"0.47943878\",\n \"0.4792616\",\n \"0.4761036\",\n \"0.4739973\",\n \"0.4637608\",\n \"0.45978764\",\n \"0.45735255\",\n \"0.45684016\",\n \"0.45425737\",\n \"0.45364887\",\n \"0.45320395\",\n \"0.45264566\",\n \"0.45124856\",\n \"0.45041758\",\n \"0.44981605\",\n \"0.44906053\",\n \"0.4479938\",\n \"0.44782987\",\n \"0.4456257\",\n \"0.44456545\",\n \"0.44324908\",\n \"0.44266894\",\n \"0.4424818\",\n \"0.44223246\",\n \"0.44196865\",\n \"0.44186735\",\n \"0.44119537\",\n \"0.43964222\",\n \"0.43777475\",\n \"0.43776992\",\n \"0.43635166\",\n \"0.43614984\",\n \"0.43589276\",\n \"0.43564114\",\n \"0.43455014\",\n \"0.43442416\",\n \"0.43375748\",\n \"0.43263614\",\n \"0.43096215\",\n \"0.4307493\",\n \"0.43073845\",\n \"0.4307001\",\n \"0.4301945\",\n \"0.42973208\",\n \"0.4294476\",\n \"0.4293759\",\n \"0.42921928\",\n \"0.42902073\",\n \"0.4286636\",\n \"0.4283694\",\n \"0.42819956\",\n \"0.42697796\",\n \"0.4254155\",\n \"0.42522398\",\n \"0.42449856\",\n \"0.42429557\",\n \"0.4240992\",\n \"0.42349797\",\n \"0.42333522\",\n \"0.4232818\",\n \"0.42304507\",\n \"0.42298192\",\n \"0.42285344\",\n \"0.4228341\",\n \"0.42245778\",\n \"0.42245114\",\n \"0.4220269\",\n \"0.4220006\",\n \"0.4219922\",\n \"0.42134938\",\n \"0.4206386\",\n \"0.4202413\",\n \"0.42022792\",\n \"0.42009097\",\n \"0.41960597\",\n \"0.4196056\",\n \"0.41859996\",\n \"0.41858888\",\n \"0.4185715\",\n \"0.4185472\",\n \"0.41835934\",\n \"0.41808888\",\n \"0.41730177\",\n \"0.41683337\",\n \"0.41676012\",\n \"0.41621724\",\n \"0.4155451\",\n \"0.41498807\",\n \"0.41434723\",\n \"0.41406462\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5903073"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":203,"numItemsPerPage":100,"numTotalItems":95772,"offset":20300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjM0NjM2OCwianRpIjoiZTlmY2UwZGYtMWFlZC00OTJmLWFjZGUtYWNmNTA4NGI3MDFjIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzNDk5NjgsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.R5xyn057pZafsGwtAaZ2IsxFTKHjwEmMXpnMUQZvDoWE5kKR5nqsf_tlMuXmu5v5P0NHBMpXyCD6ZOVj5e4ZDw","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 |
|---|---|---|---|---|---|---|
Build UPDATE SQL statement. | def sql(self):
if not self._table_names:
raise ValueError('UPDATE requires at least one table')
if not self._values and not self._values_raw:
raise ValueError('UPDATE requires at least one value')
table_refs = [', '.join(self._table_names)]
param_values = []
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_update_sql(self, fieldupdate, condition):\n return \"UPDATE %s SET %s WHERE %s\" % (self.tablename, fieldupdate, condition)",
"def getSQL_update(table, **kwargs):\n kvs = ''\n kvs_where = ''\n for k, v in kwargs.items():\n if k.startswith('where'):\n kvs_where += k[... | [
"0.8178394",
"0.77452815",
"0.74001867",
"0.7187165",
"0.650297",
"0.6500911",
"0.64556026",
"0.63847166",
"0.6344869",
"0.6329195",
"0.61464536",
"0.6131383",
"0.6125805",
"0.6088489",
"0.6056486",
"0.6034534",
"0.6028946",
"0.6023059",
"0.60020906",
"0.59567606",
"0.5950311... | 0.7417059 | 2 |
Reads a table from microsoft sql server and writes the relevant columns into a parquet file. | def import_jdbc_table(spark_config,
uri,
input_table,
input_cols,
output_table,
output_cols,
driver,
data_format,
debug=False):
with get_spa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def basic_table_read_write_parquet():\n numbers = pa.table([\n pa.array(range(1, 6), type=pa.int8()),\n pa.array(range(10, 60, 10), type=pa.int8()),\n pa.array(range(100, 600, 100), type=pa.int16()),\n ], names=['a', 'b', 'c'])\n\n fn = 'numbers.parquet'\n fp = os.path.join(DATA_OU... | [
"0.6704",
"0.66378164",
"0.6461234",
"0.6271172",
"0.6046861",
"0.6026882",
"0.60247236",
"0.59279245",
"0.5834767",
"0.5728407",
"0.5690995",
"0.5673683",
"0.56672233",
"0.5653614",
"0.56086546",
"0.56041235",
"0.5589679",
"0.55699813",
"0.55614984",
"0.5510859",
"0.5490416"... | 0.5255519 | 44 |
Reduce this Dataset's data by applying ``count`` along some dimension(s). | def count(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.count,
dim=dim,
numeric_only=False,
keep_attrs=keep_attrs,
**kwargs,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.count,\n dim=dim,\n keep_attrs=keep_attrs,\n **kwargs,\n )",
"def... | [
"0.730545",
"0.69733924",
"0.69733924",
"0.69529074",
"0.69529074",
"0.6121086",
"0.60577554",
"0.5984994",
"0.5982864",
"0.59388554",
"0.5934392",
"0.5903536",
"0.5890546",
"0.5856696",
"0.5820845",
"0.5794014",
"0.5787277",
"0.5708209",
"0.56682146",
"0.5646369",
"0.5555573... | 0.7285971 | 1 |
Reduce this Dataset's data by applying ``all`` along some dimension(s). | def all(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.array_all,
dim=dim,
numeric_only=False,
keep_attrs=keep_attrs,
**kwargs,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n if (\n flox_available\n and OPTIONS[\"use_flox\"]\n and contains_only_chunked_or_numpy(self._obj)\n ):\n ret... | [
"0.7058243",
"0.7058243",
"0.69317317",
"0.69317317",
"0.68936807",
"0.6847603",
"0.65551496",
"0.65551496",
"0.6485944",
"0.64324665",
"0.64027697",
"0.64027697",
"0.6244525",
"0.62312984",
"0.6125453",
"0.60393447",
"0.59572035",
"0.5945839",
"0.58689076",
"0.5696258",
"0.5... | 0.69636464 | 2 |
Reduce this Dataset's data by applying ``any`` along some dimension(s). | def any(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.array_any,
dim=dim,
numeric_only=False,
keep_attrs=keep_attrs,
**kwargs,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n if (\n flox_available\n and OPTIONS[\"use_flox\"]\n and contains_only_chunked_or_numpy(self._obj)\n ):\n ret... | [
"0.7161406",
"0.7161406",
"0.7086105",
"0.703172",
"0.703172",
"0.70229447",
"0.6403789",
"0.6393615",
"0.6261724",
"0.61942995",
"0.6074665",
"0.59774745",
"0.5968099",
"0.5967931",
"0.59597373",
"0.58590436",
"0.57441306",
"0.57049936",
"0.5693786",
"0.5693786",
"0.5675616"... | 0.7110761 | 2 |
Reduce this Dataset's data by applying ``max`` along some dimension(s). | def max(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.max,
dim=dim,
skipna=skipna,
numeric_only=False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.max, **kwargs)",
"def max(self, axis=None, keepdims=False, out=None):\n return np.maximum.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def max(\n self,\n dim: Dims = None,\n *... | [
"0.7753539",
"0.7408079",
"0.73061585",
"0.71528566",
"0.70420104",
"0.70420104",
"0.6946384",
"0.6946384",
"0.6743711",
"0.66858155",
"0.66754574",
"0.6588934",
"0.6558338",
"0.6365423",
"0.6345032",
"0.6310829",
"0.6250961",
"0.6227401",
"0.6187706",
"0.6186832",
"0.6148529... | 0.7329823 | 2 |
Reduce this Dataset's data by applying ``min`` along some dimension(s). | def min(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.min,
dim=dim,
skipna=skipna,
numeric_only=False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.min, **kwargs)",
"def reduce_min(data, axis=None, keepdims=False):\n\n return reduce_min_max_common.reduce_min_max(data, axis=axis, keepdims=keepdims, method=\"min\")",
"def min(\n self,\n dim: Di... | [
"0.7571916",
"0.7364422",
"0.72700524",
"0.7055405",
"0.7008117",
"0.7008117",
"0.6883447",
"0.6883447",
"0.68764853",
"0.68314165",
"0.6661202",
"0.6513228",
"0.64885235",
"0.6312382",
"0.62034804",
"0.61937124",
"0.61580485",
"0.60934466",
"0.6086458",
"0.60608375",
"0.6029... | 0.7293054 | 2 |
Reduce this Dataset's data by applying ``mean`` along some dimension(s). | def mean(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.mean,
dim=dim,
skipna=skipna,
numeric_only=True,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.mean, **kwargs)",
"def mean(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n ... | [
"0.7127385",
"0.7049797",
"0.6740046",
"0.6740046",
"0.6722186",
"0.6722186",
"0.6714496",
"0.6700629",
"0.6324996",
"0.62950623",
"0.62856495",
"0.6274769",
"0.62702817",
"0.62637585",
"0.62234634",
"0.6204494",
"0.6204494",
"0.6190918",
"0.6122293",
"0.6113007",
"0.6103501"... | 0.70370185 | 2 |
Reduce this Dataset's data by applying ``prod`` along some dimension(s). | def prod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.prod,
dim=dim,
skipna=ski... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prod(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.multiply.reduce(\n self, out=out, axis=axis, keepdims=keepdims, dtype=dtype\n )",
"def prod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | N... | [
"0.7481061",
"0.735098",
"0.714532",
"0.714532",
"0.700226",
"0.700226",
"0.6688766",
"0.65455145",
"0.65137213",
"0.64294696",
"0.6274849",
"0.6176995",
"0.6066634",
"0.59346235",
"0.5929033",
"0.591033",
"0.591033",
"0.591033",
"0.58753616",
"0.5752229",
"0.5747925",
"0.5... | 0.74074686 | 1 |
Reduce this Dataset's data by applying ``sum`` along some dimension(s). | def sum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.sum,
dim=dim,
skipna=skipn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.sum,\n dim=dim,\n ... | [
"0.69223887",
"0.68643904",
"0.68584",
"0.68099666",
"0.6725604",
"0.6725604",
"0.66675615",
"0.6634007",
"0.6546494",
"0.6546494",
"0.6421243",
"0.64142853",
"0.63628495",
"0.63059735",
"0.62661374",
"0.62658197",
"0.6225546",
"0.6212655",
"0.61623865",
"0.6143209",
"0.60457... | 0.70593727 | 0 |
Reduce this Dataset's data by applying ``median`` along some dimension(s). | def median(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.median,
dim=dim,
skipna=skipna,
numeric_only=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_filter(self):\n print \"Median-Filtering...\"\n D = self.D\n x = np.median(np.median(D,axis=1),axis=1)\n for i in xrange(len(x)):\n D[i,:,:] -= x[i]\n self.D = D\n print \"done.\"",
"def median(\n self,\n dim: Dims = None,\n *,... | [
"0.7723946",
"0.73474264",
"0.73474264",
"0.73474264",
"0.67132735",
"0.6709282",
"0.6704458",
"0.6682933",
"0.6635858",
"0.656867",
"0.65672284",
"0.6512514",
"0.64834887",
"0.64834887",
"0.6444135",
"0.63871884",
"0.6383317",
"0.6333734",
"0.62151307",
"0.61960506",
"0.6195... | 0.738869 | 2 |
Reduce this Dataset's data by applying ``cumsum`` along some dimension(s). | def cumsum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.cumsum,
dim=dim,
skipna=skipna,
numeric_only=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n ... | [
"0.7537239",
"0.7537239",
"0.7537239",
"0.67484677",
"0.67069674",
"0.66436154",
"0.63819385",
"0.6350921",
"0.6343282",
"0.62725073",
"0.6268484",
"0.6268484",
"0.6268484",
"0.6262665",
"0.6262446",
"0.62461925",
"0.61838704",
"0.61838704",
"0.61838704",
"0.61028945",
"0.606... | 0.769945 | 2 |
Reduce this Dataset's data by applying ``cumprod`` along some dimension(s). | def cumprod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.cumprod,
dim=dim,
skipna=skipna,
numeric_only=Tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumprod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumprod,\n dim=dim,\n skipna=skipna,\n ... | [
"0.78994447",
"0.78994447",
"0.78994447",
"0.70834005",
"0.7032063",
"0.69815505",
"0.6964613",
"0.6532074",
"0.62200755",
"0.6205164",
"0.62014854",
"0.61457735",
"0.6142508",
"0.6083153",
"0.60304993",
"0.59804726",
"0.59804726",
"0.5861358",
"0.5861358",
"0.5861358",
"0.58... | 0.8054797 | 2 |
Reduce this DataArray's data by applying ``count`` along some dimension(s). | def count(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.count,
dim=dim,
keep_attrs=keep_attrs,
**kwargs,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n if (\n flox_available\n and OPTIONS[\"use_flox\"]\n and contains_only_chunked_or_numpy(self._obj)\n ):\n ... | [
"0.6582146",
"0.6582146",
"0.65379834",
"0.6224404",
"0.6224404",
"0.59004956",
"0.5841828",
"0.5838448",
"0.57762665",
"0.573857",
"0.56812054",
"0.5657385",
"0.55505395",
"0.55487853",
"0.55471367",
"0.55208504",
"0.5506666",
"0.54985136",
"0.5492544",
"0.54757905",
"0.5454... | 0.6898398 | 0 |
Reduce this DataArray's data by applying ``all`` along some dimension(s). | def all(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.array_all,
dim=dim,
keep_attrs=keep_attrs,
**kwargs,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n if (\n flox_available\n and OPTIONS[\"use_flox\"]\n and contains_only_chunked_or_numpy(self._obj)\n ):\n r... | [
"0.7083386",
"0.7083386",
"0.6964989",
"0.68831027",
"0.68831027",
"0.6737816",
"0.6579109",
"0.6579109",
"0.6542948",
"0.63997453",
"0.63997453",
"0.6337151",
"0.63178223",
"0.6278503",
"0.5919452",
"0.5876098",
"0.5819424",
"0.57391477",
"0.5717155",
"0.56248033",
"0.557876... | 0.6916764 | 3 |
Reduce this DataArray's data by applying ``any`` along some dimension(s). | def any(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.array_any,
dim=dim,
keep_attrs=keep_attrs,
**kwargs,
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n if (\n flox_available\n and OPTIONS[\"use_flox\"]\n and contains_only_chunked_or_numpy(self._obj)\n ):\n r... | [
"0.7147029",
"0.7147029",
"0.71060604",
"0.69430715",
"0.69430715",
"0.686053",
"0.6258159",
"0.6215559",
"0.61174256",
"0.6110123",
"0.6066965",
"0.60409343",
"0.5994262",
"0.5851336",
"0.56650263",
"0.5628333",
"0.5623232",
"0.5615794",
"0.55963945",
"0.55963945",
"0.547996... | 0.7097509 | 3 |
Reduce this DataArray's data by applying ``max`` along some dimension(s). | def max(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.max,
dim=dim,
skipna=skipna,
keep_attrs=keep_attrs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, axis=None, keepdims=False, out=None):\n return np.maximum.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def max(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.max, **kwargs)",
"def max(x, reduce_instance_dims=True, name=None): # pylint: ... | [
"0.7499046",
"0.7493348",
"0.7419733",
"0.70581836",
"0.7029081",
"0.698748",
"0.698748",
"0.6957551",
"0.6827148",
"0.6784523",
"0.6784523",
"0.6767537",
"0.67525536",
"0.6576696",
"0.65129274",
"0.6489315",
"0.6481976",
"0.6386757",
"0.63200855",
"0.62934566",
"0.6292263",
... | 0.72377324 | 3 |
Reduce this DataArray's data by applying ``min`` along some dimension(s). | def min(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.min,
dim=dim,
skipna=skipna,
keep_attrs=keep_attrs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_min(data, axis=None, keepdims=False):\n\n return reduce_min_max_common.reduce_min_max(data, axis=axis, keepdims=keepdims, method=\"min\")",
"def min(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.min, **kwargs)",
"def min(x, reduce_instance_dims=True, na... | [
"0.7439792",
"0.7199663",
"0.70754886",
"0.70718277",
"0.6887936",
"0.68407404",
"0.68407404",
"0.6811967",
"0.67787236",
"0.6728232",
"0.6673569",
"0.6673569",
"0.6566751",
"0.63526756",
"0.6350073",
"0.63400054",
"0.63212025",
"0.6175456",
"0.6168146",
"0.6053701",
"0.60158... | 0.7155868 | 2 |
Reduce this DataArray's data by applying ``mean`` along some dimension(s). | def mean(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.mean,
dim=dim,
skipna=skipna,
keep_attrs=keep_att... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(self):\n return self.data.mean(axis=-1, keepdims=True)",
"def mean(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.mean, **kwargs)",
"def mean(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attr... | [
"0.6932092",
"0.69198084",
"0.68324643",
"0.6829645",
"0.6829645",
"0.68155813",
"0.6670382",
"0.6551353",
"0.6551353",
"0.65419024",
"0.6500794",
"0.6467665",
"0.6430388",
"0.63965666",
"0.634229",
"0.6330614",
"0.63156646",
"0.6315549",
"0.62959886",
"0.62906164",
"0.624815... | 0.7121785 | 0 |
Reduce this DataArray's data by applying ``prod`` along some dimension(s). | def prod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.prod,
dim=dim,
skipna=s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prod(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.multiply.reduce(\n self, out=out, axis=axis, keepdims=keepdims, dtype=dtype\n )",
"def prod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | N... | [
"0.75356025",
"0.69897264",
"0.69897264",
"0.69731647",
"0.68985814",
"0.6810773",
"0.6810773",
"0.6472493",
"0.63539034",
"0.6327443",
"0.6250724",
"0.6143561",
"0.60524917",
"0.6012047",
"0.5895768",
"0.58667177",
"0.58586097",
"0.58586097",
"0.58586097",
"0.58337677",
"0.5... | 0.72356445 | 1 |
Reduce this DataArray's data by applying ``sum`` along some dimension(s). | def sum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.sum,
dim=dim,
skipna=ski... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(x, reduce_instance_dims=True, name=None): # pylint: disable=redefined-builtin\n return _numeric_combine(x, np.sum, reduce_instance_dims, name)",
"def sum(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.add.reduce(self, out=out, axis=axis, keepdims=keepdims, dtype=dtype)",
"... | [
"0.708487",
"0.70516545",
"0.6916435",
"0.6822894",
"0.6715113",
"0.6715113",
"0.670114",
"0.6623486",
"0.6535948",
"0.6535948",
"0.65142673",
"0.6508816",
"0.65004647",
"0.6484067",
"0.6447339",
"0.64389634",
"0.6429189",
"0.6414335",
"0.63769716",
"0.63616836",
"0.6263026",... | 0.70296186 | 2 |
Reduce this DataArray's data by applying ``median`` along some dimension(s). | def median(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.median,
dim=dim,
skipna=skipna,
keep_attrs=keep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_filter(self):\n print \"Median-Filtering...\"\n D = self.D\n x = np.median(np.median(D,axis=1),axis=1)\n for i in xrange(len(x)):\n D[i,:,:] -= x[i]\n self.D = D\n print \"done.\"",
"def median(\n self,\n dim: Dims = None,\n *,... | [
"0.7840716",
"0.71675795",
"0.71675795",
"0.71675795",
"0.69720316",
"0.6909001",
"0.6809316",
"0.67637587",
"0.6649234",
"0.65772283",
"0.649336",
"0.6491507",
"0.64689547",
"0.64432216",
"0.6414413",
"0.6403336",
"0.6348854",
"0.6339596",
"0.6326826",
"0.6324761",
"0.632114... | 0.7371451 | 2 |
Reduce this DataArray's data by applying ``cumsum`` along some dimension(s). | def cumsum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.cumsum,
dim=dim,
skipna=skipna,
keep_attrs=keep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n ... | [
"0.7601719",
"0.7601719",
"0.7601719",
"0.71929914",
"0.70374393",
"0.6974349",
"0.6739214",
"0.6690532",
"0.6560123",
"0.64532024",
"0.6444809",
"0.6434722",
"0.6355989",
"0.6352609",
"0.6270605",
"0.6270605",
"0.6270605",
"0.62120354",
"0.6194247",
"0.6184793",
"0.6179344",... | 0.7733504 | 2 |
Reduce this DataArray's data by applying ``cumprod`` along some dimension(s). | def cumprod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.cumprod,
dim=dim,
skipna=skipna,
keep_attrs=ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumprod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumprod,\n dim=dim,\n skipna=skipna,\n ... | [
"0.78693175",
"0.78693175",
"0.78693175",
"0.74438745",
"0.73570323",
"0.72512066",
"0.71616554",
"0.6794507",
"0.66913575",
"0.6365985",
"0.6155289",
"0.60739994",
"0.6059755",
"0.60538614",
"0.602666",
"0.59202105",
"0.57904106",
"0.57707596",
"0.57707596",
"0.57707596",
"0... | 0.8048191 | 2 |
Reduce this Dataset's data by applying ``count`` along some dimension(s). | def count(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.count,\n dim=dim,\n keep_attrs=keep_attrs,\n **kwargs,\n )",
"def... | [
"0.730545",
"0.7285971",
"0.69529074",
"0.69529074",
"0.6121086",
"0.60577554",
"0.5984994",
"0.5982864",
"0.59388554",
"0.5934392",
"0.5903536",
"0.5890546",
"0.5856696",
"0.5820845",
"0.5794014",
"0.5787277",
"0.5708209",
"0.56682146",
"0.5646369",
"0.5555573",
"0.55479443"... | 0.69733924 | 3 |
Reduce this Dataset's data by applying ``all`` along some dimension(s). | def all(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_redu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.array_all,\n dim=dim,\n numeric_only=False,\n keep_attrs=keep_attrs,\n ... | [
"0.69627005",
"0.69300705",
"0.69300705",
"0.68929625",
"0.68462247",
"0.6555234",
"0.6555234",
"0.64865315",
"0.64326197",
"0.6402593",
"0.6402593",
"0.6244518",
"0.62295026",
"0.6124534",
"0.6039926",
"0.59571075",
"0.5946202",
"0.5869544",
"0.56962043",
"0.5633015",
"0.561... | 0.70568603 | 1 |
Reduce this Dataset's data by applying ``any`` along some dimension(s). | def any(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_redu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.array_any,\n dim=dim,\n numeric_only=False,\n keep_attrs=keep_attrs,\n ... | [
"0.7110761",
"0.7086105",
"0.703172",
"0.703172",
"0.70229447",
"0.6403789",
"0.6393615",
"0.6261724",
"0.61942995",
"0.6074665",
"0.59774745",
"0.5968099",
"0.5967931",
"0.59597373",
"0.58590436",
"0.57441306",
"0.57049936",
"0.5693786",
"0.5693786",
"0.5675616",
"0.56408346... | 0.7161406 | 1 |
Reduce this Dataset's data by applying ``max`` along some dimension(s). | def max(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.max, **kwargs)",
"def max(self, axis=None, keepdims=False, out=None):\n return np.maximum.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def max(\n self,\n dim: Dims = None,\n *... | [
"0.77546567",
"0.74091095",
"0.73297554",
"0.7306282",
"0.71526575",
"0.69466513",
"0.69466513",
"0.6744938",
"0.66868365",
"0.66764325",
"0.65898407",
"0.6559864",
"0.63669294",
"0.6346971",
"0.6312237",
"0.62524205",
"0.62271637",
"0.6188847",
"0.6188484",
"0.6150224",
"0.6... | 0.70421654 | 6 |
Reduce this Dataset's data by applying ``min`` along some dimension(s). | def min(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.min, **kwargs)",
"def reduce_min(data, axis=None, keepdims=False):\n\n return reduce_min_max_common.reduce_min_max(data, axis=axis, keepdims=keepdims, method=\"min\")",
"def min(\n self,\n dim: Di... | [
"0.7571916",
"0.7364422",
"0.7293054",
"0.72700524",
"0.7055405",
"0.6883447",
"0.6883447",
"0.68764853",
"0.68314165",
"0.6661202",
"0.6513228",
"0.64885235",
"0.6312382",
"0.62034804",
"0.61937124",
"0.61580485",
"0.60934466",
"0.6086458",
"0.60608375",
"0.60293967",
"0.596... | 0.7008117 | 6 |
Reduce this Dataset's data by applying ``mean`` along some dimension(s). | def mean(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.mean, **kwargs)",
"def mean(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n ... | [
"0.7125142",
"0.7047306",
"0.70345366",
"0.67199534",
"0.67199534",
"0.67112726",
"0.66991585",
"0.6322035",
"0.6293821",
"0.62826467",
"0.62740856",
"0.6267241",
"0.62604976",
"0.62210166",
"0.6203718",
"0.6203718",
"0.6188599",
"0.61203796",
"0.611122",
"0.60992503",
"0.607... | 0.6737977 | 4 |
Reduce this Dataset's data by applying ``prod`` along some dimension(s). | def prod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_onl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prod(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.multiply.reduce(\n self, out=out, axis=axis, keepdims=keepdims, dtype=dtype\n )",
"def prod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | N... | [
"0.7481061",
"0.74074686",
"0.735098",
"0.700226",
"0.700226",
"0.6688766",
"0.65455145",
"0.65137213",
"0.64294696",
"0.6274849",
"0.6176995",
"0.6066634",
"0.59346235",
"0.5929033",
"0.591033",
"0.591033",
"0.591033",
"0.58753616",
"0.5752229",
"0.5747925",
"0.5747925",
"... | 0.714532 | 4 |
Reduce this Dataset's data by applying ``sum`` along some dimension(s). | def sum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.sum,\n dim=dim,\n ... | [
"0.70600945",
"0.6923307",
"0.68674266",
"0.686163",
"0.68115973",
"0.66666335",
"0.6637249",
"0.6547622",
"0.6547622",
"0.64223146",
"0.6413984",
"0.636318",
"0.63100564",
"0.6269711",
"0.626921",
"0.62295324",
"0.62160474",
"0.61654747",
"0.614655",
"0.60469216",
"0.6013805... | 0.6726549 | 5 |
Reduce this Dataset's data by applying ``median`` along some dimension(s). | def median(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.median,
dim=dim,
skipna=skipna,
numeric_only=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_filter(self):\n print \"Median-Filtering...\"\n D = self.D\n x = np.median(np.median(D,axis=1),axis=1)\n for i in xrange(len(x)):\n D[i,:,:] -= x[i]\n self.D = D\n print \"done.\"",
"def median(\n self,\n dim: Dims = None,\n *,... | [
"0.7723946",
"0.73474264",
"0.73474264",
"0.73474264",
"0.67132735",
"0.6709282",
"0.6704458",
"0.6682933",
"0.6635858",
"0.656867",
"0.65672284",
"0.6512514",
"0.64834887",
"0.64834887",
"0.6444135",
"0.63871884",
"0.6383317",
"0.6333734",
"0.62151307",
"0.61960506",
"0.6195... | 0.738869 | 1 |
Reduce this Dataset's data by applying ``cumsum`` along some dimension(s). | def cumsum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.cumsum,
dim=dim,
skipna=skipna,
numeric_only=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n ... | [
"0.75369805",
"0.75369805",
"0.75369805",
"0.6748461",
"0.67054296",
"0.66430676",
"0.63819027",
"0.63511914",
"0.63409925",
"0.6273229",
"0.62687963",
"0.62687963",
"0.62687963",
"0.62631625",
"0.62614137",
"0.624574",
"0.61842084",
"0.61842084",
"0.61842084",
"0.60996747",
... | 0.7699135 | 1 |
Reduce this Dataset's data by applying ``cumprod`` along some dimension(s). | def cumprod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.cumprod,
dim=dim,
skipna=skipna,
numeric_only=Tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumprod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumprod,\n dim=dim,\n skipna=skipna,\n ... | [
"0.78994447",
"0.78994447",
"0.78994447",
"0.70834005",
"0.7032063",
"0.69815505",
"0.6964613",
"0.6532074",
"0.62200755",
"0.6205164",
"0.62014854",
"0.61457735",
"0.6142508",
"0.6083153",
"0.60304993",
"0.59804726",
"0.59804726",
"0.5861358",
"0.5861358",
"0.5861358",
"0.58... | 0.8054797 | 1 |
Reduce this Dataset's data by applying ``count`` along some dimension(s). | def count(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.count,\n dim=dim,\n keep_attrs=keep_attrs,\n **kwargs,\n )",
"def... | [
"0.730545",
"0.7285971",
"0.69529074",
"0.69529074",
"0.6121086",
"0.60577554",
"0.5984994",
"0.5982864",
"0.59388554",
"0.5934392",
"0.5903536",
"0.5890546",
"0.5856696",
"0.5820845",
"0.5794014",
"0.5787277",
"0.5708209",
"0.56682146",
"0.5646369",
"0.5555573",
"0.55479443"... | 0.69733924 | 2 |
Reduce this Dataset's data by applying ``all`` along some dimension(s). | def all(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_redu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.array_all,\n dim=dim,\n numeric_only=False,\n keep_attrs=keep_attrs,\n ... | [
"0.69636464",
"0.69317317",
"0.69317317",
"0.68936807",
"0.6847603",
"0.65551496",
"0.65551496",
"0.6485944",
"0.64324665",
"0.64027697",
"0.64027697",
"0.6244525",
"0.62312984",
"0.6125453",
"0.60393447",
"0.59572035",
"0.5945839",
"0.58689076",
"0.5696258",
"0.5634013",
"0.... | 0.7058243 | 0 |
Reduce this Dataset's data by applying ``any`` along some dimension(s). | def any(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_redu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.array_any,\n dim=dim,\n numeric_only=False,\n keep_attrs=keep_attrs,\n ... | [
"0.7112423",
"0.70864093",
"0.7033621",
"0.7033621",
"0.7024333",
"0.6406168",
"0.63930935",
"0.6261834",
"0.61942494",
"0.6075047",
"0.59765315",
"0.5969457",
"0.5967703",
"0.59609085",
"0.5858443",
"0.5745467",
"0.57042044",
"0.56952304",
"0.56952304",
"0.5676726",
"0.56422... | 0.7163614 | 0 |
Reduce this Dataset's data by applying ``max`` along some dimension(s). | def max(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.max, **kwargs)",
"def max(self, axis=None, keepdims=False, out=None):\n return np.maximum.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def max(\n self,\n dim: Dims = None,\n *... | [
"0.77546567",
"0.74091095",
"0.73297554",
"0.7306282",
"0.71526575",
"0.69466513",
"0.69466513",
"0.6744938",
"0.66868365",
"0.66764325",
"0.65898407",
"0.6559864",
"0.63669294",
"0.6346971",
"0.6312237",
"0.62524205",
"0.62271637",
"0.6188847",
"0.6188484",
"0.6150224",
"0.6... | 0.70421654 | 5 |
Reduce this Dataset's data by applying ``min`` along some dimension(s). | def min(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def min(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.min, **kwargs)",
"def reduce_min(data, axis=None, keepdims=False):\n\n return reduce_min_max_common.reduce_min_max(data, axis=axis, keepdims=keepdims, method=\"min\")",
"def min(\n self,\n dim: Di... | [
"0.7571916",
"0.7364422",
"0.7293054",
"0.72700524",
"0.7055405",
"0.6883447",
"0.6883447",
"0.68764853",
"0.68314165",
"0.6661202",
"0.6513228",
"0.64885235",
"0.6312382",
"0.62034804",
"0.61937124",
"0.61580485",
"0.60934466",
"0.6086458",
"0.60608375",
"0.60293967",
"0.596... | 0.7008117 | 5 |
Reduce this Dataset's data by applying ``mean`` along some dimension(s). | def mean(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.mean, **kwargs)",
"def mean(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n ... | [
"0.7127385",
"0.7049797",
"0.70370185",
"0.6722186",
"0.6722186",
"0.6714496",
"0.6700629",
"0.6324996",
"0.62950623",
"0.62856495",
"0.6274769",
"0.62702817",
"0.62637585",
"0.62234634",
"0.6204494",
"0.6204494",
"0.6190918",
"0.6122293",
"0.6113007",
"0.6103501",
"0.607219"... | 0.6740046 | 3 |
Reduce this Dataset's data by applying ``prod`` along some dimension(s). | def prod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_onl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prod(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.multiply.reduce(\n self, out=out, axis=axis, keepdims=keepdims, dtype=dtype\n )",
"def prod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | N... | [
"0.74812174",
"0.7406539",
"0.7350262",
"0.7001044",
"0.7001044",
"0.6689062",
"0.65455264",
"0.65116835",
"0.64301413",
"0.6273224",
"0.6176157",
"0.6064172",
"0.5933759",
"0.59290385",
"0.5911163",
"0.5911163",
"0.5911163",
"0.58762074",
"0.57524556",
"0.57490146",
"0.57490... | 0.7143918 | 3 |
Reduce this Dataset's data by applying ``sum`` along some dimension(s). | def sum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.sum,\n dim=dim,\n ... | [
"0.70600945",
"0.6923307",
"0.68674266",
"0.686163",
"0.68115973",
"0.66666335",
"0.6637249",
"0.6547622",
"0.6547622",
"0.64223146",
"0.6413984",
"0.636318",
"0.63100564",
"0.6269711",
"0.626921",
"0.62295324",
"0.62160474",
"0.61654747",
"0.614655",
"0.60469216",
"0.6013805... | 0.6726549 | 6 |
Reduce this Dataset's data by applying ``median`` along some dimension(s). | def median(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.median,
dim=dim,
skipna=skipna,
numeric_only=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_filter(self):\n print \"Median-Filtering...\"\n D = self.D\n x = np.median(np.median(D,axis=1),axis=1)\n for i in xrange(len(x)):\n D[i,:,:] -= x[i]\n self.D = D\n print \"done.\"",
"def median(\n self,\n dim: Dims = None,\n *,... | [
"0.7723946",
"0.73474264",
"0.73474264",
"0.73474264",
"0.67132735",
"0.6709282",
"0.6704458",
"0.6682933",
"0.6635858",
"0.656867",
"0.65672284",
"0.6512514",
"0.64834887",
"0.64834887",
"0.6444135",
"0.63871884",
"0.6383317",
"0.6333734",
"0.62151307",
"0.61960506",
"0.6195... | 0.738869 | 3 |
Reduce this Dataset's data by applying ``cumsum`` along some dimension(s). | def cumsum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.cumsum,
dim=dim,
skipna=skipna,
numeric_only=True... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n ... | [
"0.7537239",
"0.7537239",
"0.7537239",
"0.67484677",
"0.67069674",
"0.66436154",
"0.63819385",
"0.6350921",
"0.6343282",
"0.62725073",
"0.6268484",
"0.6268484",
"0.6268484",
"0.6262665",
"0.6262446",
"0.62461925",
"0.61838704",
"0.61838704",
"0.61838704",
"0.61028945",
"0.606... | 0.769945 | 0 |
Reduce this Dataset's data by applying ``cumprod`` along some dimension(s). | def cumprod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> Dataset:
return self.reduce(
duck_array_ops.cumprod,
dim=dim,
skipna=skipna,
numeric_only=Tr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumprod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.cumprod,\n dim=dim,\n skipna=skipna,\n ... | [
"0.7896212",
"0.7896212",
"0.7896212",
"0.70786357",
"0.7026533",
"0.6977891",
"0.6960451",
"0.6529018",
"0.62155104",
"0.620573",
"0.6204624",
"0.61433333",
"0.61382365",
"0.6083183",
"0.6030813",
"0.59799564",
"0.59799564",
"0.5859764",
"0.5859764",
"0.5859764",
"0.5842625"... | 0.8052243 | 0 |
Reduce this DataArray's data by applying ``count`` along some dimension(s). | def count(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.count,\n dim=dim,\n keep_attrs=keep_attrs,\n **kwargs,\n )",
"def... | [
"0.689733",
"0.6536641",
"0.6222912",
"0.6222912",
"0.5899386",
"0.5839136",
"0.58359593",
"0.5775192",
"0.57379466",
"0.56800747",
"0.5656914",
"0.5550732",
"0.5548875",
"0.5545551",
"0.5519766",
"0.5506328",
"0.54978377",
"0.54916394",
"0.54750216",
"0.54518205",
"0.5439978... | 0.6580944 | 2 |
Reduce this DataArray's data by applying ``all`` along some dimension(s). | def all(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(self, axis=None, keepdims=False, out=None):\n return np.logical_and.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def all(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduc... | [
"0.6964989",
"0.6916764",
"0.68831027",
"0.68831027",
"0.6737816",
"0.6579109",
"0.6579109",
"0.6542948",
"0.63997453",
"0.63997453",
"0.6337151",
"0.63178223",
"0.6278503",
"0.5919452",
"0.5876098",
"0.5819424",
"0.57391477",
"0.5717155",
"0.56248033",
"0.55787617",
"0.55427... | 0.7083386 | 1 |
Reduce this DataArray's data by applying ``any`` along some dimension(s). | def any(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any(self, axis=None, keepdims=False, out=None):\n return np.logical_or.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def any(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce... | [
"0.71060604",
"0.7097509",
"0.69430715",
"0.69430715",
"0.686053",
"0.6258159",
"0.6215559",
"0.61174256",
"0.6110123",
"0.6066965",
"0.60409343",
"0.5994262",
"0.5851336",
"0.56650263",
"0.5628333",
"0.5623232",
"0.5615794",
"0.55963945",
"0.55963945",
"0.5479969",
"0.547805... | 0.7147029 | 1 |
Reduce this DataArray's data by applying ``max`` along some dimension(s). | def max(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, axis=None, keepdims=False, out=None):\n return np.maximum.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def max(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.max, **kwargs)",
"def max(x, reduce_instance_dims=True, name=None): # pylint: ... | [
"0.74999726",
"0.74952066",
"0.74215984",
"0.7238595",
"0.7059394",
"0.7031104",
"0.6958482",
"0.6829291",
"0.67855746",
"0.67855746",
"0.67707264",
"0.67548984",
"0.65782875",
"0.6512423",
"0.649088",
"0.64825344",
"0.6388284",
"0.63214207",
"0.62954676",
"0.62948644",
"0.62... | 0.6988353 | 7 |
Reduce this DataArray's data by applying ``min`` along some dimension(s). | def min(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_min(data, axis=None, keepdims=False):\n\n return reduce_min_max_common.reduce_min_max(data, axis=axis, keepdims=keepdims, method=\"min\")",
"def min(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.min, **kwargs)",
"def min(\n self,\n dim: Di... | [
"0.7440803",
"0.7204129",
"0.71611565",
"0.708059",
"0.70752877",
"0.68929535",
"0.68170446",
"0.6784315",
"0.6733736",
"0.66785234",
"0.66785234",
"0.65714854",
"0.63575816",
"0.6355785",
"0.63445956",
"0.6324506",
"0.6180467",
"0.61725414",
"0.6059228",
"0.60190845",
"0.597... | 0.6846028 | 7 |
Reduce this DataArray's data by applying ``mean`` along some dimension(s). | def mean(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.mean,\n dim=dim,\n skipna=skipna,\n ke... | [
"0.7121785",
"0.6932092",
"0.69198084",
"0.68324643",
"0.68155813",
"0.6670382",
"0.6551353",
"0.6551353",
"0.65419024",
"0.6500794",
"0.6467665",
"0.6430388",
"0.63965666",
"0.634229",
"0.6330614",
"0.63156646",
"0.6315549",
"0.62959886",
"0.62906164",
"0.62481505",
"0.62440... | 0.6829645 | 5 |
Reduce this DataArray's data by applying ``prod`` along some dimension(s). | def prod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prod(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.multiply.reduce(\n self, out=out, axis=axis, keepdims=keepdims, dtype=dtype\n )",
"def prod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | N... | [
"0.75356025",
"0.72356445",
"0.69731647",
"0.68985814",
"0.6810773",
"0.6810773",
"0.6472493",
"0.63539034",
"0.6327443",
"0.6250724",
"0.6143561",
"0.60524917",
"0.6012047",
"0.5895768",
"0.58667177",
"0.58586097",
"0.58586097",
"0.58586097",
"0.58337677",
"0.58119243",
"0.5... | 0.69897264 | 3 |
Reduce this DataArray's data by applying ``sum`` along some dimension(s). | def sum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_on... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(x, reduce_instance_dims=True, name=None): # pylint: disable=redefined-builtin\n return _numeric_combine(x, np.sum, reduce_instance_dims, name)",
"def sum(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.add.reduce(self, out=out, axis=axis, keepdims=keepdims, dtype=dtype)",
"... | [
"0.70844406",
"0.70525146",
"0.70310706",
"0.6917323",
"0.68248296",
"0.67027587",
"0.66225314",
"0.6537938",
"0.6537938",
"0.6512875",
"0.6508079",
"0.65030366",
"0.64850044",
"0.644632",
"0.64397097",
"0.6430089",
"0.6415773",
"0.637861",
"0.6360291",
"0.6263903",
"0.619573... | 0.67166716 | 5 |
Reduce this DataArray's data by applying ``median`` along some dimension(s). | def median(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.median,
dim=dim,
skipna=skipna,
keep_attrs=keep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_filter(self):\n print \"Median-Filtering...\"\n D = self.D\n x = np.median(np.median(D,axis=1),axis=1)\n for i in xrange(len(x)):\n D[i,:,:] -= x[i]\n self.D = D\n print \"done.\"",
"def median(\n self,\n dim: Dims = None,\n *,... | [
"0.78427637",
"0.7167513",
"0.7167513",
"0.7167513",
"0.69730324",
"0.6910752",
"0.68106145",
"0.67670226",
"0.6652223",
"0.65817285",
"0.6497116",
"0.6493224",
"0.646913",
"0.6444315",
"0.64180654",
"0.6402042",
"0.6348643",
"0.6338873",
"0.6329231",
"0.63277715",
"0.6323139... | 0.7371279 | 3 |
Reduce this DataArray's data by applying ``cumsum`` along some dimension(s). | def cumsum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.cumsum,
dim=dim,
skipna=skipna,
keep_attrs=keep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n ... | [
"0.7601719",
"0.7601719",
"0.7601719",
"0.71929914",
"0.70374393",
"0.6974349",
"0.6739214",
"0.6690532",
"0.6560123",
"0.64532024",
"0.6444809",
"0.6434722",
"0.6355989",
"0.6352609",
"0.6270605",
"0.6270605",
"0.6270605",
"0.62120354",
"0.6194247",
"0.6184793",
"0.6179344",... | 0.7733504 | 1 |
Reduce this DataArray's data by applying ``cumprod`` along some dimension(s). | def cumprod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.cumprod,
dim=dim,
skipna=skipna,
keep_attrs=ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumprod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumprod,\n dim=dim,\n skipna=skipna,\n ... | [
"0.78693175",
"0.78693175",
"0.78693175",
"0.74438745",
"0.73570323",
"0.72512066",
"0.71616554",
"0.6794507",
"0.66913575",
"0.6365985",
"0.6155289",
"0.60739994",
"0.6059755",
"0.60538614",
"0.602666",
"0.59202105",
"0.57904106",
"0.57707596",
"0.57707596",
"0.57707596",
"0... | 0.8048191 | 1 |
Reduce this DataArray's data by applying ``count`` along some dimension(s). | def count(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.count,\n dim=dim,\n keep_attrs=keep_attrs,\n **kwargs,\n )",
"def... | [
"0.6898398",
"0.65379834",
"0.6224404",
"0.6224404",
"0.59004956",
"0.5841828",
"0.5838448",
"0.57762665",
"0.573857",
"0.56812054",
"0.5657385",
"0.55505395",
"0.55487853",
"0.55471367",
"0.55208504",
"0.5506666",
"0.54985136",
"0.5492544",
"0.54757905",
"0.54540455",
"0.543... | 0.6582146 | 1 |
Reduce this DataArray's data by applying ``all`` along some dimension(s). | def all(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all(self, axis=None, keepdims=False, out=None):\n return np.logical_and.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def all(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduc... | [
"0.6964989",
"0.6916764",
"0.68831027",
"0.68831027",
"0.6737816",
"0.6579109",
"0.6579109",
"0.6542948",
"0.63997453",
"0.63997453",
"0.6337151",
"0.63178223",
"0.6278503",
"0.5919452",
"0.5876098",
"0.5819424",
"0.57391477",
"0.5717155",
"0.56248033",
"0.55787617",
"0.55427... | 0.7083386 | 0 |
Reduce this DataArray's data by applying ``any`` along some dimension(s). | def any(
self,
dim: Dims = None,
*,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
):
return self._flox_re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def any(self, axis=None, keepdims=False, out=None):\n return np.logical_or.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def any(\n self,\n dim: Dims = None,\n *,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce... | [
"0.71060604",
"0.7097509",
"0.69430715",
"0.69430715",
"0.686053",
"0.6258159",
"0.6215559",
"0.61174256",
"0.6110123",
"0.6066965",
"0.60409343",
"0.5994262",
"0.5851336",
"0.56650263",
"0.5628333",
"0.5623232",
"0.5615794",
"0.55963945",
"0.55963945",
"0.5479969",
"0.547805... | 0.7147029 | 0 |
Reduce this DataArray's data by applying ``max`` along some dimension(s). | def max(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def max(self, axis=None, keepdims=False, out=None):\n return np.maximum.reduce(self, out=out, axis=axis, keepdims=keepdims)",
"def max(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.max, **kwargs)",
"def max(x, reduce_instance_dims=True, name=None): # pylint: ... | [
"0.7499046",
"0.7493348",
"0.7419733",
"0.72377324",
"0.70581836",
"0.7029081",
"0.6957551",
"0.6827148",
"0.6784523",
"0.6784523",
"0.6767537",
"0.67525536",
"0.6576696",
"0.65129274",
"0.6489315",
"0.6481976",
"0.6386757",
"0.63200855",
"0.62934566",
"0.6292263",
"0.6288653... | 0.698748 | 6 |
Reduce this DataArray's data by applying ``min`` along some dimension(s). | def min(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reduce_min(data, axis=None, keepdims=False):\n\n return reduce_min_max_common.reduce_min_max(data, axis=axis, keepdims=keepdims, method=\"min\")",
"def min(self, axis=0, **kwargs) -> \"Dataset\":\n return self.aggregate(axis=axis, func=np.min, **kwargs)",
"def min(\n self,\n dim: Di... | [
"0.7439792",
"0.7199663",
"0.7155868",
"0.70754886",
"0.70718277",
"0.6887936",
"0.6811967",
"0.67787236",
"0.6728232",
"0.6673569",
"0.6673569",
"0.6566751",
"0.63526756",
"0.6350073",
"0.63400054",
"0.63212025",
"0.6175456",
"0.6168146",
"0.6053701",
"0.6015834",
"0.5973817... | 0.68407404 | 6 |
Reduce this DataArray's data by applying ``mean`` along some dimension(s). | def mean(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_only_chunked_or_numpy(self._obj)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mean(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> DataArray:\n return self.reduce(\n duck_array_ops.mean,\n dim=dim,\n skipna=skipna,\n ke... | [
"0.7121785",
"0.6932092",
"0.69198084",
"0.68324643",
"0.68155813",
"0.6670382",
"0.6551353",
"0.6551353",
"0.65419024",
"0.6500794",
"0.6467665",
"0.6430388",
"0.63965666",
"0.634229",
"0.6330614",
"0.63156646",
"0.6315549",
"0.62959886",
"0.62906164",
"0.62481505",
"0.62440... | 0.6829645 | 4 |
Reduce this DataArray's data by applying ``prod`` along some dimension(s). | def prod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prod(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.multiply.reduce(\n self, out=out, axis=axis, keepdims=keepdims, dtype=dtype\n )",
"def prod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n min_count: int | N... | [
"0.75356025",
"0.72356445",
"0.69731647",
"0.68985814",
"0.6810773",
"0.6810773",
"0.6472493",
"0.63539034",
"0.6327443",
"0.6250724",
"0.6143561",
"0.60524917",
"0.6012047",
"0.5895768",
"0.58667177",
"0.58586097",
"0.58586097",
"0.58586097",
"0.58337677",
"0.58119243",
"0.5... | 0.69897264 | 2 |
Reduce this DataArray's data by applying ``sum`` along some dimension(s). | def sum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
min_count: int | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
if (
flox_available
and OPTIONS["use_flox"]
and contains_on... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum(x, reduce_instance_dims=True, name=None): # pylint: disable=redefined-builtin\n return _numeric_combine(x, np.sum, reduce_instance_dims, name)",
"def sum(self, axis=None, keepdims=False, dtype=None, out=None):\n return np.add.reduce(self, out=out, axis=axis, keepdims=keepdims, dtype=dtype)",
"... | [
"0.708487",
"0.70516545",
"0.70296186",
"0.6916435",
"0.6822894",
"0.670114",
"0.6623486",
"0.6535948",
"0.6535948",
"0.65142673",
"0.6508816",
"0.65004647",
"0.6484067",
"0.6447339",
"0.64389634",
"0.6429189",
"0.6414335",
"0.63769716",
"0.63616836",
"0.6263026",
"0.61955464... | 0.6715113 | 6 |
Reduce this DataArray's data by applying ``median`` along some dimension(s). | def median(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.median,
dim=dim,
skipna=skipna,
keep_attrs=keep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def median_filter(self):\n print \"Median-Filtering...\"\n D = self.D\n x = np.median(np.median(D,axis=1),axis=1)\n for i in xrange(len(x)):\n D[i,:,:] -= x[i]\n self.D = D\n print \"done.\"",
"def median(\n self,\n dim: Dims = None,\n *,... | [
"0.7840716",
"0.71675795",
"0.71675795",
"0.71675795",
"0.69720316",
"0.6909001",
"0.6809316",
"0.67637587",
"0.6649234",
"0.65772283",
"0.649336",
"0.6491507",
"0.64689547",
"0.64432216",
"0.6414413",
"0.6403336",
"0.6348854",
"0.6339596",
"0.6326826",
"0.6324761",
"0.632114... | 0.7371451 | 1 |
Reduce this DataArray's data by applying ``cumsum`` along some dimension(s). | def cumsum(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.cumsum,
dim=dim,
skipna=skipna,
keep_attrs=keep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumsum(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumsum,\n dim=dim,\n skipna=skipna,\n ... | [
"0.7601719",
"0.7601719",
"0.7601719",
"0.71929914",
"0.70374393",
"0.6974349",
"0.6739214",
"0.6690532",
"0.6560123",
"0.64532024",
"0.6444809",
"0.6434722",
"0.6355989",
"0.6352609",
"0.6270605",
"0.6270605",
"0.6270605",
"0.62120354",
"0.6194247",
"0.6184793",
"0.6179344",... | 0.7733504 | 0 |
Reduce this DataArray's data by applying ``cumprod`` along some dimension(s). | def cumprod(
self,
dim: Dims = None,
*,
skipna: bool | None = None,
keep_attrs: bool | None = None,
**kwargs: Any,
) -> DataArray:
return self.reduce(
duck_array_ops.cumprod,
dim=dim,
skipna=skipna,
keep_attrs=ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cumprod(\n self,\n dim: Dims = None,\n *,\n skipna: bool | None = None,\n keep_attrs: bool | None = None,\n **kwargs: Any,\n ) -> Dataset:\n return self.reduce(\n duck_array_ops.cumprod,\n dim=dim,\n skipna=skipna,\n ... | [
"0.78693175",
"0.78693175",
"0.78693175",
"0.74438745",
"0.73570323",
"0.72512066",
"0.71616554",
"0.6794507",
"0.66913575",
"0.6365985",
"0.6155289",
"0.60739994",
"0.6059755",
"0.60538614",
"0.602666",
"0.59202105",
"0.57904106",
"0.57707596",
"0.57707596",
"0.57707596",
"0... | 0.8048191 | 0 |
This function takes a C{SOM} or C{SO} and calculates the weighted average for the primary axis. | def weighted_average(obj, **kwargs):
# import the helper functions
import hlr_utils
# set up for working through data
# This time highest object in the hierarchy is NOT what we need
result = []
if(hlr_utils.get_length(obj) > 1):
res_descr = "list"
else:
res_descr = "number"... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weightedAvgAxisPoints(self, var):\n varID = var.id\n var = cdutil.averager(var, axis=\"(%s)\" % self.axis.id)\n var.id = varID\n return var",
"def mean(self, weight_by_area=True):\n if weight_by_area:\n return self.integral() / self.indicator.integral()\n ... | [
"0.6679837",
"0.6392755",
"0.63330156",
"0.6298467",
"0.62950045",
"0.62950045",
"0.61880696",
"0.6139873",
"0.61280626",
"0.6105097",
"0.6105097",
"0.6105097",
"0.60493076",
"0.60196114",
"0.6009895",
"0.5936236",
"0.585179",
"0.5833318",
"0.58251274",
"0.58160293",
"0.58099... | 0.5395155 | 69 |
Menaikan jabatan role xp member ke role xp selanjutnya(admin only). | async def promote(self, ctx, *, member = None):
# Only allow admins to change server stats
if not await self._can_run(ctx): return
em = discord.Embed(color = 0XFF8C00, description = "Menaikan jabatan role xp member ke role xp selanjutnya\n\n"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def promoteto(self, ctx, *, member = None, role = None):\r\n if not await self._can_run(ctx): return\r\n em = discord.Embed(color = 0XFF8C00, description = \"Menaikan role xp member ke role yang ditentukan\\n\"\r\n \"Pastikan role xp s... | [
"0.64883465",
"0.6299787",
"0.61075544",
"0.5897025",
"0.5765006",
"0.57568175",
"0.56386036",
"0.56318307",
"0.56316966",
"0.56002736",
"0.55545866",
"0.55380803",
"0.55184126",
"0.54676664",
"0.54562855",
"0.5447556",
"0.5395318",
"0.5377828",
"0.53774434",
"0.53774434",
"0... | 0.7284638 | 0 |
Menaikan jabatan role xp member ke role yang ditentukan(admin only). Pastikan role xp sudah terdaftar dalam list. | async def promoteto(self, ctx, *, member = None, role = None):
if not await self._can_run(ctx): return
em = discord.Embed(color = 0XFF8C00, description = "Menaikan role xp member ke role yang ditentukan\n"
"Pastikan role xp sudah terdaftar ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def promote(self, ctx, *, member = None):\r\n # Only allow admins to change server stats\r\n if not await self._can_run(ctx): return\r\n em = discord.Embed(color = 0XFF8C00, description = \"Menaikan jabatan role xp member ke role xp selanjutnya\\n\\n\"\r\n ... | [
"0.6897744",
"0.6417851",
"0.6120397",
"0.6084025",
"0.58839273",
"0.58782655",
"0.57135737",
"0.5712414",
"0.56621563",
"0.559318",
"0.5560708",
"0.5543786",
"0.55319005",
"0.5451649",
"0.53736186",
"0.53556925",
"0.5349258",
"0.53393424",
"0.5319157",
"0.5298649",
"0.523354... | 0.6150072 | 2 |
Menurunkan jabatan role xp kepada member ke role xp dibawahnya(admin only). | async def demote(self, ctx, *, member = None):
if not await self._can_run(ctx): return
em = discord.Embed(color = 0XFF8C00, description = "> Menurunkan jabatan role xp kepada member ke role xp dibawahnya\n> \n"
"> **Panduan**\n"
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def promote(self, ctx, *, member = None):\r\n # Only allow admins to change server stats\r\n if not await self._can_run(ctx): return\r\n em = discord.Embed(color = 0XFF8C00, description = \"Menaikan jabatan role xp member ke role xp selanjutnya\\n\\n\"\r\n ... | [
"0.71648365",
"0.6548941",
"0.5894065",
"0.58580065",
"0.58091015",
"0.57732093",
"0.5683263",
"0.56225127",
"0.55899394",
"0.55714273",
"0.55708843",
"0.556818",
"0.5552556",
"0.5552556",
"0.55492216",
"0.55396116",
"0.55220395",
"0.5514",
"0.5483468",
"0.5475175",
"0.544764... | 0.63345957 | 2 |
Menurunkan jabatan role xp ke role xp tertentu kepada member(admin only). Pastikan role xp sudah terdaftar dalam list | async def demoteto(self, ctx, *, member = None, role = None):
if not await self._can_run(ctx): return
em = discord.Embed(color = 0XFF8C00, description = "> Menurunkan jabatan role xp ke role xp tertentu kepada member\n"
"> Pastikan role xp ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def promote(self, ctx, *, member = None):\r\n # Only allow admins to change server stats\r\n if not await self._can_run(ctx): return\r\n em = discord.Embed(color = 0XFF8C00, description = \"Menaikan jabatan role xp member ke role xp selanjutnya\\n\\n\"\r\n ... | [
"0.6740734",
"0.6316296",
"0.6065128",
"0.5981462",
"0.59259355",
"0.5835332",
"0.5829102",
"0.581026",
"0.56879264",
"0.5583512",
"0.5526402",
"0.5479445",
"0.5473438",
"0.54572344",
"0.54492337",
"0.54278344",
"0.54069895",
"0.5392819",
"0.53751904",
"0.5368704",
"0.5354929... | 0.5236644 | 29 |
Method for serve media files with runserver. | def mediafiles_urlpatterns(prefix):
import re
from django.views.static import serve
return [
url(r'^%s(?P<path>.*)$' % re.escape(prefix.lstrip('/')), serve,
{'document_root': settings.MEDIA_ROOT})
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def media(filename):\n media_path = flask.current_app.instance_path + '/media'\n return flask.send_from_directory(media_path, filename)",
"def serve(cls, path):\n path = path[6:] # strip \"media/\"\n path = path.replace(\"..\", \"\") ## .. tricks\n \n type = \"application/data\"... | [
"0.7033503",
"0.6768408",
"0.65954095",
"0.650041",
"0.6376518",
"0.63572216",
"0.62549037",
"0.6217632",
"0.6199887",
"0.6185902",
"0.61709887",
"0.6170003",
"0.6168919",
"0.60898477",
"0.6059277",
"0.60249346",
"0.5996193",
"0.5989206",
"0.5988831",
"0.5987521",
"0.5958096"... | 0.5537691 | 47 |
Return token object as a dictionary. | def get_token(self, payload):
response = requests.post(
self.OIDC_OP_TOKEN_ENDPOINT,
data=payload,
verify=import_from_settings('OIDC_VERIFY_SSL', True))
response.raise_for_status()
return response.json() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_dict(self):\n return {\n 'token': self.token\n }",
"def map_Token_to_dict(t):\n token_info = {}\n token_info[\"word\"] = t.word\n token_info[\"lemma\"] = t.lemma\n token_info[\"msd\"] = t.msd\n token_info[\"pos\"] = t.pos\n token_info[\"saldo\"] = t.saldo\n to... | [
"0.80920255",
"0.718855",
"0.6785313",
"0.64756024",
"0.64157766",
"0.64028114",
"0.6385074",
"0.638287",
"0.63351613",
"0.629746",
"0.62601984",
"0.6139804",
"0.6139804",
"0.6134803",
"0.6105252",
"0.6074431",
"0.607083",
"0.60691285",
"0.6035684",
"0.60228795",
"0.59812164"... | 0.0 | -1 |
Authenticates a user based on the OIDC code flow. | def authenticate(self, request, **kwargs):
self.request = request
if not self.request:
return None
state = self.request.GET.get('state')
code = self.request.GET.get('code')
nonce = kwargs.pop('nonce', None)
if not code or not state:
return None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authenticate_user(authentication_code):\n\n for suffix in ('', '=', '=='):\n attempt = authentication_code + suffix\n decoded = base64.decodestring(attempt)\n fields = decoded.split('_')\n\n email, user_id, time_stamp, str_hex = fields\n\n if time_stamp < time.time():\n ... | [
"0.6552406",
"0.65238935",
"0.6430285",
"0.6422166",
"0.6393544",
"0.6226487",
"0.62242806",
"0.6216219",
"0.6209499",
"0.6170765",
"0.61462003",
"0.6108177",
"0.6060539",
"0.6059608",
"0.6046146",
"0.6044743",
"0.5983562",
"0.5963158",
"0.5959967",
"0.5950732",
"0.59470534",... | 0.72427773 | 0 |
Design a Level Shifter This will try to design a level shifter to meet a maximum nominal delay, given the load cap | async def async_design(self, cload: float, dmax: float, trf_in: float,
tile_specs: Mapping[str, Any],
k_ratio: float, tile_name: str, inv_input_cap: float,
inv_input_cap_per_fin: float,
fanout: float, vin: str, v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_hp_for_higher_level(chosen_class,level):\n #Checks to see if your character is level 4,8,12,etc.\n def upgradedAbilityAt4(level):\n if level % 4 == 0:\n upgraded_ability = raw_input(\"Level \"+str(level)+\"!\\n Which two abilities would you like t... | [
"0.5806524",
"0.5661719",
"0.5588228",
"0.54654175",
"0.5340579",
"0.5318574",
"0.5254631",
"0.52301764",
"0.5191505",
"0.5189479",
"0.5146751",
"0.51244783",
"0.5120537",
"0.50788593",
"0.5066299",
"0.5063171",
"0.5058308",
"0.50551784",
"0.5052924",
"0.5044664",
"0.50352633... | 0.47604865 | 82 |
Size the core of the LVL Shifter given K_ratio, the ratio of the NMOS to PMOS | def _design_lvl_shift_core_size(cload: float, k_ratio: float, inv_input_cap: float,
fanout: float, is_ctrl: bool) -> Tuple[int, int, int]:
out_inv_input_cap = cload / fanout
print(f'cload = {cload}')
inv_m = int(round(out_inv_input_cap / inv_input_cap))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _SizeCalculator(partition_size):\n # Max image size grows less than partition size, which means\n # footer size grows faster than partition size.\n return int(math.pow(partition_size, 0.95))",
"def pixel_size_ratio(self):\n return 2**(self.levels[-1] - self.levels[0])",
"def _SizeCalc... | [
"0.6188077",
"0.59274673",
"0.58529997",
"0.5746031",
"0.573419",
"0.5615157",
"0.5585702",
"0.5555616",
"0.5553092",
"0.55231327",
"0.5479882",
"0.5438771",
"0.5424427",
"0.542206",
"0.54073846",
"0.5404979",
"0.53181946",
"0.53123444",
"0.53076833",
"0.52982414",
"0.5290943... | 0.6555078 | 0 |
Given the NMOS segments and the PMOS segements ratio for the core, this function designs the internal inverter. For control level shifter, we don't care about matching rise / fall delay, so we just size for fanout. | async def _design_lvl_shift_internal_inv(self, pseg: int, nseg: int, out_inv_m: int,
fanout: float,
pinfo: Any, tbm_specs: Dict[str, Any], is_ctrl: bool,
has_rst: bool, dual_output: boo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _design_lvl_shift_core_size(cload: float, k_ratio: float, inv_input_cap: float,\n fanout: float, is_ctrl: bool) -> Tuple[int, int, int]:\n out_inv_input_cap = cload / fanout\n print(f'cload = {cload}')\n inv_m = int(round(out_inv_input_cap / inv_input_cap... | [
"0.573395",
"0.5689612",
"0.5377648",
"0.52175105",
"0.51980525",
"0.51722646",
"0.5154866",
"0.5073706",
"0.50463784",
"0.49642965",
"0.49641448",
"0.49348933",
"0.49050188",
"0.49022022",
"0.4888358",
"0.48803452",
"0.48743895",
"0.48456818",
"0.4839526",
"0.48382315",
"0.4... | 0.5905445 | 0 |
This function figures out the NMOS nseg for the inverter given the target delay | async def _design_lvl_shift_inv_pdn(self, pseg: int, nseg: int, out_inv_m: int,
fanout: float, pinfo: Any, tbm_specs: Dict[str, Any],
has_rst, dual_output, vin, vout) -> int:
min_fanout: float = get_tech_global_info('bag3_digital')[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getnt(simulation, t=None):\n nt_sim = simulation.nt()\n \n if t is not None:\n \n dummy = np.zeros(nt_sim)\n nt = len2(dummy[t])\n \n else:\n \n nt = nt_sim\n \n return nt",
"def energy_to_image_number(energy_ev=[], delay_us=np.NaN, time_re... | [
"0.49719483",
"0.4935958",
"0.4919428",
"0.48419625",
"0.48085135",
"0.48042274",
"0.47861707",
"0.47344568",
"0.46951145",
"0.46785071",
"0.46723995",
"0.465125",
"0.46384445",
"0.46293303",
"0.46211642",
"0.4601803",
"0.4595982",
"0.45924985",
"0.4588825",
"0.45872933",
"0.... | 0.0 | -1 |
Given the NMOS pull down size, this function will design the PMOS pull up so that the delay mismatch is minimized. | async def _design_lvl_shift_inv_pun(self, pseg: int, nseg: int, inv_nseg: int, out_inv_m: int,
fanout: float,
pinfo: Any, tbm_specs: Dict[str, Any], has_rst, dual_output,
vin, vout) -> Tuple[int, int]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def snspd(wire_width = 0.2, wire_pitch = 0.6, size = (10,8),\n num_squares = None, turn_ratio = 4, terminals_same_side = False,\n layer = 0):\n # Convenience tests to auto-shape the size based\n # on the number of squares\n if num_squares is not None and ((size is None) or ((size[0] is N... | [
"0.504567",
"0.5005425",
"0.4978836",
"0.49669868",
"0.49210796",
"0.49188507",
"0.48736426",
"0.4858349",
"0.4849506",
"0.48208347",
"0.4812086",
"0.4811671",
"0.47960854",
"0.47818014",
"0.4774092",
"0.47568643",
"0.4684301",
"0.4682786",
"0.46726155",
"0.46431875",
"0.4638... | 0.44285044 | 48 |
Given all other sizes and total output inverter segments, this function will optimize the output inverter to minimize rise/fall mismatch. | async def _design_output_inverter(self, inv_in_pseg: int, inv_in_nseg: int, pseg: int,
nseg: int, inv_nseg: int,
inv_pseg: int, out_inv_m: int, fanout: float, pinfo: Any,
tbm_specs: Dict[str, Any], has_rst,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def _design_lvl_shift_internal_inv(self, pseg: int, nseg: int, out_inv_m: int,\n fanout: float,\n pinfo: Any, tbm_specs: Dict[str, Any], is_ctrl: bool,\n has_rst: bool, dual_out... | [
"0.57551074",
"0.5633371",
"0.55631614",
"0.5548981",
"0.54104066",
"0.53518677",
"0.52544314",
"0.52046525",
"0.5193554",
"0.510433",
"0.50876915",
"0.507961",
"0.5076772",
"0.5050112",
"0.5047182",
"0.5028232",
"0.50279135",
"0.50186217",
"0.49814168",
"0.49547577",
"0.4953... | 0.65121347 | 0 |
Creates a dictionary of parameters for the layout class LevelShifterCore | def _get_lvl_shift_core_params_dict(pinfo: Any, seg_p: int, seg_n: int,
has_rst: bool, is_ctrl: bool = False) -> Dict[str, Any]:
global_info = get_tech_global_info('bag3_digital')
wn = global_info['w_minn'] if is_ctrl else 2 * global_info['w_minn']
wp = gl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_params_info(cls):\n return dict(\n config='laygo configuration dictionary.',\n threshold='transistor threshold flavor.',\n draw_boundaries='True to draw boundaries.',\n num_blk='number of driver segments.',\n show_pins='True to draw pin geometri... | [
"0.6594422",
"0.65031415",
"0.64297277",
"0.6422143",
"0.6381749",
"0.61534536",
"0.6128739",
"0.612587",
"0.6112433",
"0.61071366",
"0.60628444",
"0.603704",
"0.60055584",
"0.5990008",
"0.5988576",
"0.59868056",
"0.5950084",
"0.5924208",
"0.5910025",
"0.58566475",
"0.5843962... | 0.6011777 | 12 |
Creates a dictionary of parameters for the layout class LevelShifter | def _get_lvl_shift_params_dict(pinfo: Any, seg_p: int, seg_n: int, seg_inv_p: int,
seg_inv_n: int, seg_in_inv_p: int, seg_in_inv_n: int,
out_inv_m: int, has_rst: bool, dual_output: bool,
is_ctrl: bool = False,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def layout_method_mapper(self):\n return {\n \"kamada_kawai_layout\": kamada_kawai_layout,\n \"fruchterman_reingold_layout\": fruchterman_reingold_layout,\n \"spectral_layout\": spectral_layout,\n }",
"def init_pos_parms(self):\n\n ## init_pos_parms()\n ... | [
"0.617329",
"0.61104554",
"0.60987556",
"0.6021736",
"0.5993616",
"0.596282",
"0.59227943",
"0.5847736",
"0.5747626",
"0.5723274",
"0.57080036",
"0.5674384",
"0.565163",
"0.56308",
"0.5629004",
"0.5618874",
"0.56178457",
"0.56168747",
"0.56168747",
"0.5608124",
"0.5590386",
... | 0.6311791 | 0 |
Handle mocked API request for repo existence check. | def callback_repo_check(self, request, uri, headers, status_code=404):
self.assertEqual(
request.headers['Authorization'],
'token {0}'.format(self.OAUTH2_TOKEN)
)
# Handle the new "rerun" repo differently
if self.TEST_RERUN_REPO in uri:
status_code = 4... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_github_repos_info_positive(self):\n self.assertIsNotNone(app.get_github_repos_info(\"dhh\")[\"repo_info\"])",
"def test_github_api_exists():\n p = github_api.GithubPath.from_repo('tensorflow/datasets', 'v3.1.0')\n with enable_api_call():\n assert p.exists()\n assert not (p / 'unnknown... | [
"0.6614973",
"0.6548657",
"0.6510613",
"0.6494966",
"0.6306936",
"0.6299396",
"0.6290716",
"0.6259003",
"0.625318",
"0.6162342",
"0.6154876",
"0.609253",
"0.6088747",
"0.607778",
"0.60644174",
"0.6063622",
"0.6023541",
"0.600028",
"0.60001606",
"0.59103364",
"0.58970094",
"... | 0.6812977 | 0 |
Mock repo creation API call. | def callback_repo_create(self, request, uri, headers, status_code=201):
# Disabling unused-argument because this is a callback with
# required method signature.
# pylint: disable=unused-argument
self.assertEqual(
request.headers['Authorization'],
'token {0}'.forma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_repository(\n repo_type, response, repository_collection, faker, mocker):\n x_configuration = faker.pydict()\n repository_collection.client.scripts.run.return_value = response\n\n mocker.patch('json.dumps')\n json.dumps.return_value = x_configuration\n\n mocker.patch.object(\n... | [
"0.741694",
"0.7329381",
"0.7204714",
"0.7076258",
"0.6999122",
"0.6988286",
"0.6960335",
"0.6862453",
"0.68590546",
"0.68273866",
"0.68168354",
"0.6659639",
"0.66498876",
"0.66248244",
"0.65726507",
"0.65599334",
"0.6549759",
"0.65463334",
"0.64759225",
"0.6467559",
"0.64593... | 0.7112598 | 3 |
Mock team listing API call. | def callback_team_list(
self, request, uri, headers, status_code=200, more=False
):
# All arguments needed for tests
# pylint: disable=too-many-arguments
self.assertEqual(
request.headers['Authorization'],
'token {0}'.format(self.OAUTH2_TOKEN)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_teams(self):\n pass",
"def test_get_teams(self):\n pass",
"def test_teams_list(self):\n pass",
"def test_retrieve_team(self):\n pass",
"def test_get_list_teams(self):\n args = {\n 'name': 'test team',\n 'capacity': '11',\n 'nu... | [
"0.7832198",
"0.7832198",
"0.7787231",
"0.766385",
"0.76570606",
"0.75967157",
"0.7504579",
"0.7386774",
"0.73839384",
"0.7326292",
"0.727717",
"0.7085672",
"0.70076525",
"0.6997477",
"0.69914085",
"0.69476736",
"0.693627",
"0.68850756",
"0.68613017",
"0.6815415",
"0.68070585... | 0.7038121 | 12 |
Return team membership list | def callback_team_members(
self, request, uri, headers,
status_code=200, members=None
):
# Disabling unused-argument because this is a callback with
# required method signature.
# pylint: disable=unused-argument,too-many-arguments
if members is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_teams():",
"def get_team_list(self):\n result = dict\n managers = User.get_users([UserRole.ProjectManager])\n for manager in managers:\n result.update({manager.get_username(): manager.get_team_members()})\n return build_team_list(result)",
"def get_people(team):",... | [
"0.76556545",
"0.71873957",
"0.71658576",
"0.6852401",
"0.68359214",
"0.67922753",
"0.67901105",
"0.6633291",
"0.6610026",
"0.66014594",
"0.64625037",
"0.6446009",
"0.6441612",
"0.6413571",
"0.63949007",
"0.6385507",
"0.6379801",
"0.6379801",
"0.63730794",
"0.6361104",
"0.634... | 0.5828557 | 78 |
Create a new team as requested | def callback_team_create(
self, request, uri, headers, status_code=201, read_only=True
):
# Disabling unused-argument because this is a callback with
# required method signature.
# pylint: disable=unused-argument,too-many-arguments
self.assertEqual(
request.he... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_team(self):\n pass",
"def post(self):\n req = team_req.parse_args(strict=True)\n curr_user = api.user.get_user()\n if curr_user[\"teacher\"]:\n raise PicoException(\"Teachers may not create teams\", 403)\n req[\"team_name\"] = req[\"team_name\"].strip... | [
"0.8152444",
"0.814473",
"0.8012371",
"0.8007305",
"0.78516024",
"0.7795718",
"0.7782906",
"0.7776992",
"0.7776569",
"0.76310307",
"0.7547328",
"0.74677587",
"0.74334925",
"0.7394837",
"0.73344284",
"0.7300357",
"0.7254561",
"0.72359705",
"0.72048813",
"0.72006017",
"0.717792... | 0.6497525 | 43 |
Manage both add and delete of team membership. ``action_list`` is a list of tuples with (``username``, ``added (bool)``) to track state of membership since this will get called multiple times in one library call. | def callback_team_membership(
request, uri, headers, success=True, action_list=None
):
# pylint: disable=too-many-arguments
username = uri.rsplit('/', 1)[1]
if not success:
status_code = 500
if request.method == 'DELETE':
if success:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def actions(self, request, action_list, group):\n return action_list",
"def add_list(action, user):\n \n userprofile = user.get_profile()\n \n board = userprofile.get_board(action['boardId'])\n \n # Create the list\n l = List()\n l.title = action['what']['title']\n l.color = act... | [
"0.5766691",
"0.5531757",
"0.5485128",
"0.54238945",
"0.53260785",
"0.5270922",
"0.5267349",
"0.52224904",
"0.51530606",
"0.51122624",
"0.4995376",
"0.4994134",
"0.49654278",
"0.49381015",
"0.49172172",
"0.4907861",
"0.4896086",
"0.48836443",
"0.48314428",
"0.48299542",
"0.48... | 0.63153493 | 0 |
Mock adding a repo to a team API call. | def callback_team_repo(self, request, uri, headers, status_code=204):
self.assertEqual(
request.headers['Authorization'],
'token {0}'.format(self.OAUTH2_TOKEN)
)
self.assertIsNotNone(re.match(
'{url}teams/[13]/repos/{org}/({repo}|{rerun_repo})'.format(
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_team_repo_add(self, body):\n httpretty.register_uri(\n httpretty.PUT,\n re.compile(\n r'^{url}teams/\\d+/repos/{org}/({repo}|{rerun_repo})$'.format(\n url=self.URL,\n org=self.ORG,\n repo=re.escape(sel... | [
"0.7141473",
"0.65856546",
"0.6429309",
"0.62477094",
"0.6094817",
"0.60466355",
"0.60456145",
"0.60106695",
"0.59947604",
"0.5952673",
"0.5949856",
"0.59379244",
"0.59319305",
"0.59313947",
"0.5918774",
"0.5888266",
"0.58841544",
"0.58520806",
"0.5811963",
"0.57970244",
"0.5... | 0.6032238 | 7 |
Register repo check URL and method. | def register_repo_check(self, body):
httpretty.register_uri(
httpretty.GET,
re.compile(
'^{url}repos/{org}/({repo}|{repo_rerun})$'.format(
url=self.URL,
org=self.ORG,
repo=re.escape(self.TEST_REPO),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(name, url):\n click.echo(\"registered repo {} at url {}\".format(name, url))",
"def addRepository(self, uri):\n pass",
"def register(self, hook_url):\n raise NotImplementedError()",
"def add_repo(repo_name, url):\n\n # First, validate the URL\n if not utils.is_valid_url(url):\n... | [
"0.648579",
"0.60714537",
"0.58604896",
"0.5853189",
"0.58087116",
"0.5801936",
"0.5749618",
"0.5737087",
"0.5730165",
"0.571998",
"0.5632852",
"0.5463911",
"0.54567236",
"0.53939337",
"0.53857875",
"0.5376803",
"0.53699636",
"0.52942485",
"0.5257235",
"0.5177173",
"0.5175245... | 0.7127913 | 0 |
Register url for repo create. | def register_repo_create(self, body):
httpretty.register_uri(
httpretty.POST,
'{url}orgs/{org}/repos'.format(
url=self.URL,
org=self.ORG,
),
body=body
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(name, url):\n click.echo(\"registered repo {} at url {}\".format(name, url))",
"def repository_create_hosted():\n pass",
"def repo_add(self, name, url, **kwargs):\n\n self.helm_client.repo_add(name, url, **kwargs)",
"def addRepository(self, uri):\n pass",
"def addRepository(self... | [
"0.7228415",
"0.69657815",
"0.66111845",
"0.6596335",
"0.6379819",
"0.6372043",
"0.6295349",
"0.62912536",
"0.62566435",
"0.62522775",
"0.6242981",
"0.61664414",
"0.6139451",
"0.60608256",
"0.6047676",
"0.60390604",
"0.60049415",
"0.59894115",
"0.5982883",
"0.5956164",
"0.593... | 0.76181614 | 0 |
Simple hook creation URL registration. | def register_hook_create(self, body, status):
test_url = '{url}repos/{org}/{repo}/hooks'.format(
url=self.URL,
org=self.ORG,
repo=self.TEST_REPO
)
# Register for hook endpoint
httpretty.register_uri(
httpretty.POST,
test_url,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_url(url, handler, name=None, kwargs=None):\n if name is None and kwargs is None:\n app_config.urls.append((url, handler))\n return\n\n if name is None:\n app_config.urls.append((url, handler, kwargs))\n return\n\n app_config.urls.append((url, handler, kwargs, name)... | [
"0.7065106",
"0.6987261",
"0.69342375",
"0.6807452",
"0.6751295",
"0.66805863",
"0.66070133",
"0.64777035",
"0.643182",
"0.63921785",
"0.6343328",
"0.63177997",
"0.6295365",
"0.6255854",
"0.62248653",
"0.6210918",
"0.6169819",
"0.6090442",
"0.601174",
"0.59947973",
"0.5945518... | 0.55894935 | 55 |
Simple hook list URL. | def register_hook_list(self, body=None, status=200):
if body is None:
body = json.dumps(
[{
'url': '{url}repos/{org}/{repo}/hooks/1'.format(
url=self.URL, org=self.ORG, repo=self.TEST_REPO
)
}]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def url(self):\n return reverse('snippet-list')",
"def getURLs():",
"def list(self):\n return self._post(\n request=ApiActions.LIST.value,\n uri=ApiUri.HOOKS.value,\n ).get('hooks')",
"def url_list(path):\n match = re.match(r'^.*(/wa/[A-Za-z0-9/-]+)([A-Za-z-]+)/(... | [
"0.61078",
"0.60590255",
"0.60329723",
"0.60213965",
"0.6001832",
"0.5835626",
"0.5812988",
"0.5810151",
"0.575069",
"0.568352",
"0.56398803",
"0.5614848",
"0.5573087",
"0.54942304",
"0.54856974",
"0.54843545",
"0.5479251",
"0.54742557",
"0.5471129",
"0.54698616",
"0.5446562"... | 0.6599427 | 0 |
Simple hook list URL. | def register_hook_delete(self, status=204):
test_url = '{url}repos/{org}/{repo}/hooks/1'.format(
url=self.URL,
org=self.ORG,
repo=self.TEST_REPO
)
# Register for hook endpoint
httpretty.register_uri(
httpretty.DELETE,
test_url,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_hook_list(self, body=None, status=200):\n if body is None:\n body = json.dumps(\n [{\n 'url': '{url}repos/{org}/{repo}/hooks/1'.format(\n url=self.URL, org=self.ORG, repo=self.TEST_REPO\n )\n }... | [
"0.6599427",
"0.61078",
"0.60590255",
"0.60329723",
"0.60213965",
"0.6001832",
"0.5835626",
"0.5812988",
"0.5810151",
"0.575069",
"0.568352",
"0.56398803",
"0.5614848",
"0.5573087",
"0.54942304",
"0.54856974",
"0.54843545",
"0.5479251",
"0.54742557",
"0.5471129",
"0.54698616"... | 0.0 | -1 |
Team membership list API. | def register_team_members(self, body):
httpretty.register_uri(
httpretty.GET,
re.compile(
r'^{url}teams/\d+/members$'.format(
url=re.escape(self.URL)
)
),
body=body
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_list_my_memberships_member(self):\n url = '/api/v1/communities/0/list_my_memberships/'\n\n response = self.client.get(url, HTTP_AUTHORIZATION=self.auth('user3'))\n self.assertEqual(status.HTTP_200_OK, response.status_code)\n\n data = response.data\n self.assertEqual(3, d... | [
"0.6860412",
"0.68018156",
"0.6789227",
"0.6723566",
"0.6712711",
"0.65723747",
"0.6512672",
"0.6378553",
"0.63683796",
"0.63451695",
"0.6340732",
"0.633752",
"0.6332788",
"0.6235343",
"0.6208743",
"0.61913913",
"0.6188811",
"0.6170523",
"0.61651313",
"0.6150756",
"0.61351734... | 0.5718576 | 63 |
Register adding and removing team members. | def register_team_membership(self, body):
url_regex = re.compile(r'^{url}teams/\d+/memberships/\w+$'.format(
url=re.escape(self.URL),
))
httpretty.register_uri(
httpretty.PUT, url_regex, body=body
)
httpretty.register_uri(
httpretty.DELETE, url... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_team_member(self):\n pass",
"def register_team_members(self, body):\n httpretty.register_uri(\n httpretty.GET,\n re.compile(\n r'^{url}teams/\\d+/members$'.format(\n url=re.escape(self.URL)\n )\n ),\n ... | [
"0.68252176",
"0.65158945",
"0.6490704",
"0.639203",
"0.6363671",
"0.63076943",
"0.62758386",
"0.61730903",
"0.6119535",
"0.6111411",
"0.60833365",
"0.605366",
"0.60312194",
"0.59802115",
"0.5968567",
"0.5962732",
"0.592363",
"0.5835005",
"0.5833699",
"0.58229077",
"0.5815000... | 0.6414152 | 3 |
Register team repo addition. | def register_team_repo_add(self, body):
httpretty.register_uri(
httpretty.PUT,
re.compile(
r'^{url}teams/\d+/repos/{org}/({repo}|{rerun_repo})$'.format(
url=self.URL,
org=self.ORG,
repo=re.escape(self.TEST_REPO),... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(name, url):\n click.echo(\"registered repo {} at url {}\".format(name, url))",
"def _RegisterAmberRepository(self, tuf_repo, remote_port):\n\n # Extract the public signing key for inclusion in the config file.\n root_keys = []\n root_json_path = os.path.join(tuf_repo, 'repository', 'root.json... | [
"0.6898738",
"0.6489705",
"0.64307415",
"0.6304983",
"0.6265113",
"0.6264515",
"0.6212561",
"0.61818516",
"0.6177951",
"0.61501896",
"0.60574985",
"0.5968487",
"0.58513224",
"0.57982254",
"0.57399786",
"0.5735879",
"0.5716812",
"0.5707634",
"0.5682229",
"0.5664063",
"0.56495"... | 0.75826085 | 0 |
Return tables of cells in neuronPop population name connected to mitrals specified in args, via neuronProj projection name if args is not specified get all. | def exportTable(network, neuronProj, neuronPop, colours, \
args={}, spikes=True, allcells=True):
exportDict = {'spikes':spikes,'data_tables':[]}
if array(colours).shape == (3,): coloursList = False
else: coloursList = True
## get cells connected to mitrals specified in args. if not specified... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getCellsByMitralConnection(args, network, projection, population, allcells=False):\n cellList = []\n cellUniques = []\n if args.has_key('mitrals'):\n for mitid in args['mitrals']:\n mitpath = 'mitrals_'+str(mitid)\n cellnum = 0\n if projection in network.project... | [
"0.5612893",
"0.5285766",
"0.5185361",
"0.5045113",
"0.5007588",
"0.49609387",
"0.49419475",
"0.48437467",
"0.48161486",
"0.48034397",
"0.47943878",
"0.4792616",
"0.4761036",
"0.4739973",
"0.4637608",
"0.45978764",
"0.45735255",
"0.45684016",
"0.45425737",
"0.45364887",
"0.45... | 0.5903073 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.