query stringlengths 9 9.05k | document stringlengths 10 222k | metadata dict | negatives listlengths 30 30 | negative_scores listlengths 30 30 | document_score stringlengths 4 10 | document_rank stringclasses 2
values |
|---|---|---|---|---|---|---|
(Personalization Only) The storage account connection string. | def storage_account_connection_string(self) -> Optional[str]:
return pulumi.get(self, "storage_account_connection_string") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rdb_storage_connection_string(self) -> str:\n return pulumi.get(self, \"rdb_storage_connection_string\")",
"def account_connection_string(self) -> str:\n return pulumi.get(self, \"account_connection_string\")",
"def storage_account(self) -> str:\n return pulumi.get(self, \"storage_acco... | [
"0.78525084",
"0.77868885",
"0.7490864",
"0.7084924",
"0.68205947",
"0.680374",
"0.6798149",
"0.65964776",
"0.6592029",
"0.65299773",
"0.63563156",
"0.6331491",
"0.63102967",
"0.6303591",
"0.62777317",
"0.6277717",
"0.6274107",
"0.6228608",
"0.6228479",
"0.6141211",
"0.614121... | 0.8600586 | 0 |
(Metrics Advisor Only) The super user of Metrics Advisor. | def super_user(self) -> Optional[str]:
return pulumi.get(self, "super_user") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user(self):\n pass",
"def user(self):\n return self.getattr('user')",
"def user(self):\n return self._forced_user",
"def get_user(self):\n return None",
"def user(self):\n return self._user",
"def user(self):\n return self._user",
"def user(self):\n ... | [
"0.6955923",
"0.66741955",
"0.66067237",
"0.6595119",
"0.6546568",
"0.6546568",
"0.6546568",
"0.6546568",
"0.65376055",
"0.64804995",
"0.6439071",
"0.6429419",
"0.63909256",
"0.63909256",
"0.6382017",
"0.6368345",
"0.63560563",
"0.6195999",
"0.6175691",
"0.6140341",
"0.612710... | 0.7323845 | 0 |
(Metrics Advisor Only) The website name of Metrics Advisor. | def website_name(self) -> Optional[str]:
return pulumi.get(self, "website_name") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSiteName():\n return os.environ['SITENAME']",
"def site_name(self, obj):\n site = obj.site\n return (\"%s\" % (site.name))",
"def sitename(self) :\n\t\ttry :\n\t\t\treturn self._sitename\n\t\texcept Exception as e:\n\t\t\traise e",
"def bucket_website_domain_name(self) -> str:\n ... | [
"0.69923437",
"0.69106567",
"0.6616829",
"0.6565683",
"0.6469414",
"0.6435438",
"0.6411144",
"0.6411144",
"0.6380905",
"0.6277378",
"0.62384963",
"0.62384963",
"0.617236",
"0.61205363",
"0.60646456",
"0.605211",
"0.59489995",
"0.5926967",
"0.5890607",
"0.588797",
"0.5839904",... | 0.7566009 | 0 |
The renewal period in seconds of Call Rate Limit. | def renewal_period(self) -> Optional[float]:
return pulumi.get(self, "renewal_period") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def expirePeriodInSeconds(self)->int:\n return self._lic.params['periodInSeconds'].value",
"def refresh_period(self):\n return int(self.__get_option('refresh_period'))",
"def update_period(self):\n return 0.1",
"def refresh_period_in_seconds(self) -> Optional[pulumi.Input[int]]:\n ... | [
"0.7220695",
"0.68607104",
"0.66482574",
"0.6505736",
"0.64645785",
"0.6337664",
"0.62624717",
"0.62323433",
"0.6031927",
"0.6022835",
"0.6014422",
"0.60099036",
"0.60031545",
"0.60031545",
"0.60031545",
"0.5978044",
"0.59692264",
"0.59621155",
"0.5960568",
"0.5960568",
"0.59... | 0.73784405 | 0 |
Cognitive Services account commitment quota. | def quota(self) -> 'outputs.CommitmentQuotaResponse':
return pulumi.get(self, "quota") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def online_quota(self):\r\n return self.max_contributions - self.num_tickets_total",
"def account_space(access_token):\n client = dropbox.client.DropboxClient(access_token)\n account_info = client.account_info()\n quota_info = account_info['quota_info']\n total = quota_info['quota']\n used ... | [
"0.6712958",
"0.65523666",
"0.6515917",
"0.631611",
"0.60914433",
"0.6000025",
"0.57346606",
"0.5602452",
"0.5518095",
"0.551689",
"0.54627246",
"0.545674",
"0.5402079",
"0.53996605",
"0.53487813",
"0.5334519",
"0.53081733",
"0.5271333",
"0.5261874",
"0.519679",
"0.5194432",
... | 0.76280224 | 0 |
The Azure resource id of the commitment plan. | def commitment_plan_id(self) -> Optional[str]:
return pulumi.get(self, "commitment_plan_id") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plan_id(self) -> str:\n return self._plan_id",
"def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")",
"def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")",
"def resource_id(self) -> str:\n return pulumi.get(self, \"resource_id\")",
... | [
"0.7716365",
"0.6851893",
"0.6851893",
"0.6851893",
"0.6644602",
"0.6575877",
"0.6432363",
"0.643091",
"0.643091",
"0.6401933",
"0.6401933",
"0.6401933",
"0.6401933",
"0.6401933",
"0.6317398",
"0.6317398",
"0.6317398",
"0.6297618",
"0.6297618",
"0.6297618",
"0.6297618",
"0.... | 0.7871174 | 0 |
The location of of the commitment plan. | def commitment_plan_location(self) -> Optional[str]:
return pulumi.get(self, "commitment_plan_location") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def commitment_plan_id(self) -> Optional[str]:\n return pulumi.get(self, \"commitment_plan_id\")",
"def plan(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"plan\")",
"def _course_location(self):\r\n return \"location:{org}+{number}+{run}+course+{run}\".format(**self._cou... | [
"0.6826332",
"0.6241266",
"0.61446285",
"0.60929376",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60332566",
"0.60002583",
"0.60002583",
"0.60002583",
... | 0.8788695 | 0 |
Cognitive Services account commitment period. | def last(self) -> 'outputs.CommitmentPeriodResponse':
return pulumi.get(self, "last") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def current(self) -> Optional['outputs.CommitmentPeriodResponse']:\n return pulumi.get(self, \"current\")",
"def get_period_guarantee_advance(self):\n return ceiling(self.scheduled_completion, 3)",
"def current_effective_deadline(cls) -> float:",
"def next(self) -> Optional['outputs.CommitmentP... | [
"0.5595547",
"0.556296",
"0.5546404",
"0.5526741",
"0.52279395",
"0.5222263",
"0.5204489",
"0.51837915",
"0.5149062",
"0.5121727",
"0.5081491",
"0.5066678",
"0.50160015",
"0.5004779",
"0.49921027",
"0.49675107",
"0.49551263",
"0.4941851",
"0.49270973",
"0.49227467",
"0.491820... | 0.6236221 | 0 |
The list of ProvisioningIssue. | def provisioning_issues(self) -> Sequence[str]:
return pulumi.get(self, "provisioning_issues") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_issues(self) -> [\"AIOGitHubAPIRepositoryIssue\"]:\n _endpoint = f\"/repos/{self.full_name}/issues\"\n\n response = await self.client.get(endpoint=_endpoint)\n return [AIOGitHubAPIRepositoryIssue(self.client, x) for x in response or []]",
"def issues(self) -> Iterable[Issue]:\n... | [
"0.63413113",
"0.6226929",
"0.61056864",
"0.6073216",
"0.6073216",
"0.60230535",
"0.5824415",
"0.57908684",
"0.5765761",
"0.57227564",
"0.56972843",
"0.5593333",
"0.555865",
"0.545716",
"0.5440722",
"0.54217577",
"0.5414522",
"0.541265",
"0.5391178",
"0.5390083",
"0.5378608",... | 0.7382787 | 0 |
Cognitive Services account commitment period. | def current(self) -> Optional['outputs.CommitmentPeriodResponse']:
return pulumi.get(self, "current") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def last(self) -> 'outputs.CommitmentPeriodResponse':\n return pulumi.get(self, \"last\")",
"def get_period_guarantee_advance(self):\n return ceiling(self.scheduled_completion, 3)",
"def current_effective_deadline(cls) -> float:",
"def next(self) -> Optional['outputs.CommitmentPeriodResponse']:... | [
"0.6236221",
"0.556296",
"0.5546404",
"0.5526741",
"0.52279395",
"0.5222263",
"0.5204489",
"0.51837915",
"0.5149062",
"0.5121727",
"0.5081491",
"0.5066678",
"0.50160015",
"0.5004779",
"0.49921027",
"0.49675107",
"0.49551263",
"0.4941851",
"0.49270973",
"0.49227467",
"0.491820... | 0.5595547 | 1 |
The call rate limit Cognitive Services account. | def call_rate_limit(self) -> 'outputs.CallRateLimitResponse':
return pulumi.get(self, "call_rate_limit") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rate_limit(self):\n resp = self._session.get(self.API_ROOT + \"/rate_limit\")\n log.info(resp.text)",
"def ctx(self):\n return RateLimitContextBase()",
"def get_rate_limit(client):\n query = '''query {\n rateLimit {\n limit\n remaining\n r... | [
"0.6358268",
"0.6162561",
"0.60568434",
"0.5990054",
"0.5918794",
"0.58661646",
"0.573936",
"0.57365024",
"0.5668265",
"0.5640884",
"0.56161267",
"0.5614316",
"0.5562859",
"0.5551392",
"0.5523943",
"0.5515391",
"0.54717577",
"0.54716563",
"0.5464131",
"0.5456545",
"0.54448587... | 0.73106307 | 0 |
The call rate limit Cognitive Services account. | def call_rate_limit(self) -> 'outputs.CallRateLimitResponse':
return pulumi.get(self, "call_rate_limit") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_rate_limit(self):\n resp = self._session.get(self.API_ROOT + \"/rate_limit\")\n log.info(resp.text)",
"def ctx(self):\n return RateLimitContextBase()",
"def get_rate_limit(client):\n query = '''query {\n rateLimit {\n limit\n remaining\n r... | [
"0.6358268",
"0.6162561",
"0.60568434",
"0.5990054",
"0.5918794",
"0.58661646",
"0.573936",
"0.57365024",
"0.5668265",
"0.5640884",
"0.56161267",
"0.5614316",
"0.5562859",
"0.5551392",
"0.5523943",
"0.5515391",
"0.54717577",
"0.54716563",
"0.5464131",
"0.5456545",
"0.54448587... | 0.73106307 | 1 |
Deployment model version upgrade option. | def version_upgrade_option(self) -> Optional[str]:
return pulumi.get(self, "version_upgrade_option") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def upgrade(self, old_version, new_version):\n pass",
"def auto_minor_version_upgrade(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"auto_minor_version_upgrade\")",
"def auto_minor_version_upgrade(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"auto_m... | [
"0.6301088",
"0.6108278",
"0.6108278",
"0.6108278",
"0.6108278",
"0.6100564",
"0.60524964",
"0.60524964",
"0.60400146",
"0.6026032",
"0.60177636",
"0.60177636",
"0.5922572",
"0.5913727",
"0.58997905",
"0.5865239",
"0.5865239",
"0.5865239",
"0.579891",
"0.578187",
"0.5762119",... | 0.6563416 | 0 |
Deployment active capacity. This value might be different from `capacity` if customer recently updated `capacity`. | def active_capacity(self) -> int:
return pulumi.get(self, "active_capacity") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def capacity(self) -> Optional[int]:\n return pulumi.get(self, \"capacity\")",
"def capacity(self) -> Optional[int]:\n return pulumi.get(self, \"capacity\")",
"def capacity(self) -> Optional[int]:\n return pulumi.get(self, \"capacity\")",
"def capacity(self) -> Optional[int]:\n re... | [
"0.7532596",
"0.7532596",
"0.7532596",
"0.7532596",
"0.7492223",
"0.745867",
"0.7449016",
"0.7422382",
"0.7390689",
"0.7366575",
"0.72826654",
"0.72591174",
"0.72591174",
"0.72591174",
"0.72591174",
"0.72591174",
"0.72591174",
"0.72591174",
"0.7257428",
"0.72303516",
"0.71830... | 0.84809434 | 0 |
Version of the Key from KeyVault | def key_version(self) -> Optional[str]:
return pulumi.get(self, "key_version") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def version_template(self) -> pulumi.Output['outputs.CryptoKeyVersionTemplateResponse']:\n return pulumi.get(self, \"version_template\")",
"def get_key_request(self, vault_name: str, key_name: str, key_version: str) -> dict[str, Any]:\n\n url = f'https://{vault_name}{self.azure_cloud.suffixes.keyva... | [
"0.6438031",
"0.63502395",
"0.63091785",
"0.62830764",
"0.62450016",
"0.6224766",
"0.62174904",
"0.6146448",
"0.6091593",
"0.5932736",
"0.5924557",
"0.5905134",
"0.5850796",
"0.5846698",
"0.5845496",
"0.57633024",
"0.5708141",
"0.5634579",
"0.5590769",
"0.5518944",
"0.5513102... | 0.6812989 | 0 |
The list of virtual network rules. | def virtual_network_rules(self) -> Optional[Sequence['outputs.VirtualNetworkRuleResponse']]:
return pulumi.get(self, "virtual_network_rules") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def virtual_network_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"virtual_network_rules\")",
"def virtual_network_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageAccountSpecNetworkRuleVirtualNetworkRulesArgs']]]]:\n return pulumi.... | [
"0.776357",
"0.77235216",
"0.76376677",
"0.7382955",
"0.7215082",
"0.6944976",
"0.6879922",
"0.68092316",
"0.65993077",
"0.63442385",
"0.629894",
"0.6288252",
"0.62423277",
"0.6196568",
"0.6196568",
"0.61666393",
"0.61666393",
"0.6166045",
"0.61336064",
"0.6104291",
"0.608563... | 0.792192 | 1 |
Maps the region to the regional custom subdomain. | def customsubdomain(self) -> Optional[str]:
return pulumi.get(self, "customsubdomain") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bucket_regional_domain_name(self) -> str:\n ...",
"def custom_sub_domain_name(self) -> Optional[str]:\n return pulumi.get(self, \"custom_sub_domain_name\")",
"def bucket_regional_domain_name(self) -> str:\n return jsii.get(self, \"bucketRegionalDomainName\")",
"def bucket_regional_do... | [
"0.66863793",
"0.5875713",
"0.584936",
"0.584936",
"0.5845517",
"0.58098024",
"0.58075595",
"0.5707554",
"0.56916225",
"0.55765885",
"0.5548106",
"0.5548106",
"0.5548106",
"0.55425155",
"0.55297667",
"0.5515043",
"0.5466608",
"0.54244334",
"0.53858924",
"0.5385837",
"0.532729... | 0.61522025 | 1 |
Gets the count of downgrades. | def count_of_downgrades(self) -> Optional[float]:
return pulumi.get(self, "count_of_downgrades") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_of_upgrades_after_downgrades(self) -> Optional[float]:\n return pulumi.get(self, \"count_of_upgrades_after_downgrades\")",
"def count_downvotes(self):\n return self.filter(value=-1).count()",
"def data_downgrades():\n pass",
"def data_downgrades():\n pass",
"def get_downlink_c... | [
"0.8287235",
"0.67211527",
"0.62132925",
"0.62132925",
"0.6082984",
"0.6066136",
"0.59956974",
"0.59314454",
"0.5926545",
"0.58456475",
"0.57416725",
"0.563767",
"0.5635512",
"0.56127214",
"0.55500185",
"0.54669005",
"0.5453762",
"0.5427202",
"0.542651",
"0.54143727",
"0.5398... | 0.8500595 | 0 |
Gets the count of upgrades after downgrades. | def count_of_upgrades_after_downgrades(self) -> Optional[float]:
return pulumi.get(self, "count_of_upgrades_after_downgrades") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_of_downgrades(self) -> Optional[float]:\n return pulumi.get(self, \"count_of_downgrades\")",
"def getUpgrades(self) -> list:\n return self.state[UPGRADES]",
"def count_downvotes(self):\n return self.filter(value=-1).count()",
"def dump_updown_count(self):\n raise NotImpl... | [
"0.7273881",
"0.62744755",
"0.5958437",
"0.58793324",
"0.58278257",
"0.5820554",
"0.5820554",
"0.5792164",
"0.578981",
"0.57145786",
"0.5697508",
"0.56740063",
"0.5644544",
"0.5571523",
"0.5564085",
"0.55153704",
"0.5468588",
"0.54553634",
"0.5416293",
"0.5406054",
"0.5377968... | 0.8690283 | 0 |
Gets the last change date. | def last_change_date(self) -> Optional[str]:
return pulumi.get(self, "last_change_date") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def svn_info_t_last_changed_date_get(svn_info_t_self): # real signature unknown; restored from __doc__\n pass",
"def dt_last_update(self):\n return self.last_update",
"def status_change_date(self) -> str:\n return pulumi.get(self, \"status_change_date\")",
"def __last_commit_date(self):\n ... | [
"0.7332252",
"0.7219531",
"0.71956813",
"0.71701235",
"0.71467483",
"0.7004979",
"0.69549567",
"0.69372267",
"0.69336087",
"0.68705344",
"0.68644184",
"0.68644184",
"0.6829638",
"0.68113947",
"0.67973435",
"0.6780454",
"0.67783314",
"0.6749812",
"0.67184407",
"0.67096853",
"0... | 0.8572634 | 0 |
Ignore missing vnet service endpoint or not. | def ignore_missing_vnet_service_endpoint(self) -> Optional[bool]:
return pulumi.get(self, "ignore_missing_vnet_service_endpoint") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ignore_missing_v_net_service_endpoint(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"ignore_missing_v_net_service_endpoint\")",
"def ignore_missing_service_endpoint(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"ignore_missing_service_endpoint\")",
"def... | [
"0.75127226",
"0.666186",
"0.65345496",
"0.61584747",
"0.5785869",
"0.566079",
"0.5657597",
"0.5604734",
"0.5506748",
"0.54837817",
"0.5482908",
"0.53341347",
"0.52935594",
"0.52466923",
"0.5243484",
"0.52242935",
"0.52234066",
"0.52123487",
"0.5211851",
"0.5159619",
"0.51533... | 0.81507653 | 0 |
Return a list containing files in current working directory | def get_all_files(cwd):
return os.listdir(cwd) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getFiles(self):\n\t\treturn os.listdir(self.getPath())",
"def get_my_files():\n return [file for file in os.listdir(os.getcwd()) if os.path.isfile(file)]",
"def files_in_dir(path):\n return os.listdir(path)",
"def list_files(path):\n ls_output = os.listdir(path)\n return ls_output",
"def ge... | [
"0.8243705",
"0.7986272",
"0.78300756",
"0.7797188",
"0.77566135",
"0.7747943",
"0.7612247",
"0.75997365",
"0.75865906",
"0.7568702",
"0.7565383",
"0.754392",
"0.74458206",
"0.74326265",
"0.7400026",
"0.73980325",
"0.738138",
"0.7292439",
"0.7267739",
"0.7262558",
"0.72419256... | 0.82731485 | 0 |
Return a list of folder name | def folder_name(self):
folders = []
for folder in self.folders:
folders.append(folder)
return folders | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_folder_list(args):\n\tif not args.folders:\n\t\treturn None\n\n\tif os.path.isfile(args.folders):\n\t\treturn [x.strip() for x in list(open(args.folders, 'r'))]\n\n\telse:\n\t\treturn [x.strip() for x in args.folders.split(',')]",
"def get_list_of_folders(self, end_of_folder_name):\n folder_list =... | [
"0.76186156",
"0.7430843",
"0.73491526",
"0.73406965",
"0.71975374",
"0.71707374",
"0.7130499",
"0.7100979",
"0.70779717",
"0.70659024",
"0.7000448",
"0.6987247",
"0.69868743",
"0.696074",
"0.683982",
"0.68326867",
"0.682668",
"0.68047774",
"0.67565644",
"0.6719934",
"0.67135... | 0.863706 | 0 |
Return a list of folder type | def folder_type(self):
types = []
for type in self.folders_type:
types.append(type)
return types | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_folder_files(folder, types):\n files_grabed = []\n for file_type in types:\n files_grabed.extend(glob.glob(os.path.join(folder, file_type)))\n return files_grabed",
"def folder_name(self): \n folders = []\n for folder in self.folders:\n folders.append(folder)\n ... | [
"0.7214165",
"0.6907222",
"0.6847481",
"0.65982836",
"0.65898377",
"0.6582917",
"0.6539961",
"0.64663464",
"0.64614886",
"0.6460519",
"0.6443383",
"0.64318335",
"0.6402228",
"0.63659465",
"0.632687",
"0.63254786",
"0.62755585",
"0.6269897",
"0.6251558",
"0.6250081",
"0.624549... | 0.8790956 | 0 |
Test the ability to gather sequence | def testGetSequence():
#a few of hand-tested genome positions
test_data = [ ('1',500,520,'GTCTGACCTGAGGAGAACTGT'),
('2',500,520,'CCCGACCCCGACCCCGACCCA'),
('3',50000,50020,'TCTTCTTTTATGAAAAAGGAT'),
('4',50000,50020,'AGAGCCCTGCAATTTGAAGAT'),
('5',100000,100020,'AATGTTCACCAGTATATTTTA'),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_input_type_seq(self, _run_mock):\n hhblits = self.tool(input_type=hhsuite.QueryType.SEQUENCE)\n self.assertEqual(set(hhblits.REQUIRED), set([\"name\", \"sequence\"]))\n hhblits.run({\"sequence\": self.SEQUENCE, \"name\": self.SEQ_NAME})\n self.verify_common(\"hhblits\", hhblits... | [
"0.61842567",
"0.61777836",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6167748",
"0.6158104",
"0.61537033",
"0.59816474",
"0.59589577",
"0.5941578",
"0.59333587",
"0.5928325",
"0.5923485",
"0.5907195",
"0.5892558... | 0.63319796 | 0 |
API return string and HTTP Bad Request (400) issued when project type is not valid. | def invalid_project_tye_msg(proj_type):
return {"error": f"Project type {proj_type} is not valid, please use one of the following: "
f"{', '.join(project_types)}"}, 400 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_response(project_type, result):\n if project_type not in project_types:\n return invalid_project_tye_msg(project_type)\n return result",
"def bad_request():\n return HttpError(400)",
"def bad_request(self, request, message):\n if request.META.get('CONTENT_TYPE') == 'application/v... | [
"0.70865583",
"0.6068282",
"0.59508896",
"0.5887611",
"0.58829206",
"0.584176",
"0.5705421",
"0.56078774",
"0.56074756",
"0.5575878",
"0.5568863",
"0.55578727",
"0.555444",
"0.5553019",
"0.5551587",
"0.5527737",
"0.5523695",
"0.5515269",
"0.55109483",
"0.54840106",
"0.5443446... | 0.7925061 | 0 |
Wrapper to return the desired api response only if the specified project type is valid | def api_response(project_type, result):
if project_type not in project_types:
return invalid_project_tye_msg(project_type)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_project_or_study(obj_type, obj_id):\n \n response = None\n\n try:\n if obj_type not in set([\"projects\", \"studies\"]):\n raise Exception(\"Invalid object type specified\")\n\n files_d = {}\n files_d.update(file_dict[obj_type][\"valid\"])\n files_d.update(fi... | [
"0.64074504",
"0.584251",
"0.57444906",
"0.5642053",
"0.55687165",
"0.55578846",
"0.5441781",
"0.54382634",
"0.5401079",
"0.5363507",
"0.53115785",
"0.53091395",
"0.5285356",
"0.52749294",
"0.52570665",
"0.52514297",
"0.52415955",
"0.5230785",
"0.5206412",
"0.52010256",
"0.51... | 0.80576724 | 0 |
Function to check for XPath validity. Tries to create an etree ETXPath instance from the query. If this fails, the XPathSyntaxError is excepted to return a False. Returns True otherwise | def is_valid_query(query):
try:
etree.ETXPath(query)
return True
except etree.XPathSyntaxError:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_xpath(xpath, etree):\n try:\n return etree.xpath(xpath)\n except (lxml.etree.XPathSyntaxError, lxml.etree.XPathEvalError):\n raise InvalidXPathExpression(sys.exc_info()[:2], value=xpath)",
"def compile_xpath(xpath, key=None):\n try:\n return lxml.etree.XPath(xpath)\n excep... | [
"0.6174968",
"0.5611842",
"0.54611474",
"0.5443031",
"0.54190075",
"0.54012316",
"0.5400232",
"0.5372852",
"0.5365433",
"0.53124905",
"0.5279214",
"0.5277152",
"0.52084434",
"0.5196005",
"0.5166062",
"0.5154404",
"0.51458836",
"0.51294345",
"0.5126877",
"0.5125673",
"0.508333... | 0.74816614 | 0 |
First checks if the request is a simple dictionary with string keys and string values. If so, the queries in the request message are saved to disk | def process_queries(req, save_dir, replace_allowed):
create_dir_if_not_exists(save_dir)
req_obj = json.loads(req.data)
result_dict = dict()
if not all(map(lambda x: all(map(lambda y: isinstance(y, str), x)), req_obj.items())):
return {"message": f"Not all query names or values are strings"}, 400... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_request(self, request):\n request_dict = self.process_request(request)\n self.ser.info(pickle.dumps(request_dict))\n self.ser.info(REQUEST_UNIQUE_STRING)",
"def test_query_dict_for_request_in_method_post(self):\n self.request.POST = QueryDict(\"foo=bar\")\n response = ... | [
"0.5780125",
"0.561636",
"0.551793",
"0.54183286",
"0.51633644",
"0.51528674",
"0.5141749",
"0.5132121",
"0.5078204",
"0.50738424",
"0.5060169",
"0.5056697",
"0.50541925",
"0.50471795",
"0.5036605",
"0.50358754",
"0.50194955",
"0.500363",
"0.49596575",
"0.4937282",
"0.4927945... | 0.64579356 | 0 |
Returns a query result dictionary, given an ACE Record instance and a dictionary of the XPath queries that need to be executed on this record. | def query_dict_for_record(record, touched_queries):
result = dict()
if len(touched_queries) > 0:
parsed_record = etree.parse(StringIO(record.test_data_xml()))
result.update(dict((q_name, {'query': q_value,
'result': list(x.text for x in etree.ETXPath(q_value)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute_records_query(query):\n result, hits, output = execute_basic(TYPE_RECORD, query)\n for rec in hits.get('hits', []):\n record = rec.get('_source')\n record['score'] = rec.get('_score')\n record['text'] = rec.get('highlight', {}).get('text')\n output['results'].append(re... | [
"0.57072085",
"0.5547496",
"0.5542535",
"0.55252427",
"0.5523193",
"0.5461427",
"0.5346732",
"0.53411245",
"0.53293097",
"0.53058386",
"0.5295658",
"0.5276403",
"0.52639025",
"0.51895535",
"0.51621974",
"0.5137885",
"0.51368797",
"0.51255596",
"0.51243746",
"0.512335",
"0.510... | 0.755422 | 0 |
Endpoint to exercise a message. The message is injected into the flow. For this recording and injection must be temporarily enabled on the flow. Test data is obtained, after which instances of ACERecord are created and sorted on flowSequenceNumber. For each record, an object is created with the fromto node+terminal inf... | def post(self, project_type, project, msgflow, node):
result = dict()
try:
ace_conn.start_recording(project_type, project, msgflow)
ace_conn.start_injection(project_type, project, msgflow)
ace_conn.inject(project_type, project, msgflow, node, request.data)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_echo(self):\n self.add_item(\"skill\", \"fetchai/echo:0.5.0\")\n\n process = self.run_agent()\n is_running = self.is_running(process)\n assert is_running, \"AEA not running within timeout!\"\n\n # add sending and receiving envelope from input/output files\n sender... | [
"0.5372232",
"0.5337886",
"0.5229061",
"0.51248443",
"0.5084246",
"0.5082173",
"0.5059913",
"0.50520146",
"0.5048308",
"0.50415814",
"0.5012191",
"0.5003331",
"0.49835372",
"0.49795404",
"0.49769887",
"0.49708155",
"0.49585548",
"0.49475357",
"0.49267948",
"0.48812303",
"0.48... | 0.5756279 | 0 |
Ask a yes/no question via raw_input() and return their answer. "question" is a string that is presented to the user. "default" is the presumed answer if the user just hits . It must be "yes" (the default), "no" or None (meaning an answer is required of the user). The force option simply sets the answer to default. The ... | def query_yes_no(question, default="yes", force=False):
valid = {"yes":True, "y":True, "ye":True,
"no":False, "n":False}
if default == None:
prompt = " [y/n] "
elif default == "yes":
prompt = " [Y/n] "
elif default == "no":
prompt = " [y/N] "
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def query_yes_no(question, default=\"yes\"):\n valid = {\"yes\":\"yes\", \"y\":\"yes\", \"ye\":\"yes\",\n \"no\":\"no\", \"n\":\"no\"}\n if default == None:\n prompt = \" [y/n] \"\n elif default == \"yes\":\n prompt = \" [Y/n] \"\n elif default == \"no\":\n promp... | [
"0.82480913",
"0.8201619",
"0.8161579",
"0.81534576",
"0.81376886",
"0.81355315",
"0.81342065",
"0.8133191",
"0.8133191",
"0.8130005",
"0.8128684",
"0.8128684",
"0.8128684",
"0.8128684",
"0.8128684",
"0.81278366",
"0.81278366",
"0.81278366",
"0.81278366",
"0.81278366",
"0.812... | 0.85351175 | 0 |
Perform a filtered directory walk. | def filtered_walk(rootdir, filter_fn, include_dirs=None, exclude_dirs=None, get_dirs=False):
flist = []
dlist = []
for root, dirs, files in os.walk(rootdir):
if include_dirs and len(set(root.split(os.sep)).intersection(set(include_dirs))) == 0:
## Also try re.search in case we have patte... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter(self):\n self._printer('Standard Walk')\n count = Counter(length=3)\n for directory in self.directory:\n self._printer('Searching ' + directory)\n for root, directories, files in os.walk(directory, topdown=self.topdown):\n root = root[len(str(dir... | [
"0.7196122",
"0.6588966",
"0.6396584",
"0.6380269",
"0.6349008",
"0.63149124",
"0.61969244",
"0.61103547",
"0.60762525",
"0.6074421",
"0.60585856",
"0.6046986",
"0.60449713",
"0.6044598",
"0.60307413",
"0.6027791",
"0.60122037",
"0.599719",
"0.5978354",
"0.5976603",
"0.597657... | 0.6661728 | 1 |
Transform option list to a dictionary. | def opt_to_dict(opts):
if isinstance(opts, dict):
return
args = list(itertools.chain.from_iterable([x.split("=") for x in opts]))
opt_d = {k: True if v.startswith('-') else v
for k,v in zip(args, args[1:]+["--"]) if k.startswith('-')}
return opt_d | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_options(option_list: List[str]) -> Dict[str, Union[int, float, str]]:\n d = dict()\n for o in option_list:\n o = o.split('=')\n if len(o) != 3:\n raise OptionParsingError(\"Not enough elements in the parsed options. Need 3 elements.\")\n key = o[0]\n val = o[1... | [
"0.6948613",
"0.661204",
"0.6580496",
"0.65647084",
"0.65088916",
"0.6373278",
"0.6370471",
"0.63431555",
"0.6230479",
"0.6225121",
"0.61512506",
"0.6135905",
"0.60848534",
"0.6042554",
"0.6006351",
"0.5991005",
"0.59683454",
"0.58970153",
"0.5887909",
"0.5887085",
"0.5885839... | 0.6884359 | 1 |
Remove unwanted options from an option list. | def prune_option_list(opts, keys):
opt_d = opt_to_dict(opts)
for k in keys:
if k in opt_d:
del opt_d[k]
return [k for item in opt_d.iteritems() for k in item] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sanitize(self, opts_list):\n for opt in opts_list:\n if len(opt.strip()) == 0:\n opts_list.remove(opt)\n return opts_list",
"def remove_all(self):\n self._options.clear()\n self._programs.clear()",
"def replace_unacceptable_options(options, is_request)... | [
"0.7164903",
"0.62534535",
"0.62313527",
"0.6177054",
"0.6156464",
"0.61167467",
"0.598523",
"0.5968531",
"0.5958963",
"0.5934466",
"0.5840218",
"0.5644665",
"0.5616773",
"0.55490786",
"0.55408776",
"0.551189",
"0.5459334",
"0.54491204",
"0.54466665",
"0.54283345",
"0.5392538... | 0.7166121 | 0 |
Make a paper plot for the Ohmic (or linear) mobility of the RTA, lowfield, and fulldrift solutions. | def linear_mobility_paperplot(fieldVector,df):
vcm = np.array(fieldVector) * 1e-2
lw = 1.5
mu_1 = []
mu_2 = []
mu_3 = []
meanE_1 = []
meanE_2 = []
meanE_3 = []
for ee in fieldVector:
chi_1_i = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '1_' + "E_{:.1e}.npy".format(ee))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def small_signal_mobility_paperplot(fieldVector, freqVector, df):\n vcm = np.array(fieldVector)*1e-2\n n = utilities.calculate_density(df)\n lw = 1.5\n fig, ax = plt.subplots()\n for freq in freqVector:\n cond = []\n mu_3 = []\n for ee in fieldVector:\n chi_3_i = np.l... | [
"0.6821178",
"0.64246243",
"0.6286595",
"0.626816",
"0.6249688",
"0.6224722",
"0.6198306",
"0.6154236",
"0.613358",
"0.61210513",
"0.6096487",
"0.6086529",
"0.6069941",
"0.598622",
"0.59854215",
"0.5982351",
"0.59644985",
"0.59618616",
"0.59519553",
"0.59491116",
"0.59424275"... | 0.65401083 | 1 |
Make a paper plot for the momentum KDE of the lowfield, and fulldrift solutions. | def momentum_kde_paperplot(fields):
fig, (ax1, ax2, ax3) = plt.subplots(nrows=3, sharex=True)
axisList = [ax1,ax2,ax3]
i =0
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
for ee in fields:
ee_Vcm = ee/100
textstr = r'$E_{k_x}\, = \, %.1f \, V \, cm^{-1}$' % ee_Vcm
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def momentum_kde2_paperplot(fields):\n plt.figure(figsize=(2.65, 2.5))\n ax = plt.axes([0.18, 0.17, 0.8, 0.8])\n colorList = [med_color, high_color]\n lw = 1.5\n i = 0\n meankx_2 = []\n meankx_3 = []\n k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + \"E_{:.1e}.npy\".format(... | [
"0.7816318",
"0.70826715",
"0.6468687",
"0.61942935",
"0.6098648",
"0.60919285",
"0.59449416",
"0.58786696",
"0.5867492",
"0.58451384",
"0.5830002",
"0.58245164",
"0.5811453",
"0.5785101",
"0.5761999",
"0.57525295",
"0.57412106",
"0.5740107",
"0.5730716",
"0.5714857",
"0.5704... | 0.73915446 | 1 |
Make a paper plot for the momentum KDE of the lowfield, and fulldrift solutions. | def momentum_kde2_paperplot(fields):
plt.figure(figsize=(2.65, 2.5))
ax = plt.axes([0.18, 0.17, 0.8, 0.8])
colorList = [med_color, high_color]
lw = 1.5
i = 0
meankx_2 = []
meankx_3 = []
k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + "E_{:.1e}.npy".format(fields[0]))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def momentum_kde_paperplot(fields):\n fig, (ax1, ax2, ax3) = plt.subplots(nrows=3, sharex=True)\n axisList = [ax1,ax2,ax3]\n i =0\n\n props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)\n for ee in fields:\n ee_Vcm = ee/100\n textstr = r'$E_{k_x}\\, = \\, %.1f \\, V \\, cm^{-1... | [
"0.73927927",
"0.7082678",
"0.64685386",
"0.6194481",
"0.60984546",
"0.6091529",
"0.5944429",
"0.5879228",
"0.58678186",
"0.5845622",
"0.5829439",
"0.5824676",
"0.58108956",
"0.5784534",
"0.57618827",
"0.57524467",
"0.57417613",
"0.57405406",
"0.57309103",
"0.57143843",
"0.57... | 0.7817756 | 0 |
Make a energy plot for the momentum KDE of the lowfield, and fulldrift solutions. | def energy_kde_paperplot(fields,df):
plt.figure()
i = 0
colorList = ['dodgerblue','tomato']
lw = 2
meanE_2 = []
meanE_3 = []
mup = np.min(df['energy [eV]']) - pp.mu
chi_0 = np.load(pp.outputLoc + 'Steady/' + 'chi_' + '2_' + "E_{:.1e}.npy".format(fields[0]))
g_en_axis, _, _, _, _, _,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def momentum_kde2_paperplot(fields):\n plt.figure(figsize=(2.65, 2.5))\n ax = plt.axes([0.18, 0.17, 0.8, 0.8])\n colorList = [med_color, high_color]\n lw = 1.5\n i = 0\n meankx_2 = []\n meankx_3 = []\n k_ax = np.load(pp.outputLoc + 'Momentum_KDE/' + 'k_ax_' + '2_' + \"E_{:.1e}.npy\".format(... | [
"0.7072073",
"0.6860298",
"0.6784533",
"0.6767711",
"0.6717085",
"0.64930975",
"0.6264038",
"0.62380916",
"0.6227457",
"0.62017035",
"0.6190444",
"0.61265624",
"0.60596615",
"0.6039065",
"0.60338074",
"0.59825134",
"0.59809995",
"0.5952686",
"0.5921822",
"0.5920559",
"0.59139... | 0.7414247 | 0 |
Returns the nth item | def nth(iterable, index):
return next(itertools.islice(iterable, index, None)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nth(n, seq):\n try:\n return seq[n]\n except TypeError:\n return next(itertools.islice(seq, n, None))",
"def nth(iterable, n, default=None):\n return next(islice(iterable, n, None), default)",
"def nth(iterable, n, default=None):\n return next(islice(iterable, n, None), default)",... | [
"0.7396352",
"0.72852194",
"0.72852194",
"0.72852194",
"0.7229926",
"0.7180901",
"0.70936525",
"0.69702876",
"0.6887761",
"0.6603851",
"0.6541124",
"0.6488166",
"0.6476991",
"0.64401025",
"0.64200073",
"0.6405436",
"0.63758516",
"0.6363515",
"0.63572127",
"0.62999797",
"0.629... | 0.7512134 | 0 |
Store any type of data in Redis | def store(self, data: Union[str, bytes, int, float]) -> str:
k = str(uuid.uuid4())
self._redis[k] = data
return k | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def store(self, data: Union[str, bytes, int, float]) -> str:\n key = str(uuid.uuid4())\n self._redis.set(key, data)\n return key",
"def redis_save(key: object, value: object) -> object:\n if key is not None and value is not None:\n red.redis.set(json.dumps(key), json.dumps(value))"... | [
"0.74398786",
"0.7203963",
"0.68926376",
"0.64535683",
"0.6436974",
"0.6225524",
"0.61990386",
"0.61871934",
"0.61752015",
"0.6131745",
"0.6131207",
"0.6122489",
"0.6113348",
"0.6100349",
"0.6039475",
"0.5939632",
"0.59025615",
"0.5878599",
"0.58582723",
"0.5839085",
"0.58303... | 0.7362231 | 1 |
Iterate through supported mode/char combinations. | def iter_mode(n, obj='ndarray'):
for mode in cap[obj][MODE]:
for char in fmtdict[mode]:
yield randitems(n, obj, mode, char) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n return iter([v for k, v in sorted(self._modes.items())])",
"def modes(self):\n try:\n order = self._current_order\n except AttributeError:\n raise AttributeError('Cannot iterate over modes without iterating over orders!') from None\n mode = ... | [
"0.62502277",
"0.60794157",
"0.594942",
"0.5905437",
"0.5903358",
"0.5762716",
"0.56345135",
"0.5598813",
"0.5586852",
"0.5512914",
"0.550523",
"0.5503041",
"0.54652876",
"0.5426214",
"0.54166454",
"0.5404549",
"0.53661305",
"0.5359288",
"0.5355193",
"0.53164005",
"0.5308114"... | 0.68199724 | 0 |
Yield (format, items, item) for all possible modes and format characters plus one random compound format string. | def iter_format(nitems, testobj='ndarray'):
for t in iter_mode(nitems, testobj):
yield t
if testobj != 'ndarray':
return
yield struct_items(nitems, testobj) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makeNamesFromFormats(formats):\n i = getIter(formats)\n if not i:\n return\n\n try:\n c = 0\n item = i.next()\n while item:\n c = c +1\n name = 'c%s' % c\n if isinstance(item, str):\n yield name\n else:\n ... | [
"0.59636045",
"0.55950534",
"0.5526537",
"0.5526537",
"0.5512344",
"0.5512344",
"0.5500678",
"0.5500678",
"0.54459256",
"0.5404356",
"0.54026484",
"0.5386869",
"0.5325779",
"0.52617586",
"0.52564883",
"0.5248751",
"0.5190863",
"0.5118963",
"0.50866807",
"0.50587744",
"0.50531... | 0.64417255 | 0 |
Calculate strides of a contiguous array. Layout is 'C' or 'F' (Fortran). | def strides_from_shape(ndim, shape, itemsize, layout):
if ndim == 0:
return ()
if layout == 'C':
strides = list(shape[1:]) + [itemsize]
for i in range(ndim-2, -1, -1):
strides[i] *= strides[i+1]
else:
strides = [itemsize] + list(shape[:-1])
for i in range(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strides_from_shape(ndim, shape, itemsize, layout):\n if ndim == 0:\n return ()\n if layout == 'C':\n strides = list(shape[1:]) + [itemsize]\n for i in range(ndim - 2, -1, -1):\n strides[i] *= strides[i + 1]\n else:\n strides = [itemsize] + list(shape[:-1])\n ... | [
"0.6671998",
"0.6667623",
"0.63901645",
"0.62995565",
"0.6209812",
"0.62079126",
"0.6108434",
"0.60595614",
"0.60080725",
"0.5996222",
"0.5996222",
"0.5860129",
"0.57919973",
"0.57440704",
"0.56975204",
"0.56885684",
"0.56631756",
"0.5634464",
"0.56175673",
"0.5605618",
"0.55... | 0.6674238 | 0 |
flatten list or return scalar | def flatten(lst):
if atomp(lst): # scalar
return lst
return _flatten(lst) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lflatten(*lst):\n return flatten(list(lst))",
"def _flatten_one(x):\n return x[0] if is_iterable(x) else x",
"def flatten(x): # przerobić na lambda?\n if x==[]:\n return None\n else:\n return x[0]",
"def flatten():",
"def flatten(lst):\n if atomp(lst):\n return lst\n... | [
"0.7351641",
"0.7303014",
"0.71548724",
"0.7148735",
"0.7075203",
"0.69926786",
"0.6866925",
"0.68362427",
"0.68152994",
"0.6766912",
"0.67421544",
"0.6731956",
"0.66912895",
"0.66828746",
"0.6666743",
"0.6657045",
"0.6656961",
"0.66309655",
"0.66255593",
"0.6615",
"0.6612183... | 0.83005923 | 0 |
Compare the structure of llst[lslices] and rlst[rslices]. | def cmp_structure(llst, rlst, lslices, rslices):
lshape = slice_shape(llst, lslices)
rshape = slice_shape(rlst, rslices)
if (len(lshape) != len(rshape)):
return -1
for i in range(len(lshape)):
if lshape[i] != rshape[i]:
return -1
if lshape[i] == 0:
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cmp_structure(llst, rlst, lslices, rslices):\n lshape = slice_shape(llst, lslices)\n rshape = slice_shape(rlst, rslices)\n if len(lshape) != len(rshape):\n return -1\n for i in range(len(lshape)):\n if lshape[i] != rshape[i]:\n return -1\n if lshape[i] == 0:\n ... | [
"0.8107347",
"0.5830058",
"0.5787684",
"0.57273674",
"0.5708086",
"0.547884",
"0.54676497",
"0.5341118",
"0.53267294",
"0.5325244",
"0.5295086",
"0.52857417",
"0.52715236",
"0.52042264",
"0.5128856",
"0.50830114",
"0.50252223",
"0.5011563",
"0.50000906",
"0.49984854",
"0.4990... | 0.8097147 | 1 |
The structure 't' is overlapping if at least one memory location is visited twice while iterating through all possible tuples of indices. | def is_overlapping(t):
memlen, itemsize, ndim, shape, strides, offset = t
visited = 1<<memlen
for ind in indices(shape):
i = memory_index(ind, t)
bit = 1<<i
if visited & bit:
return True
visited |= bit
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_overlapping(t):\n memlen, itemsize, ndim, shape, strides, offset = t\n visited = 1 << memlen\n for ind in indices(shape):\n i = memory_index(ind, t)\n bit = 1 << i\n if visited & bit:\n return True\n visited |= bit\n return False",
"def listOfOverlappingT... | [
"0.71436214",
"0.6230163",
"0.54177374",
"0.53693205",
"0.526794",
"0.52386534",
"0.5171279",
"0.5169592",
"0.5149605",
"0.5122925",
"0.5052315",
"0.50437593",
"0.5038537",
"0.5037338",
"0.5033946",
"0.49886644",
"0.49637598",
"0.49573925",
"0.495004",
"0.49486208",
"0.493795... | 0.7153341 | 0 |
Create a random slice of len slicelen that fits into listlen. | def randslice_from_slicelen(slicelen, listlen):
maxstart = listlen - slicelen
start = randrange(maxstart+1)
maxstep = (listlen - start) // slicelen if slicelen else 1
step = randrange(1, maxstep+1)
stop = start + slicelen * step
s = slice(start, stop, step)
_, _, _, control = slice_indices(s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def randslice_from_slicelen(slicelen, listlen):\n maxstart = listlen - slicelen\n start = randrange(maxstart + 1)\n maxstep = (listlen - start) // slicelen if slicelen else 1\n step = randrange(1, maxstep + 1)\n stop = start + slicelen * step\n s = slice(start, stop, step)\n _, _, _, control =... | [
"0.83833927",
"0.80226773",
"0.714893",
"0.7132235",
"0.6567857",
"0.6413113",
"0.62118304",
"0.61636114",
"0.6134608",
"0.6101278",
"0.61010647",
"0.6062314",
"0.60282576",
"0.6016087",
"0.59929234",
"0.5939068",
"0.59296066",
"0.59249735",
"0.59247345",
"0.5907804",
"0.5882... | 0.8387383 | 0 |
Create two sets of slices for an array x with shape 'shape' such that shapeof(x[lslices]) == shapeof(x[rslices]). | def randslice_from_shape(ndim, shape):
lslices = [0] * ndim
rslices = [0] * ndim
for n in range(ndim):
l = shape[n]
slicelen = randrange(1, l+1) if l > 0 else 0
lslices[n] = randslice_from_slicelen(slicelen, l)
rslices[n] = randslice_from_slicelen(slicelen, l)
return tupl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def randslice_from_shape(ndim, shape):\n lslices = [0] * ndim\n rslices = [0] * ndim\n for n in range(ndim):\n l = shape[n]\n slicelen = randrange(1, l + 1) if l > 0 else 0\n lslices[n] = randslice_from_slicelen(slicelen, l)\n rslices[n] = randslice_from_slicelen(slicelen, l)\n... | [
"0.6905628",
"0.65749097",
"0.6485385",
"0.6485385",
"0.6428866",
"0.64170295",
"0.64149487",
"0.6344559",
"0.6343766",
"0.6329222",
"0.62940896",
"0.6255896",
"0.62288624",
"0.6182799",
"0.59876955",
"0.5903534",
"0.58359647",
"0.5818925",
"0.5786385",
"0.5780439",
"0.572824... | 0.6896135 | 1 |
Return a list of random items for structure 't' with format 'fmtchar'. | def randitems_from_structure(fmt, t):
memlen, itemsize, _, _, _, _ = t
return gen_items(memlen//itemsize, '#'+fmt, 'numpy') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def randitems_from_structure(fmt, t):\n memlen, itemsize, _, _, _, _ = t\n return gen_items(memlen // itemsize, '#' + fmt, 'numpy')",
"def gen_item(fmt, obj):\n mode, chars = fmt.split('#')\n x = []\n for c in chars:\n x.append(randrange_fmt(mode, c, obj))\n return x[0] if len(x) == 1 el... | [
"0.75925416",
"0.6998413",
"0.6998413",
"0.61594206",
"0.61594206",
"0.5678781",
"0.55998796",
"0.55998796",
"0.5551217",
"0.55419385",
"0.5459458",
"0.5367428",
"0.53579396",
"0.53160495",
"0.5218872",
"0.51369077",
"0.5077376",
"0.5070219",
"0.5048697",
"0.50483674",
"0.503... | 0.7437101 | 1 |
Interpret the raw memory of 'exporter' as a list of items with size 'itemsize'. If shape=None, the new structure is assumed to be 1D with n itemsize = bytelen. If shape is given, the usual constraint for contiguous arrays prod(shape) itemsize = bytelen applies. On success, return (items, shape). If the constraints cann... | def cast_items(exporter, fmt, itemsize, shape=None):
bytelen = exporter.nbytes
if shape:
if prod(shape) * itemsize != bytelen:
return None, shape
elif shape == []:
if exporter.ndim == 0 or itemsize != bytelen:
return None, shape
else:
n, r = divmod(bytelen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cast_items(exporter, fmt, itemsize, shape=None):\n bytelen = exporter.nbytes\n if shape:\n if prod(shape) * itemsize != bytelen:\n return None, shape\n elif shape == []:\n if exporter.ndim == 0 or itemsize != bytelen:\n return None, shape\n else:\n n, r = ... | [
"0.77506953",
"0.49568605",
"0.48241737",
"0.48023552",
"0.47398067",
"0.4713811",
"0.47077888",
"0.46982223",
"0.4669957",
"0.4669957",
"0.4669957",
"0.4669957",
"0.46594286",
"0.4643557",
"0.459365",
"0.4521161",
"0.45037562",
"0.44983464",
"0.4494086",
"0.4490511",
"0.4454... | 0.77280533 | 1 |
Generate random slice for a single dimension of length n. If zero=True, the slices may be empty, otherwise they will be nonempty. | def rslice(n, allow_empty=False):
minlen = 0 if allow_empty or n == 0 else 1
slicelen = randrange(minlen, n+1)
return randslice_from_slicelen(slicelen, n) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rslice(n, allow_empty=False):\n minlen = 0 if allow_empty or n == 0 else 1\n slicelen = randrange(minlen, n + 1)\n return randslice_from_slicelen(slicelen, n)",
"def get_slice(self, n):\n if n == 0:\n return slice(self._lo_atom, self._lo_atom + self._n_atoms)\n raise IndexEr... | [
"0.77326006",
"0.70148605",
"0.6813906",
"0.6813906",
"0.6412858",
"0.63864595",
"0.62999004",
"0.6264508",
"0.61941475",
"0.6164201",
"0.616065",
"0.6156945",
"0.6141035",
"0.61246413",
"0.61231834",
"0.605221",
"0.60043675",
"0.60013884",
"0.59873164",
"0.5930526",
"0.59282... | 0.77208936 | 1 |
Print ndarray for debugging. | def ndarray_print(nd):
try:
x = nd.tolist()
except (TypeError, NotImplementedError):
x = nd.tobytes()
if isinstance(nd, ndarray):
offset = nd.offset
flags = nd.flags
else:
offset = 'unknown'
flags = 'unknown'
print("ndarray(%s, shape=%s, strides=%s, su... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ndarray_print(nd):\n try:\n x = nd.tolist()\n except (TypeError, NotImplementedError):\n x = nd.tobytes()\n if isinstance(nd, ndarray):\n offset = nd.offset\n flags = nd.flags\n else:\n offset = 'unknown'\n flags = 'unknown'\n print(\n \"ndarray(%... | [
"0.7679877",
"0.68368405",
"0.6631245",
"0.6609683",
"0.65994364",
"0.65967774",
"0.6263622",
"0.62557095",
"0.62557095",
"0.62557095",
"0.62557095",
"0.6235029",
"0.6219768",
"0.6178411",
"0.61287254",
"0.6089198",
"0.6083977",
"0.60370946",
"0.60179627",
"0.6011618",
"0.598... | 0.7686053 | 0 |
Is (x0, y0) on a shared diagonal with (x1, y1)? | def share_diagonal(x0,y0,x1,y1):
return abs(x0 - x1) == abs(y0 - y1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def share_diagonal(x0, y0, x1, y1):\r\n dy = abs(y1 - y0) # Calc the absolute y distance\r\n dx = abs(x1 - x0) # CXalc the absolute x distance\r\n return dx == dy # They clash if dx == dy\r",
"def share_diagonal(x0, y0, x1, y1):\r\n dy = abs(y1 - y0) # Calc the absolute ... | [
"0.8518046",
"0.8518046",
"0.8502754",
"0.84337777",
"0.7760696",
"0.70689964",
"0.70689964",
"0.706408",
"0.6565794",
"0.65179807",
"0.6373702",
"0.63458717",
"0.63303655",
"0.6296012",
"0.6293987",
"0.62332195",
"0.62295103",
"0.61589813",
"0.61407775",
"0.6136831",
"0.6124... | 0.88636863 | 0 |
Parse a formatted string and return the names of the args and their types. Will raise a ValueError if the type is not a pyopenapi3 `Field` or an already defined Component Parameter type. In the case that the type represents a `Field`, then its type will be returned, respectively. Otherwise, if it is an already defined ... | def parse_name_and_type_from_fmt_str(
formatted_str: str,
allowed_types: Optional[Dict[str, Component]] = None
) -> Generator[Tuple[str, Type[Field]], None, None]:
for _, arg_name, _type_name, _ in Formatter().parse(formatted_str):
if arg_name is not None:
try:
as... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def extract_type(self, param):\n\n def evaluate(instance):\n if isinstance(instance, (Struct, Enum)):\n return instance.name\n if isinstance(instance, (Integer, Float)):\n return 'Number'\n return type(instance).__name__\n\n if isinstance... | [
"0.5762772",
"0.56126136",
"0.5612374",
"0.5606245",
"0.5510904",
"0.5498231",
"0.54389805",
"0.5416661",
"0.5379599",
"0.53538597",
"0.5281033",
"0.52633864",
"0.522637",
"0.51833683",
"0.5179722",
"0.5152138",
"0.51198363",
"0.51118517",
"0.50726426",
"0.5072116",
"0.507044... | 0.74992687 | 0 |
Convert a custom object to a schema. This is done by create a reference to the object. Any nonreference object should be created by the Components builder. param `obj` must be a subtype of `data_types.Component`. Its type will determine what kind of component it is, e.g. '/components/ schemas/...' or '/components/param... | def convert_objects_to_schema(obj: Type[Component]) -> ReferenceObject:
cmp_type: str = 'schemas' # default component type
if hasattr(obj, '__cmp_type__'):
cmp_type = obj.__cmp_type__.lower() # type: ignore
return create_reference(obj.__name__, cmp_type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_schema(obj):\n\n if not isinstance(obj, Schema):\n if isinstance(obj, dict):\n return DictStructure(obj)\n elif isinstance(obj, list):\n return ListStructure(obj)\n elif isinstance(obj, (int, float, str, bool)) or (obj is None):\n return Value(obj)\... | [
"0.6243453",
"0.5825912",
"0.57944256",
"0.57603896",
"0.56610686",
"0.5654507",
"0.5639352",
"0.5597519",
"0.5585299",
"0.5489156",
"0.5368194",
"0.53657424",
"0.5364657",
"0.5353328",
"0.5295786",
"0.5216217",
"0.5193709",
"0.516745",
"0.51386046",
"0.5135405",
"0.5110169",... | 0.81769264 | 0 |
'Inject' the `Component` class into the custom, user defined, soontobe Component, class. This will help when building a property that involves a user defined custom Component. param `cmp_type` is some subtype of `data_types.Component`, e.g. whether it is a Schema component or Parameter component. | def inject_component(cls, cmp_type: Type[ComponentType]):
if issubclass(cls, Component):
return cls
else:
injected = type(
"Injected",
(cls, cmp_type),
{attr_name: attr for attr_name, attr in cls.__dict__.items()}
)
injected.__qualname__ = f'Co... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_comp(self, name, ctype):\n\n name = self.name + '.' + name\n\n assert name not in self.components, 'A component named \\'{}\\' already exists for node \\'{}\\''.format(\n name, self.name)\n\n try:\n cls = co.str_to_comp(ctype)\n except AttributeError:\n ... | [
"0.6341976",
"0.60763973",
"0.60763973",
"0.5894654",
"0.5816849",
"0.5718252",
"0.56145835",
"0.56028533",
"0.5554072",
"0.55418164",
"0.5510925",
"0.54735297",
"0.54278535",
"0.5406879",
"0.5326886",
"0.5326886",
"0.5322498",
"0.52880853",
"0.518145",
"0.51773274",
"0.51618... | 0.7875679 | 0 |
Determine all of the local ip addresses for this machine This allows us to flag traffic as inbound or outbound. | def detect_local_ips(self):
result = set()
for ifaceName in interfaces():
try:
address = [i['addr'] for i in ifaddresses(ifaceName)[AF_INET]]
except:
pass
result.add(address[0])
return tuple(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ips():\r\n local_ips = []\r\n public_ips = []\r\n \r\n # list of iface names, 'lo0', 'eth0', etc.\r\n for iface in netifaces.interfaces():\r\n # list of ipv4 addrinfo dicts\r\n ipv4s = netifaces.ifaddresses(iface).get(netifaces.AF_INET, [])\r\n for entry in ipv4s:\r\n ... | [
"0.73083735",
"0.72061265",
"0.704093",
"0.6923851",
"0.6890017",
"0.6762811",
"0.6715329",
"0.67115986",
"0.66833586",
"0.6657584",
"0.66189605",
"0.66133195",
"0.66041005",
"0.6584781",
"0.6563698",
"0.6518723",
"0.64804894",
"0.647476",
"0.645703",
"0.63811326",
"0.6353452... | 0.74796903 | 0 |
Sorts an iterable of packets and removes the duplicates | def iter_packets(iterable):
prev = None
for i in sorted(iterable, key=attrgetter('seq')):
if prev is None or prev.seq != i.seq:
prev = i
yield i | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sort_grouped_packets(self, grouped_packets):\n for group in grouped_packets:\n group.sort(key=lambda x: x.time, reverse=False)\n return grouped_packets",
"def insertOrderedPacket(self, packet:Rudp.Packet, packets:list) -> list:\n i = 0\n for i in range(len(packets)):\n ... | [
"0.6647256",
"0.61278707",
"0.60170823",
"0.5986823",
"0.596562",
"0.5906093",
"0.5628137",
"0.5617985",
"0.560249",
"0.5601702",
"0.5557772",
"0.5519489",
"0.55179644",
"0.55005574",
"0.5492273",
"0.54918206",
"0.5472187",
"0.5472187",
"0.54687566",
"0.543962",
"0.54305553",... | 0.6355191 | 1 |
Hashes a packet to determine the tcp stream it is part of | def hash_packet(eth, outbound=False):
ip = eth.data
tcp = ip.data
return '%s:%i' % (ipaddr_string(ip.dst if outbound else ip.src),
tcp.sport if outbound else tcp.dport
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hash_packet(packet):\n if packet.proto == 6:\n #*** Is TCP:\n packet_tuple = (packet.ip_src,\n packet.ip_dst,\n packet.proto,\n packet.tp_src,\n packet.tp_dst,\n packet.tp_seq_src,\n ... | [
"0.7895792",
"0.661901",
"0.63492525",
"0.6196242",
"0.6103663",
"0.6019841",
"0.5995078",
"0.5981094",
"0.59252846",
"0.5890868",
"0.58816797",
"0.58208543",
"0.5804756",
"0.5796329",
"0.5782937",
"0.5778316",
"0.574992",
"0.568126",
"0.56439674",
"0.5617276",
"0.5610319",
... | 0.72170126 | 1 |
Iterates over next packets in the buffer and removes them | def remove_buffered_packets(self):
seq = self.next_seq
while True:
p = self.buffer.pop(seq, None)
if p is None:
break
else:
seq += len(p.data)
yield p | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drop_packets(self, verbose=False):\n while True:\n try:\n packet, address = self._socket.recvfrom(10240)\n except:\n break\n\n if verbose:\n logger.debug(\"dropped %d bytes from %s:%d\", len(packet), address[0], address[1])",
... | [
"0.67283076",
"0.66058624",
"0.63236773",
"0.6317739",
"0.6310936",
"0.62291014",
"0.61791795",
"0.60786915",
"0.60678726",
"0.59578645",
"0.5947683",
"0.5928341",
"0.5889969",
"0.5796768",
"0.5776283",
"0.5721672",
"0.571722",
"0.57118416",
"0.5706474",
"0.5685877",
"0.56655... | 0.7841867 | 0 |
Move a die through a list of positions. | def move(self, *positions, show_length=True) -> str:
move_parts = []
move_count = len(positions)
pips = prev_x = prev_y = 0
for i, (x, y) in enumerate(positions):
if i == 0:
pips = self.dice.pop((x, y))
else:
dx = x - prev_x
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def throw(self, move):\n for dice_index in move:\n self.dice[dice_index - 1] = random.randint(1,6)",
"def move_tie_fighters(self):\n for i in range(len(self.tie_fighters)):\n self.tie_fighters[i].move_tie_fighter()",
"def migration(self):\n\n coordinates = self.get_ra... | [
"0.66328007",
"0.596524",
"0.5870962",
"0.58515584",
"0.5819032",
"0.57985187",
"0.5759108",
"0.57562107",
"0.574448",
"0.57078034",
"0.56926847",
"0.56588614",
"0.5642412",
"0.5605683",
"0.5596673",
"0.5586302",
"0.55856097",
"0.5582289",
"0.5575625",
"0.55608356",
"0.555548... | 0.63560057 | 1 |
Record the joint character between a pair of cells. | def add_joint(joint: str, x1: int, y1: int, x2: int, y2: int) -> str:
return joint | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def junction_char(self):\n ...",
"def _put_chr_at(self, char, row, col, color, adjustment_x=.19, adjustment_y=.19):\n self._goto_piece_xy(row, col, adjustment_x, adjustment_y)\n self.pen.color(color)\n self.pen.write(char, font=(\"Courier\", round(self.square_side_size * .7),\n ... | [
"0.6033239",
"0.5642616",
"0.5578127",
"0.5315496",
"0.52856386",
"0.5230224",
"0.5207506",
"0.51857436",
"0.51733494",
"0.5166131",
"0.51407605",
"0.5093636",
"0.5047172",
"0.50447404",
"0.50364846",
"0.50296426",
"0.5018322",
"0.499095",
"0.49901915",
"0.49538672",
"0.49527... | 0.5760053 | 1 |
Split all dominoes into separate cells. Useful for Dominosa. | def split_all(self):
for domino in self.dominoes[:]:
self.split(domino) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_split_cell_splits_neighbours(mock_amg):\n\n # split the centre cell in the mock grid\n # this will create 4 more cells at tier 1\n mock_amg.cells[4].split()\n\n # now split the bottom right of these cells\n # this should force the east and south cells to also be split\n mock_amg.cells[4]... | [
"0.54147345",
"0.53187776",
"0.5316432",
"0.53141034",
"0.50757587",
"0.50472033",
"0.5007801",
"0.49147692",
"0.49121788",
"0.4892322",
"0.48909703",
"0.48512492",
"0.48459086",
"0.48424825",
"0.48366407",
"0.48032853",
"0.47910866",
"0.47892538",
"0.47808278",
"0.47771978",
... | 0.7638271 | 0 |
Iterate through self.extra_dominoes, start at random position. a generator of dominoes. | def choose_extra_dominoes(self, random):
dominoes = self.extra_dominoes[:]
count = len(dominoes)
start = random.randrange(count)
for i in range(count):
yield dominoes[(i + start) % count] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_and_flip_extra_dominoes(self, random):\n for domino in self.choose_extra_dominoes(random):\n if domino.head.pips == domino.tail.pips:\n yield domino, False\n else:\n flip_first = random.randint(0, 1)\n for j in range(2):\n ... | [
"0.6895019",
"0.62940025",
"0.5725973",
"0.53913283",
"0.51478684",
"0.5122216",
"0.5106027",
"0.51026565",
"0.5055542",
"0.50077224",
"0.49957895",
"0.4972248",
"0.49301994",
"0.49140477",
"0.49055457",
"0.48926997",
"0.4876082",
"0.48698455",
"0.48647448",
"0.48630825",
"0.... | 0.8736248 | 0 |
Iterate through self.extra_dominoes, start at random position. a generator of (domino, is_flipped) pairs. Each domino is returned twice, with True or False in random order. | def choose_and_flip_extra_dominoes(self, random):
for domino in self.choose_extra_dominoes(random):
if domino.head.pips == domino.tail.pips:
yield domino, False
else:
flip_first = random.randint(0, 1)
for j in range(2):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def choose_extra_dominoes(self, random):\n dominoes = self.extra_dominoes[:]\n count = len(dominoes)\n start = random.randrange(count)\n for i in range(count):\n yield dominoes[(i + start) % count]",
"def pickup_dominoes(self, num_dominoes, player):\n\n for domino in... | [
"0.7208414",
"0.5903002",
"0.5236969",
"0.47793296",
"0.4773952",
"0.47145683",
"0.46093652",
"0.4590172",
"0.45812768",
"0.45804274",
"0.45732227",
"0.45460996",
"0.4520758",
"0.4515188",
"0.44946986",
"0.4483429",
"0.44739068",
"0.446823",
"0.4457632",
"0.44459644",
"0.4417... | 0.8199502 | 0 |
Get a direction by name. | def get_direction(self, name):
index = Domino.direction_names.find(name)
return Domino.directions[index] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def match_direction(self, string):\r\n return Direction.query(\r\n or_(Direction.name == string, Direction.short_name == string)\r\n ).first()",
"def getDirection(self, direction: str):\n return direction",
"def get_direction(self, start_direction, **kwargs):\n return sel... | [
"0.65444416",
"0.644363",
"0.6317267",
"0.58342814",
"0.5821944",
"0.5821525",
"0.57715315",
"0.57485586",
"0.56602365",
"0.56146896",
"0.56140655",
"0.5608703",
"0.5557051",
"0.5557051",
"0.55225646",
"0.54623437",
"0.54026246",
"0.5378701",
"0.5376569",
"0.5370104",
"0.5360... | 0.81401694 | 0 |
True if either cell matches one of its neighbours. Slightly different type of matching from isMatch(). | def hasMatch(self):
for cell in (self.head, self.tail):
for neighbour in cell.find_neighbours():
if neighbour.pips == cell.pips:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_neighbours(self):\n for p in self.targetCell.possibilities:\n if p != 0:\n if p not in self.targetCell.row_neighbour_possibilities:\n self.targetCell.solve(p)\n return True\n elif p not in self.targetCell.column_neighbo... | [
"0.6724939",
"0.65565187",
"0.651675",
"0.6491993",
"0.64436924",
"0.64371634",
"0.64162314",
"0.64157915",
"0.64040434",
"0.64029574",
"0.6330807",
"0.6311212",
"0.62970114",
"0.625364",
"0.6251876",
"0.62480813",
"0.6242117",
"0.62384665",
"0.6207678",
"0.6207055",
"0.61696... | 0.7738691 | 0 |
Move a domino and calculate the new board state. Afterward, put the board back in its original state. | def move(self, domino, dx, dy) -> typing.Tuple[str, int]:
domino.move(dx, dy)
try:
board = domino.head.board
if not board.is_connected():
raise BadPositionError('Board is not connected.')
if board.has_loner():
raise BadPositionError('Bo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, domino, dx, dy, offset=None):\n matching_dominoes = set()\n complement_found = False\n domino.move(dx, dy)\n board = domino.head.board\n try:\n if not board.is_connected():\n raise BadPositionError('Board is not connected after move.')\n ... | [
"0.7599279",
"0.6890704",
"0.6870524",
"0.6765509",
"0.6765455",
"0.67173713",
"0.6701276",
"0.66965497",
"0.66819054",
"0.6667514",
"0.6663559",
"0.66578156",
"0.66204715",
"0.657253",
"0.65490776",
"0.6526394",
"0.6526335",
"0.6520004",
"0.6495556",
"0.6494918",
"0.6452767"... | 0.7041228 | 1 |
Move a domino and calculate the new board state. Afterward, put the board back in its original state. | def move(self, domino, dx, dy, offset=None):
matching_dominoes = set()
complement_found = False
domino.move(dx, dy)
board = domino.head.board
try:
if not board.is_connected():
raise BadPositionError('Board is not connected after move.')
for... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, domino, dx, dy) -> typing.Tuple[str, int]:\n domino.move(dx, dy)\n try:\n board = domino.head.board\n if not board.is_connected():\n raise BadPositionError('Board is not connected.')\n if board.has_loner():\n raise BadPosit... | [
"0.7041228",
"0.6890704",
"0.6870524",
"0.6765509",
"0.6765455",
"0.67173713",
"0.6701276",
"0.66965497",
"0.66819054",
"0.6667514",
"0.6663559",
"0.66578156",
"0.66204715",
"0.657253",
"0.65490776",
"0.6526394",
"0.6526335",
"0.6520004",
"0.6495556",
"0.6494918",
"0.6452767"... | 0.7599279 | 0 |
Attempts to exploit a ColdFusion file disclosure vulnerability to retrieve a hashed admin password. If found, this script will produce a hash to be used to bypass admin login by computing the value of the admin hash and a ColdFusion salt input parameter. | def retrieve_hash(host, salt):
password_pattern = re.compile(r'\npassword=(.+)\r')
url = 'http://%s/CFIDE/administrator/enter.cfm?locale=../../../../../../../../../../ColdFusion8/lib/password.properties%%00en' % host
try:
response = requests.post(url)
password_hash = re.search(pass... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pre_hash(masterpw, password, args):\n salt_hasher = hmac.new(masterpw, digestmod=DIGEST)\n\n if args.salt_url is not None:\n print(\"[INFO] Using resource at URL as salt ...\")\n with urlopen(args.salt_url) as f:\n while True:\n data = f.read(128)\n ... | [
"0.56448627",
"0.55366296",
"0.54568374",
"0.54494023",
"0.53573483",
"0.533294",
"0.5329196",
"0.5288839",
"0.52837366",
"0.5233808",
"0.52312523",
"0.5218411",
"0.51976466",
"0.5186236",
"0.5183251",
"0.51653415",
"0.5149853",
"0.51409924",
"0.5114079",
"0.51067483",
"0.509... | 0.6947036 | 0 |
This method starts traffic between VMs using pktgen | def start_traffic_pktgen_between_vm(
sr_vm_fix,
dst_vm_fix,
dest_min_port=10000,
dest_max_port=10000):
start_traffic_pktgen(
sr_vm_fix,
src_min_ip=sr_vm_fix.vm_ip,
src_max_ip=sr_vm_fix.vm_ip,
dest_ip=dst_vm_fix.vm_ip,
dest_min_port=dest_min_po... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_traffic_pktgen(\n vm_fix,\n src_min_ip='',\n src_max_ip='',\n dest_ip='',\n dest_min_port='',\n dest_max_port=''):\n vm_fix.logger.info(\"Sending traffic...\")\n try:\n cmd = '~/pktgen_new.sh %s %s %s %s %s' % (src_min_ip,\n ... | [
"0.7372693",
"0.59777474",
"0.58827966",
"0.5760567",
"0.5757512",
"0.5692496",
"0.5627953",
"0.5596239",
"0.5572661",
"0.5571036",
"0.55461",
"0.55419725",
"0.55401415",
"0.5530725",
"0.552947",
"0.55276793",
"0.5517556",
"0.5503944",
"0.54876393",
"0.5487193",
"0.5486951",
... | 0.664063 | 1 |
get output file's raw name, without .txt or .csv | def get_output_raw_name(journal_file_name, output_type='txt'):
dot_pos = journal_file_name.rfind('.')
if dot_pos != -1:
output_file_name = journal_file_name[0: dot_pos]
else:
output_file_name = journal_file_name
num_of_output = 1
if output_type == 'txt':
while True:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getOutputFilename(self, filename):\n return filename[:-4] + \".txt\"",
"def get_file_name(self):\n return str(self.get_file())",
"def _get_output_filename(dataset_dir, split_name):\n return '%s/%s*.tfrecord' % (dataset_dir, split_name)",
"def _get_raw_output_fp(self, output_dir, params):... | [
"0.74351394",
"0.7248863",
"0.72257614",
"0.7196246",
"0.70979714",
"0.7075223",
"0.7033236",
"0.7024702",
"0.7010298",
"0.698268",
"0.6951329",
"0.6924173",
"0.69214404",
"0.691918",
"0.6910793",
"0.69105744",
"0.6872355",
"0.6843693",
"0.6799241",
"0.6777324",
"0.67486",
... | 0.7691399 | 0 |
Apply base theme to the application. | def _apply_base_theme(self, app):
app.setStyle("Fusion")
with open(self._STYLESHEET) as stylesheet:
app.setStyleSheet(stylesheet.read()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def apply_theme(self, ax):\n pass",
"def apply_style(self, app):\n\n darkPalette = QPalette()\n\n # base\n darkPalette.setColor(QPalette.WindowText, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))\n darkPalette.setColor(QPalette.Light, ... | [
"0.71454114",
"0.7026285",
"0.7016173",
"0.6658857",
"0.66372305",
"0.6465947",
"0.6465947",
"0.6419377",
"0.63436294",
"0.6121915",
"0.60901904",
"0.607666",
"0.6037439",
"0.5978628",
"0.5909347",
"0.5894715",
"0.5894359",
"0.5853654",
"0.5733367",
"0.5661598",
"0.56274146",... | 0.83967525 | 0 |
Apply Light Theme to the Qt application instance. | def apply_style(self, app):
lightPalette = QPalette()
# base
lightPalette.setColor(QPalette.WindowText, QColor(0, 0, 0))
lightPalette.setColor(QPalette.Button, QColor(240, 240, 240))
lightPalette.setColor(QPalette.Light, QColor(180, 180, 180))
lightPalette.setColor(QPal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def change_theme(self):\n # get the QApplication instance, or crash if not set\n app = QtWidgets.QApplication.instance()\n if app is None:\n raise RuntimeError(\"No Qt Application found.\")\n\n if self.darkCheckBox.isChecked():\n app.setStyleSheet(qdarkstyle.load_... | [
"0.73362345",
"0.7268235",
"0.6951579",
"0.6824019",
"0.67134887",
"0.61943114",
"0.61578697",
"0.61033326",
"0.6091632",
"0.6071398",
"0.60527337",
"0.5875625",
"0.5875625",
"0.58475655",
"0.57241774",
"0.57137465",
"0.5653085",
"0.5578202",
"0.54841846",
"0.54613185",
"0.54... | 0.743344 | 0 |
Create new entity returning uuid of created record | def create_entity(data: dict) -> str:
new_uuid = str(uuid4())
Entity.create(uuid=new_uuid, data=data["data"])
return new_uuid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_instance(**kwargs):\n ctxt = context.get_admin_context()\n return db.instance_create(ctxt, _create_instance_dict(**kwargs))['id']",
"def new(self):\n uuid = uuid4().hex\n cur = self.conn.cursor()\n cur.execute(\n \"\"\"\n INSERT INTO experiments (uuid)\n ... | [
"0.6654303",
"0.6614401",
"0.6504342",
"0.64369875",
"0.6267132",
"0.6234407",
"0.62021786",
"0.62021786",
"0.61904436",
"0.6179102",
"0.613219",
"0.61154836",
"0.60848325",
"0.6072805",
"0.60569495",
"0.6037746",
"0.6018132",
"0.6005871",
"0.6001378",
"0.59915316",
"0.599153... | 0.7855162 | 0 |
determine langage used base on the extension | def identifyLangage(script):
langage = "undefined"
scriptNameInArray = script.split(".")
extension = scriptNameInArray[-1]
if(extension == "pl"):
langage = "perl"
elif(extension == "py"):
langage = "python"
elif(extension == "sh"):
langage = "bash"
else:
langage == "not recognised"
return langage | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lang(self):\n return self.langs.lang",
"def get_language(self, article):\r\n # we don't want to force the target laguage\r\n # so we use the article.meta_lang\r\n if self.config.use_meta_language == True:\r\n if article.meta_lang:\r\n return article.m... | [
"0.717291",
"0.71475804",
"0.70080835",
"0.70027035",
"0.69902664",
"0.698173",
"0.6898868",
"0.6871327",
"0.6855876",
"0.68457574",
"0.6826537",
"0.6808138",
"0.6802423",
"0.6731631",
"0.6702847",
"0.668899",
"0.664422",
"0.6610783",
"0.6597736",
"0.6578168",
"0.65664876",
... | 0.75546545 | 0 |
Get the stderr of script | def getErrors(script):
p = subprocess.Popen(['./'+script], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
out, err = p.communicate()
return err | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_stderr(self):\n return self._get_log('stderr')",
"def stderr(self) -> str:\n _args: list[Arg] = []\n _ctx = self._select(\"stderr\", _args)\n return _ctx.execute_sync(str)",
"def result_stderr(result):\n return result[1][1]",
"def stderr(self):\n return self.__stderr... | [
"0.80331707",
"0.77476525",
"0.77177006",
"0.7631188",
"0.73205614",
"0.72101223",
"0.7183124",
"0.7134146",
"0.7087779",
"0.70248073",
"0.6913695",
"0.6896512",
"0.6791896",
"0.66601497",
"0.66361713",
"0.65947324",
"0.64891607",
"0.64813185",
"0.63999623",
"0.6331216",
"0.6... | 0.79301566 | 1 |
scan script for simple errors | def scanForSimpleError(script):
langage = identifyLangage(script)
line_number = 0
logFile_name = "scan.log"
# Scanning File
logFile = open(logFile_name, 'w')
scriptFile = open(script, 'r')
for line in scriptFile:
line_number +=1
lineWithoutBackN = line.replace("\n", "")
lineInArray = lineWithoutBackN.spli... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scan_error(self, line: int, message: str):\n self.report(line, \"\", message)",
"def error_check(command):\r\n\r\n # TODO\r",
"def check_errors(self) -> None:",
"def check_errors():\n\n for error in errors:\n ERROR('%s' % str(error))\n\n if len(errors) != 0:\n sys.exit(1)",
... | [
"0.6841208",
"0.68405724",
"0.66131353",
"0.6445967",
"0.6399118",
"0.6177685",
"0.61256075",
"0.6095763",
"0.6076316",
"0.6045332",
"0.60325944",
"0.5948576",
"0.5919206",
"0.5869653",
"0.58674383",
"0.58112127",
"0.5804113",
"0.5793846",
"0.57393223",
"0.57348496",
"0.57310... | 0.754085 | 0 |
Returns the loss function that will be used to train the encoder. | def get_loss_fn(self):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_loss_fn():\n return reconstruction",
"def get_loss(self):\n raise NotImplementedError",
"def loss(self):\n return 'mse'",
"def loss_op(self):\n return self.loss",
"def get_loss_function(loss):\n try:\n\n loss_func_map = {\"sparse_softmax_cross_entropy\": tf.losses.... | [
"0.7495766",
"0.7134641",
"0.70509577",
"0.7038898",
"0.6990812",
"0.6928303",
"0.6885967",
"0.68388313",
"0.6784255",
"0.6783532",
"0.67699516",
"0.6748856",
"0.672302",
"0.66822994",
"0.66506594",
"0.6647998",
"0.6568442",
"0.6567009",
"0.65539795",
"0.65407044",
"0.6529401... | 0.77475625 | 0 |
Switches the dataset state to the next epoch. The default implementation for this method is to reset the state. Returns | def next_epoch(self, state):
return self.reset(state) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_epoch(self):\n self._curr_batch = 0\n if self.shuffle_order:\n self.shuffle()",
"def _reset(self):\n np.random.shuffle(self.id)\n self.episode_step = 0 # Reset episode step counter at the end of every episode\n self._state = self.X_train[self.id[self.episode... | [
"0.73462296",
"0.69393736",
"0.6755204",
"0.6629461",
"0.6506496",
"0.646609",
"0.6465896",
"0.6438578",
"0.6374113",
"0.6371389",
"0.6335564",
"0.63048464",
"0.628498",
"0.6273848",
"0.62642074",
"0.6264049",
"0.6257736",
"0.6157545",
"0.6111303",
"0.60934657",
"0.6084503",
... | 0.7705791 | 0 |
Use the default iteration scheme to construct a data stream. | def get_default_stream(self):
if not hasattr(self, 'default_scheme'):
raise ValueError("Dataset does not provide a default iterator")
return DataStream(self, iteration_scheme=self.default_scheme) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_data_iterator(input):\n assert isinstance(input, DataLoader)\n data_iterator = iter(input)\n return data_iterator",
"def __iter__(self):\n\n # Open the data reader\n self.data.open()\n\n starts = np.arange(self.start, self.stop, self.chunksize)\n for a, b in zip_long... | [
"0.6576385",
"0.6544374",
"0.63232946",
"0.6247353",
"0.6233099",
"0.62073475",
"0.618729",
"0.61413085",
"0.61413085",
"0.61413085",
"0.61316687",
"0.60305387",
"0.6023972",
"0.6003705",
"0.5974357",
"0.5966117",
"0.5944801",
"0.594095",
"0.5936904",
"0.59299433",
"0.5929826... | 0.6743139 | 0 |
Filter the requested sources from those provided by the dataset. A dataset can be asked to provide only a subset of the sources it can provide (e.g. asking MNIST only for the features, not for the labels). A dataset can choose to use this information to e.g. only load the requested sources into memory. However, in case... | def filter_sources(self, data):
return tuple([d for d, s in zip(data, self.provides_sources)
if s in self.sources]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_new_sourcedatasets(self):\n previous_study_version = self.get_previous_version()\n SourceDataset = apps.get_model('trait_browser', 'SourceDataset')\n if previous_study_version is not None:\n qs = SourceDataset.objects.filter(source_study_version=self)\n # We can p... | [
"0.6109405",
"0.6090112",
"0.59479564",
"0.58847076",
"0.5806422",
"0.56509817",
"0.5643852",
"0.5635574",
"0.5618711",
"0.5561764",
"0.55469316",
"0.5468559",
"0.5457959",
"0.54406905",
"0.5426888",
"0.53734815",
"0.53640324",
"0.5352967",
"0.5352967",
"0.5352967",
"0.532246... | 0.69611335 | 0 |
Create properties that perform lazy loading of attributes. | def lazy_property_factory(lazy_property):
def lazy_property_getter(self):
if not hasattr(self, '_' + lazy_property):
self.load()
if not hasattr(self, '_' + lazy_property):
raise ValueError("{} wasn't loaded".format(lazy_property))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lazy_properties(*lazy_properties):\n def lazy_property_factory(lazy_property):\n \"\"\"Create properties that perform lazy loading of attributes.\"\"\"\n def lazy_property_getter(self):\n if not hasattr(self, '_' + lazy_property):\n self.load()\n ... | [
"0.70922816",
"0.6685102",
"0.6428715",
"0.6299822",
"0.6247607",
"0.5921087",
"0.5776609",
"0.5761453",
"0.57289666",
"0.56989306",
"0.5629627",
"0.56074035",
"0.5563408",
"0.55521804",
"0.55443585",
"0.55443585",
"0.55443585",
"0.5507907",
"0.547553",
"0.5448069",
"0.543360... | 0.7106498 | 0 |
Render a Django response and finish up this request. You'll need to call this if the view function/method is a coroutine. | def render(self, response):
logger.debug("TornadoRequest::render")
response = self._handler.finish_response(self, response)
logger.debug("response: Finished") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def finish_response(self, request, response):\n logger.debug(\"TornadoHandler::finish_response\")\n\n try:\n response = self._render_template(request, response)\n except Exception as e:\n return self._handle_response_exception(request, response, e)\n\n try:\n ... | [
"0.734545",
"0.7148183",
"0.6868576",
"0.6828342",
"0.66384035",
"0.6576349",
"0.6576349",
"0.6488101",
"0.64071804",
"0.63726956",
"0.63658375",
"0.6342019",
"0.63327676",
"0.6281047",
"0.62706876",
"0.62440646",
"0.6232727",
"0.61879945",
"0.6183402",
"0.6164196",
"0.616272... | 0.7349427 | 0 |
Convenience wrapper for the Tornado request's write() method. | def write(self, chunk):
return self.tornado_request.write(chunk) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write(self, *args, **kwargs):\n\n self.response.out.write(*args, **kwargs)",
"def write(self, *a, **kw):\n self.response.out.write(*a, **kw)",
"def write(self, *a, **kw):\n self.response.out.write(*a, **kw)",
"def write(self, *a, **kw):\n self.response.out.write(*a, **kw)",
... | [
"0.7011142",
"0.6603937",
"0.6603937",
"0.6603937",
"0.6603937",
"0.6603937",
"0.6459584",
"0.6459584",
"0.6424561",
"0.6364683",
"0.57424295",
"0.5591314",
"0.5554613",
"0.5515465",
"0.5395379",
"0.5374757",
"0.5356486",
"0.5350801",
"0.5335824",
"0.53176373",
"0.52599496",
... | 0.7030209 | 0 |
Convenience wrapper for the Tornado request's finish() method. | def finish(self):
return self.tornado_request.finish() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RequestHandler_finish(self):\n if self.request._oboe_finish_ev and self.request._oboe_ctx and self.request._oboe_ctx.is_valid():\n ev = self.request._oboe_finish_ev\n ctx = self.request._oboe_ctx\n if hasattr(self, 'get_status'): # recent Tornado\n ev.add_info(\"Status\", sel... | [
"0.6845464",
"0.65772814",
"0.6546038",
"0.6546038",
"0.64914596",
"0.643756",
"0.64001775",
"0.6219688",
"0.6184029",
"0.6064755",
"0.6025992",
"0.5989794",
"0.5957331",
"0.5918375",
"0.579136",
"0.57792234",
"0.5768139",
"0.57536525",
"0.57431555",
"0.5708127",
"0.569587",
... | 0.7975853 | 0 |
Returns the equivalent of the HTTP request's SCRIPT_NAME header variable. If Apache mod_rewrite has been used, returns what would have been the script name prior to any rewriting (so it's the script name as seen from the client's perspective), unless the FORCE_SCRIPT_NAME setting is set (to anything). | def get_script_name(t_req):
if settings.FORCE_SCRIPT_NAME is not None:
return force_text(settings.FORCE_SCRIPT_NAME)
# If Apache's mod_rewrite had a whack at the URL, Apache set either
# SCRIPT_URL or REDIRECT_URL to the full resource URL before applying any
# rewrites. Unfortunately not every ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getScriptname():\n return os.environ.get('SCRIPT_NAME', '')",
"def get_current_request_hostname():\r\n hostname = None\r\n request = get_current_request()\r\n if request:\r\n hostname = request.META.get('HTTP_HOST')\r\n\r\n return hostname",
"def get_wsgi_file_name(self):\n ret... | [
"0.74698013",
"0.64156264",
"0.6333524",
"0.5728996",
"0.5704559",
"0.551568",
"0.5501407",
"0.54212606",
"0.5419497",
"0.54038095",
"0.5375227",
"0.52965987",
"0.5247907",
"0.5221188",
"0.5179678",
"0.5173248",
"0.5162168",
"0.514716",
"0.5140043",
"0.5136708",
"0.51301867",... | 0.82943535 | 0 |
More proper boolean operator for easier reading. return 1 Indicate a found listener return 0 Indicates nobody listening | def is_listening(port):
return not listening(port) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isListening(self):\n if not self.proxy:\n self.proxy = self.session.service(\"ALExpressiveListening\")\n return self.proxy.isListening()",
"def listening(self):\n return self._server is not None",
"def available(self):\n from pyhs3 import STATE_LISTENING\n retu... | [
"0.66875106",
"0.65970385",
"0.6574591",
"0.65360075",
"0.6319728",
"0.6317834",
"0.6192521",
"0.61528975",
"0.6120801",
"0.6109273",
"0.60723865",
"0.6063828",
"0.60545415",
"0.6010599",
"0.5838284",
"0.58022517",
"0.5795148",
"0.5793659",
"0.57519114",
"0.57032394",
"0.5682... | 0.66736966 | 1 |
Process runtime args. Based on the args, run the program. Return the number of listeners for all provided ports. 100 == error for port | def main():
import getopt
try:
options, remainder = getopt.getopt(
sys.argv[1:], '',
['help', # Print usage msg, exit
'short', # Output is shortened
'pid', # Output only pid of listenig process
'proc', # Output only process ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def portcheck_main(args=sys.argv[1:]):\n ports = portcheck(*args)\n for i in ports:\n print '%s: %s' % (i, ports[i])\n return 0",
"def run_app():\n target = None\n negative_results = False\n\n description = 'Simple TCP port scanner'\n epilog = 'The author of this code take no responsi... | [
"0.6942394",
"0.66215736",
"0.63740706",
"0.62902844",
"0.60026693",
"0.5923105",
"0.58010936",
"0.57660186",
"0.5717203",
"0.56580085",
"0.5623557",
"0.55659944",
"0.55659944",
"0.55630726",
"0.5499098",
"0.5495286",
"0.54854834",
"0.5462336",
"0.54213244",
"0.5405209",
"0.5... | 0.7322132 | 0 |
Testing opssysd correctly stores switch_version column. Test if the opssysd correctly parse the osrelease file and stores the information in the OVSDB. | def check_switch_version(dut, file_name):
copy_os_release_file(dut, file_name)
# Restart the ovsdb-server and sysd
start(dut)
version_id = read_os_release_file(dut, file_name, 'VERSION_ID')
build_id = read_os_release_file(dut, file_name, 'BUILD_ID')
expected = "{0} (Build: {1})".format(version_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_update_hyperflex_server_firmware_version(self):\n pass",
"def init_linuxVersion(self):\n releaseDic = collections.OrderedDict() # 排序的字典\n releaseDic['/etc/oracle-release'] = self.__getOracleVersion\n releaseDic['/etc/redhat-release'] = self.__getRedhatVersion\n re... | [
"0.59922117",
"0.58298945",
"0.5813068",
"0.5752418",
"0.57282406",
"0.5699847",
"0.56906575",
"0.56672615",
"0.56032926",
"0.5582374",
"0.55770415",
"0.5560227",
"0.5493755",
"0.5482867",
"0.5482622",
"0.54738504",
"0.5470605",
"0.5469388",
"0.5446355",
"0.54303396",
"0.5381... | 0.6845919 | 0 |
Read the local osrelease file and return the data. | def read_os_release_file(dut, fname=default_os_release_file, key=None):
cur_dir, f = os.path.split(__file__)
path = os.path.join(cur_dir, os_release_files_dir, fname)
d = {}
with open(path) as f:
for line in f:
k, v = line.rstrip().split("=")
d[k] = v
if key:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_release_version():\n with open(\"RELEASE-VERSION\", \"r\") as f:\n return f.readline().strip()",
"def versionRead():\n xuvtop = os.environ['XUVTOP']\n vFileName = os.path.join(xuvtop, 'VERSION')\n vFile = open(vFileName)\n versionStr = vFile.readline()\n vFil... | [
"0.6877728",
"0.6081906",
"0.6046769",
"0.6038422",
"0.60357785",
"0.6028265",
"0.6022373",
"0.6018158",
"0.60076445",
"0.59902287",
"0.593641",
"0.589239",
"0.5883661",
"0.587215",
"0.5849723",
"0.5803643",
"0.5778237",
"0.57766265",
"0.5729708",
"0.5707521",
"0.5704802",
... | 0.68287444 | 1 |
Copy a given osrelease file to /etc/osrelease. | def copy_os_release_file(dut, fname=default_os_release_file):
# src = os.path.join(os.path.sep, 'shared', os_release_files_dir, fname)
dst = os.path.join(os.path.sep, 'etc', 'os-release')
dut("/bin/cp /tmp/files/os_releases/" + fname + " " + dst, shell="bash") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_os_release_file(**kwargs):\n\n LOGGER.info(\"Doing pre-flight checks\")\n\n releases_repo_url = OPENSTACK_REPOS + '/releases.git'\n releases_folder = kwargs['workdir'] + '/releases'\n\n oa_folder = kwargs['workdir'] + '/openstack-ansible'\n click.confirm((\"Are your sure your {} folder is... | [
"0.5891819",
"0.5617878",
"0.5600983",
"0.54453236",
"0.5412584",
"0.5301226",
"0.5192675",
"0.5176676",
"0.5082615",
"0.50576097",
"0.50236535",
"0.5004781",
"0.50029683",
"0.49893183",
"0.4973388",
"0.49352297",
"0.49307936",
"0.4925656",
"0.49127647",
"0.49001563",
"0.4860... | 0.7919572 | 0 |
Remove the OpenSwitch DB from ovsdbserver. It also removes the DB file from the file system. | def stop_ovsdb(dut):
# Remove the database from the ovsdb-server.
dut(ovs_appctl + "-t ovsdb-server ovsdb-server/remove-db OpenSwitch",
shell="bash")
# Remove the DB file from the file system.
dut("/bin/rm -f /var/run/openvswitch/ovsdb.db", shell="bash") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def db_remove():\n\n db.session.close()\n db.drop_all()\n\n path = current_app.config['SNER_VAR']\n for file_object in os.listdir(path):\n file_object_path = os.path.join(path, file_object)\n if os.path.isdir(file_object_path):\n shutil.rmtree(file_object_path)\n else:\n... | [
"0.7118374",
"0.70850265",
"0.6969073",
"0.6936522",
"0.6843543",
"0.6600032",
"0.6549064",
"0.6437333",
"0.6426025",
"0.6383878",
"0.636996",
"0.63381946",
"0.6297148",
"0.62754035",
"0.62196547",
"0.6199373",
"0.6198524",
"0.6159389",
"0.6147187",
"0.61467093",
"0.61348754"... | 0.76180816 | 0 |
Draws range of tower if clicked on. | def draw_range(self, win):
if self.selected:
surface = pygame.Surface((self.range * 4, self.range * 4), pygame.SRCALPHA, 32)
pygame.draw.circle(surface, (128, 128, 128, 100), (self.range, self.range), self.range, 0)
win.blit(surface, (self.x - self.range, self.y - self.range... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def draw_bounds():\n\n pass",
"def draw(self):\n if context.click():\n self.place()",
"def draw(self):\n #for (x, y) in self.coords:\n # pyxel.rect(\n # (x + self.x) * 4,\n # (y + self.y) * 4,\n # (x + self.x) * 4 + 3,\n # ... | [
"0.6205973",
"0.61523294",
"0.6008315",
"0.5989245",
"0.5944279",
"0.5893319",
"0.5844363",
"0.5831077",
"0.5826656",
"0.58184046",
"0.58160055",
"0.5798459",
"0.5755259",
"0.57308894",
"0.5701369",
"0.5675944",
"0.5657623",
"0.56501853",
"0.56467706",
"0.5638101",
"0.5619085... | 0.7217638 | 0 |
Returns the scan resolution in mm of the ship. | def scanResolution(self):
return self._getAttribute(Attribute.scanResolution) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getResolution(self):\n return self.resolution",
"def getResolution(self):\n return self._lowLevelGetDeviceResolution()",
"def get_current_resolution(self):\n return self.display_info[\"width\"], self.display_info[\"height\"]",
"def resolution(self) -> int:\n return self._resol... | [
"0.7246049",
"0.69126594",
"0.685117",
"0.6794998",
"0.67246604",
"0.6541934",
"0.6535295",
"0.6369",
"0.6277552",
"0.6272509",
"0.6237596",
"0.62197703",
"0.61901945",
"0.6151652",
"0.61414826",
"0.61146194",
"0.6110332",
"0.6093271",
"0.6090543",
"0.6054958",
"0.60548455",
... | 0.73278564 | 0 |
Returns the max number of locked targets. | def maxTargets(self):
return self._getAttribute(Attribute.maxTargets) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def maxTasksAchievable(self):\n maxTasks = 0\n for w in self._workers:\n maxTasks = maxTasks + w.multitask\n return maxTasks",
"def max_node_count(self) -> int:\n return pulumi.get(self, \"max_node_count\")",
"def node_count_max(self) -> int:\n return int(self.graph_tuple_stats.node_cou... | [
"0.7053719",
"0.6945075",
"0.67787427",
"0.6716458",
"0.66914487",
"0.65706974",
"0.6546918",
"0.6542584",
"0.65309083",
"0.65046275",
"0.6473251",
"0.6438238",
"0.6386052",
"0.6385337",
"0.6385203",
"0.63613576",
"0.6358105",
"0.63530767",
"0.63487595",
"0.6279512",
"0.62710... | 0.6987084 | 1 |
Returns the sensor strength of the ship. | def sensorStrength(self):
# TODO: also return type of sensor
radar = self._getAttribute(Attribute.scanRadarStrength)
ladar = self._getAttribute(Attribute.scanLadarStrength)
magnetometric = self._getAttribute(Attribute.scanMagnetometricStrength)
gravimetric = self._getAttribute(Attribute.scanGravimet... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getStrength(self):\n return self.st",
"def strength(self) -> int:\n return self._strength",
"def wireless_signal_strength(self) -> int:\n return self.data[Attribute.WIRELESS_SIGNAL_STRENGTH]",
"def getPersonStrength(self):\n strength = self.myDesign.myShipHull.mass/200\n ... | [
"0.72526914",
"0.67626673",
"0.6689082",
"0.6676303",
"0.6576709",
"0.6460022",
"0.6326511",
"0.6292669",
"0.62278104",
"0.6079792",
"0.60773563",
"0.602665",
"0.6026219",
"0.5985158",
"0.5903484",
"0.5875291",
"0.58557934",
"0.582385",
"0.5819542",
"0.58171266",
"0.58148235"... | 0.79078126 | 0 |
Returns details about the ship's capacitor. | def capacitor(self):
capacity = self._getAttribute(Attribute.capacitorCapacity)
recharge = self._getAttribute(Attribute.capacitorRecharge)
recharge /= 1000 # milliseconds
return {
"capacity": capacity,
"recharge": recharge,
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getShip(self):\r\n return self._ship",
"def my_ship_info(self, ship_id):\n r = requests.get(self.base_url + f'/users/{self.username}/ships/{ship_id}', headers=self.auth_header)\n return r.text",
"def get_card(self):\n return self.card",
"def card(self):\n return self.cd... | [
"0.6025865",
"0.5962599",
"0.5775231",
"0.5688934",
"0.5532411",
"0.53715676",
"0.53670514",
"0.5319011",
"0.52973115",
"0.52933747",
"0.5288867",
"0.5282726",
"0.5235691",
"0.5224877",
"0.52141637",
"0.52120286",
"0.5172074",
"0.5133092",
"0.51199114",
"0.50787777",
"0.50685... | 0.63753223 | 0 |
Returns details about the ship's armor. Resists are integers from 0 to 100. | def armor(self):
capacity = self._getAttribute(Attribute.armorCapacity)
em = self._getAttribute(Attribute.armorEM)
explosive = self._getAttribute(Attribute.armorExplosive)
kinetic = self._getAttribute(Attribute.armorKinetic)
thermal = self._getAttribute(Attribute.armorThermal)
em = 1.0 - em
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getArmor(self):\n return self.av",
"def armor(self) -> Union[int, float]:\n return self.type_data.proto.armor",
"def armor(self) -> Union[int, float]:\n return self.type_data.proto.armor",
"def get_armor_equipped(self):\n\t\treturn self.equippedArmor",
"def armor_mapping(self, armo... | [
"0.672655",
"0.6709763",
"0.6709763",
"0.6694133",
"0.5853349",
"0.5786742",
"0.5659746",
"0.56013674",
"0.5586368",
"0.55516726",
"0.54307085",
"0.54023623",
"0.52987903",
"0.5295258",
"0.52864414",
"0.524963",
"0.52466756",
"0.5236324",
"0.52125114",
"0.5185202",
"0.5182413... | 0.70991963 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.