code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# --- Day 17: Trick Shot ---
import math
import time
def get_puzzle_input(filepath):
with open(filepath) as f:
for line in f:
# target area: x=269..292, y =-68..-44
parts = line.rstrip().replace(',', '').split()
[x1, x2] = parts[2][2:].split("..")
[y1, y2] =... | [
"math.sqrt",
"time.time",
"math.floor"
] | [((7662, 7673), 'time.time', 'time.time', ([], {}), '()\n', (7671, 7673), False, 'import time\n'), ((7780, 7791), 'time.time', 'time.time', ([], {}), '()\n', (7789, 7791), False, 'import time\n'), ((6751, 6764), 'math.sqrt', 'math.sqrt', (['x1'], {}), '(x1)\n', (6760, 6764), False, 'import math\n'), ((7736, 7747), 'tim... |
import zipfile
zip_file = zipfile.ZipFile("zip_archive.zip", "w")
zip_file.write("textfile_for_zip_01")
zip_file.write("textfile_for_zip_02")
zip_file.write("textfile_for_zip_03")
# print(zipfile.is_zipfile("zip_archive.zip"))
# zip_file = zipfile.ZipFile("zip_archive.zip")
# print(zip_file.namelist())
... | [
"zipfile.ZipFile"
] | [((29, 68), 'zipfile.ZipFile', 'zipfile.ZipFile', (['"""zip_archive.zip"""', '"""w"""'], {}), "('zip_archive.zip', 'w')\n", (44, 68), False, 'import zipfile\n')] |
import logging
from datetime import datetime
import numpy as np
from logging.config import dictConfig
from kafkawrapper.producer import Producer
from utils.mongo_utils import BenchMarkingProcessRepo
from configs.configs import ulca_notifier_input_topic, ulca_notifier_benchmark_completed_event, ulca_notifier_benchmark_f... | [
"logging.getLogger",
"kafkawrapper.producer.Producer",
"utils.mongo_utils.BenchMarkingProcessRepo",
"models.metric_manager.MetricManager.getInstance",
"logging.config.dictConfig",
"datetime.datetime.now",
"numpy.round"
] | [((387, 412), 'logging.getLogger', 'logging.getLogger', (['"""file"""'], {}), "('file')\n", (404, 412), False, 'import logging\n'), ((421, 431), 'kafkawrapper.producer.Producer', 'Producer', ([], {}), '()\n', (429, 431), False, 'from kafkawrapper.producer import Producer\n'), ((439, 464), 'utils.mongo_utils.BenchMarkin... |
from datetime import datetime
import discord
import itertools
from .utils import formatString, getUsageEmbed, getOopsEmbed
# IDEAS
# 1. Paying out points (without bets)
class DiscordPoints:
"""
Class that parses Discord Points info and interactions
Attributes
__________
fire (Fire obj): The fire... | [
"datetime.datetime.today",
"discord.Colour.red",
"discord.Embed",
"itertools.groupby"
] | [((9243, 9259), 'datetime.datetime.today', 'datetime.today', ([], {}), '()\n', (9257, 9259), False, 'from datetime import datetime\n'), ((9276, 9342), 'discord.Embed', 'discord.Embed', ([], {'title': 'title', 'description': 'description', 'timestamp': 'now'}), '(title=title, description=description, timestamp=now)\n', ... |
from django.contrib import admin
from .models import MenuFacebook, MenuEmail, UserProfile, Occupation, FacebookRestaurant, EmailRestaurant
class MenuBaseAdmin(admin.ModelAdmin):
list_display = ('id', 'format_date', 'is_lunch', 'message')
list_filter = ('created_date', 'is_lunch')
list_editable = ('is_lun... | [
"django.contrib.admin.site.register"
] | [((1279, 1335), 'django.contrib.admin.site.register', 'admin.site.register', (['FacebookRestaurant', 'RestaurantAdmin'], {}), '(FacebookRestaurant, RestaurantAdmin)\n', (1298, 1335), False, 'from django.contrib import admin\n'), ((1336, 1389), 'django.contrib.admin.site.register', 'admin.site.register', (['EmailRestaur... |
""" Module containing helper routines for routes """
from typing import Dict, Any, Set, List, Tuple
import numpy as np
from route_distances.utils.type_utils import StrDict
def calc_depth(tree_dict: StrDict, depth: int = 0) -> int:
"""
Calculate the depth of a route, recursively
:param tree_dict: the ro... | [
"numpy.argsort"
] | [((3623, 3641), 'numpy.argsort', 'np.argsort', (['scores'], {}), '(scores)\n', (3633, 3641), True, 'import numpy as np\n')] |
from __future__ import print_function
from node.tests import NodeTestCase
from yafowil.base import factory
from yafowil.compat import IS_PY2
import lxml.etree as etree
import sys
import unittest
import yafowil.common
import yafowil.compound
import yafowil.persistence
import yafowil.table
if not IS_PY2:
from impor... | [
"unittest.TestSuite",
"yafowil.base.factory.clear",
"importlib.reload",
"lxml.etree.fromstring",
"unittest.findTestCases",
"lxml.etree.tostring"
] | [((625, 646), 'lxml.etree.fromstring', 'etree.fromstring', (['xml'], {}), '(xml)\n', (641, 646), True, 'import lxml.etree as etree\n'), ((1168, 1188), 'unittest.TestSuite', 'unittest.TestSuite', ([], {}), '()\n', (1186, 1188), False, 'import unittest\n'), ((453, 468), 'yafowil.base.factory.clear', 'factory.clear', ([],... |
import os
import dgl
import time
import argparse
import numpy as np
import torch as th
import distutils.util
import torch.nn.functional as F
import utils
import models
import data_loader
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
dev = th.device('cuda' if th.cuda.is_available() else 'cpu')
if __name__ == '__main__':
... | [
"utils.feat_norm",
"numpy.mean",
"utils.compute_acc",
"argparse.ArgumentParser",
"torch.nn.functional.nll_loss",
"torch.LongTensor",
"os.path.join",
"torch.FloatTensor",
"data_loader.KddDataset",
"utils.adj_preprocess",
"torch.cuda.is_available",
"dgl.DGLGraph",
"torch.nn.functional.log_soft... | [((336, 371), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""training"""'], {}), "('training')\n", (359, 371), False, 'import argparse\n'), ((1666, 1745), 'data_loader.KddDataset', 'data_loader.KddDataset', (['args.adj_path', 'args.feat_path', 'args.label_path', 'indices'], {}), '(args.adj_path, args.feat_... |
from __future__ import print_function
from configurations import configuration
from pymongo import MongoClient
MONGO_HOST= configuration.MONGO_HOST
client = MongoClient(MONGO_HOST)
class DBConnection():
def getConnection(self):
return client.analyticsDB
| [
"pymongo.MongoClient"
] | [((158, 181), 'pymongo.MongoClient', 'MongoClient', (['MONGO_HOST'], {}), '(MONGO_HOST)\n', (169, 181), False, 'from pymongo import MongoClient\n')] |
from typing import Any, List
from dataclasses import dataclass, replace
from .consts import OK
class Data:
def replace(self, **kwargs):
return replace(self, **kwargs)
@dataclass(frozen=True)
class RpcCall(Data):
route: str
service: str
method: str
args: List[Any]
@dataclass(frozen=Tr... | [
"dataclasses.dataclass",
"dataclasses.replace"
] | [((186, 208), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (195, 208), False, 'from dataclasses import dataclass, replace\n'), ((301, 323), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (310, 323), False, 'from dataclasses import dataclass, ... |
#!/usr/bin/python
import timeit
setup = '''
import os
def FileTest(path):
file = open(path, "r")
lines = file.readlines()
data = [None for i in range(len(lines))]
i = 0
for line in lines:
data[i] = line.split(',')
j = 0
for field in data[i]:
data[i][j] = field.strip('\\'\\n')
j += 1
i += 1
re... | [
"timeit.timeit"
] | [((345, 432), 'timeit.timeit', 'timeit.timeit', (['"""FileTest(os.getcwd() + \'/../employees.txt\')"""'], {'setup': 'setup', 'number': '(1)'}), '("FileTest(os.getcwd() + \'/../employees.txt\')", setup=setup,\n number=1)\n', (358, 432), False, 'import timeit\n'), ((477, 564), 'timeit.timeit', 'timeit.timeit', (['"""F... |
# -*- coding: utf-8 -*-
'''
Created on 25.9.2011
@author: xaralis
'''
from model_utils import Choices
SEXES = Choices(
(1, 'FEMALE', u'žena'),
(2, 'MALE', u'muž')
)
NATIONALITIES = Choices(
(1, 'CZ', u'Česká republika'),
(2, 'EU', u'Jiné - EU'),
(3, 'NON_EU', u'Jiné - non-EU'),
(4, 'UNKNOWN', ... | [
"model_utils.Choices"
] | [((112, 164), 'model_utils.Choices', 'Choices', (["(1, 'FEMALE', u'žena')", "(2, 'MALE', u'muž')"], {}), "((1, 'FEMALE', u'žena'), (2, 'MALE', u'muž'))\n", (119, 164), False, 'from model_utils import Choices\n'), ((191, 319), 'model_utils.Choices', 'Choices', (["(1, 'CZ', u'Česká republika')", "(2, 'EU', u'Jiné - EU')"... |
######################################################################
# OLED_Clock.py
#
# This program display date and time on OLED module
######################################################################
import Adafruit_SSD1306
from datetime import datetime
import time
from PIL import Image
from PIL impo... | [
"PIL.Image.new",
"PIL.ImageFont.truetype",
"time.sleep",
"Adafruit_SSD1306.SSD1306_128_64",
"datetime.datetime.now",
"PIL.ImageDraw.Draw"
] | [((392, 432), 'Adafruit_SSD1306.SSD1306_128_64', 'Adafruit_SSD1306.SSD1306_128_64', ([], {'rst': 'RST'}), '(rst=RST)\n', (423, 432), False, 'import Adafruit_SSD1306\n'), ((602, 634), 'PIL.ImageFont.truetype', 'ImageFont.truetype', (['fontFile', '(12)'], {}), '(fontFile, 12)\n', (620, 634), False, 'from PIL import Image... |
'''
Contains the extended FastAPI router, for simplified CRUD from a model
'''
from typing import Any, List, Optional, Sequence, Set, Type, Union
import fastapi
from fastapi import Depends, params
from pydantic import BaseModel, create_model
from odim import Odim, OkResponse, SearchResponse
from odim.dependencies imp... | [
"odim.OkResponse",
"odim.Odim",
"fastapi.Depends"
] | [((3431, 3452), 'fastapi.Depends', 'Depends', (['SearchParams'], {}), '(SearchParams)\n', (3438, 3452), False, 'from fastapi import Depends, params\n'), ((5915, 5927), 'odim.OkResponse', 'OkResponse', ([], {}), '()\n', (5925, 5927), False, 'from odim import Odim, OkResponse, SearchResponse\n'), ((2045, 2054), 'odim.Odi... |
from collections import namedtuple
RGB = namedtuple("RGB", "red, green, blue")
COLORS = {
"red": RGB(255, 0, 0),
"orange-deep": RGB(255, 40, 0),
"orange": RGB(255, 120, 0),
"yellow": RGB(255, 200, 0),
"yellow-acid": RGB(160, 255, 0),
"green": RGB(0, 255, 0),
"green-forest": RGB(34, 139, 34... | [
"collections.namedtuple"
] | [((42, 79), 'collections.namedtuple', 'namedtuple', (['"""RGB"""', '"""red, green, blue"""'], {}), "('RGB', 'red, green, blue')\n", (52, 79), False, 'from collections import namedtuple\n')] |
#!/usr/bin/env python
from helpers import sjoin, cjoin
from random import shuffle
card_types = [
("tax",1,1), # tax everyone 2 coins => bank
("soldier",2,1),
("sergeant",3,1),
("captain",4,2),
("emperor",1,5),
("prince",1,1), #... | [
"helpers.cjoin",
"random.shuffle"
] | [((1135, 1148), 'random.shuffle', 'shuffle', (['deck'], {}), '(deck)\n', (1142, 1148), False, 'from random import shuffle\n'), ((762, 802), 'helpers.cjoin', 'cjoin', (['self.name', 'self.cards', 'self.coins'], {}), '(self.name, self.cards, self.coins)\n', (767, 802), False, 'from helpers import sjoin, cjoin\n')] |
import bson
import json
import swifty
#
# GET /tasks -- list tasks
# POST /tasks $BODY -- add new task
# GET /tasks/ID -- get info about task
# PUT /tasks/ID -- update task (except status)
# DELETE /tasks/ID -- remove task
# POST /tasks/ID/done -- mark task as done
#
def toTask(o... | [
"bson.ObjectId",
"json.loads",
"swifty.MongoDatabase"
] | [((440, 456), 'json.loads', 'json.loads', (['body'], {}), '(body)\n', (450, 456), False, 'import json\n'), ((532, 561), 'swifty.MongoDatabase', 'swifty.MongoDatabase', (['"""tasks"""'], {}), "('tasks')\n", (552, 561), False, 'import swifty\n'), ((1090, 1109), 'bson.ObjectId', 'bson.ObjectId', (['p[1]'], {}), '(p[1])\n'... |
# https://dmoj.ca/problem/tss17a
# https://dmoj.ca/submission/2226280
import sys
n = int(sys.stdin.readline()[:-1])
for i in range(n):
instruction = sys.stdin.readline()[:-1].split()
printed = False
for j in range(3):
if instruction.count(instruction[j]) >= 2:
print(instruction[j])
... | [
"sys.stdin.readline"
] | [((90, 110), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (108, 110), False, 'import sys\n'), ((154, 174), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (172, 174), False, 'import sys\n')] |
from todo.templatetags.todo_tags import is_management
from django.contrib.auth.decorators import login_required, user_passes_test
from django.http import HttpResponse
from django.shortcuts import render
from todo.models import Designer, Management, Writer, Editor
@login_required
@user_passes_test(is_management)
def u... | [
"django.shortcuts.render",
"todo.models.Writer.objects.all",
"todo.models.Editor.objects.all",
"todo.models.Designer.objects.all",
"django.contrib.auth.decorators.user_passes_test",
"todo.models.Management.objects.all"
] | [((283, 314), 'django.contrib.auth.decorators.user_passes_test', 'user_passes_test', (['is_management'], {}), '(is_management)\n', (299, 314), False, 'from django.contrib.auth.decorators import login_required, user_passes_test\n'), ((1108, 1158), 'django.shortcuts.render', 'render', (['request', '"""todo/users_detail.h... |
from bluepy import btle
import concurrent
from concurrent import futures
import threading
import multiprocessing
import time
from time_sync import *
import eval_client
import dashBoardClient
from joblib import dump, load
import numpy # to count labels and store in dict
import operator # to get most predicted label
im... | [
"random.choice",
"numpy.unique",
"bluepy.btle.DefaultDelegate.__init__",
"concurrent.futures.ThreadPoolExecutor",
"bluepy.btle.Peripheral",
"dashBoardClient.Client",
"json.dumps",
"time.sleep",
"sklearn.preprocessing.StandardScaler",
"multiprocessing.Pool",
"joblib.load",
"operator.itemgetter"... | [((469, 518), 'bluepy.btle.UUID', 'btle.UUID', (['"""0000dfb1-0000-1000-8000-00805f9b34fb"""'], {}), "('0000dfb1-0000-1000-8000-00805f9b34fb')\n", (478, 518), False, 'from bluepy import btle\n'), ((25115, 25157), 'numpy.unique', 'numpy.unique', (['pred_arr'], {'return_counts': '(True)'}), '(pred_arr, return_counts=True... |
import os
import keras
import skimage.io
import keras_contrib.applications
from metrics import *
from mrcnn import utils
from mrcnn import config
from imgaug import augmenters as iaa
from dataset import Dataset, PoseEstimationDataset
import numpy as np
import keras.backend as K
import mrcnn.model as modellib
class Con... | [
"keras.optimizers.Adam",
"mrcnn.model.MaskRCNN",
"os.path.exists",
"keras.layers.Flatten",
"mrcnn.utils.download_trained_weights",
"os.makedirs",
"keras.callbacks.ReduceLROnPlateau",
"imgaug.augmenters.GaussianBlur",
"keras.backend.square",
"os.path.join",
"dataset.PoseEstimationDataset",
"ker... | [((2767, 2798), 'keras.optimizers.Adam', 'keras.optimizers.Adam', ([], {'lr': '(0.001)'}), '(lr=0.001)\n', (2788, 2798), False, 'import keras\n'), ((1051, 1164), 'mrcnn.model.MaskRCNN', 'modellib.MaskRCNN', ([], {'mode': "('training' if mode == self.TRAIN else 'inference')", 'config': 'self.config', 'model_dir': 'logs'... |
from django.conf.urls import include, url
from donations.views import DonateAPI, VerifyAPI
app_name = 'donations'
api_urls = ([
url(r'^donate/$', DonateAPI.as_view(), name="donate"),
url(r'^verify/(?P<pk>[0-9]+)$', VerifyAPI.as_view(), name="verify"),
], "donations")
donations = ([
url(r'^api/', include... | [
"django.conf.urls.include",
"donations.views.VerifyAPI.as_view",
"donations.views.DonateAPI.as_view"
] | [((397, 438), 'django.conf.urls.include', 'include', (['donations'], {'namespace': '"""donations"""'}), "(donations, namespace='donations')\n", (404, 438), False, 'from django.conf.urls import include, url\n'), ((153, 172), 'donations.views.DonateAPI.as_view', 'DonateAPI.as_view', ([], {}), '()\n', (170, 172), False, '... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Feb 19 23:38:25 2022
@author: goran
"""
from ..general_cp import GeneralCP
from ..cp_utils import to_degrees, dihedral_angle, normal
from math import sqrt, pi, tan, atan2
box_packing_cell_nodes = {'A': (2, 0),
'B': (4, 0),
... | [
"math.sqrt"
] | [((532, 539), 'math.sqrt', 'sqrt', (['(2)'], {}), '(2)\n', (536, 539), False, 'from math import sqrt, pi, tan, atan2\n')] |
from .modules.common import *
import numpy as np
import os
from .modules.rs_structs import getRSformat
class RockstarFile(object):
def __init__(self,binfile,data,galaxies,debug):
self.galaxies = galaxies
self.binfile = binfile
self.debug = debug
self.header()
self.... | [
"os.path.isfile",
"numpy.fromfile",
"numpy.asarray",
"numpy.zeros"
] | [((2883, 2898), 'numpy.asarray', 'np.asarray', (['arr'], {}), '(arr)\n', (2893, 2898), True, 'import numpy as np\n'), ((1123, 1187), 'numpy.fromfile', 'np.fromfile', (['self.f'], {'dtype': 'self.halostruct', 'count': 'self.num_halos'}), '(self.f, dtype=self.halostruct, count=self.num_halos)\n', (1134, 1187), True, 'imp... |
import boto3
from datetime import datetime, date
import re
import string
import pandas as pd
from spellchecker import SpellChecker
import uuid
import psycopg2
from psycopg2 import sql
import sys
sys.path.append('.')
from rule_processing import postgresql
def queryTable(conn, table):
cmd = """
SELECT * FROM ... | [
"rule_processing.postgresql.connect",
"boto3.client",
"re.compile",
"datetime.datetime.strptime",
"spellchecker.SpellChecker",
"uuid.uuid4",
"string.punctuation.replace",
"datetime.date.today",
"sys.path.append",
"psycopg2.sql.Identifier",
"psycopg2.sql.SQL"
] | [((198, 218), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (213, 218), False, 'import sys\n'), ((466, 505), 'boto3.client', 'boto3.client', ([], {'service_name': '"""comprehend"""'}), "(service_name='comprehend')\n", (478, 505), False, 'import boto3\n'), ((516, 562), 'boto3.client', 'boto3.client... |
import datetime
from bgmi.script import ScriptBase
from bgmi.utils import parse_episode
class Script(ScriptBase):
class Model(ScriptBase.Model):
bangumi_name = "TEST_BANGUMI"
cover = ""
update_time = "Mon"
due_date = datetime.datetime(2017, 9, 30)
def get_download_url(self):
... | [
"datetime.datetime",
"bgmi.utils.parse_episode"
] | [((256, 286), 'datetime.datetime', 'datetime.datetime', (['(2017)', '(9)', '(30)'], {}), '(2017, 9, 30)\n', (273, 286), False, 'import datetime\n'), ((999, 1027), 'bgmi.utils.parse_episode', 'parse_episode', (["item['title']"], {}), "(item['title'])\n", (1012, 1027), False, 'from bgmi.utils import parse_episode\n')] |
from collections import deque
def fill_the_box(*args):
box_size = args[0] * args[1] * args[2]
args = deque(args[3:])
while args:
curr_arg = args.popleft()
if curr_arg == "Finish":
break
box_size -= curr_arg
if box_size < 0:
args.remove("Finish")
... | [
"collections.deque"
] | [((111, 126), 'collections.deque', 'deque', (['args[3:]'], {}), '(args[3:])\n', (116, 126), False, 'from collections import deque\n')] |
"""Implementation of allocation API.
"""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import logging
from treadmill import discovery
from treadmill import context
_LOGGER = logging.getLogger(__name__)
class AP... | [
"logging.getLogger",
"treadmill.discovery.iterator"
] | [((282, 309), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (299, 309), False, 'import logging\n'), ((556, 643), 'treadmill.discovery.iterator', 'discovery.iterator', (['context.GLOBAL.zk.conn', "('root.%s' % hostname)", '"""nodeinfo"""', '(False)'], {}), "(context.GLOBAL.zk.conn, 'root.... |
from django.shortcuts import render
from django.shortcuts import HttpResponse
# Create your views here.
def index(request):
return HttpResponse('Hello World</en>')
| [
"django.shortcuts.HttpResponse"
] | [((134, 166), 'django.shortcuts.HttpResponse', 'HttpResponse', (['"""Hello World</en>"""'], {}), "('Hello World</en>')\n", (146, 166), False, 'from django.shortcuts import HttpResponse\n')] |
#!/usr/bin/python3
# I don't believe in license.
# You can do whatever you want with this program.
import os
import sys
import re
import time
import requests
import random
import argparse
from urllib.parse import urlparse
from functools import partial
from colored import fg, bg, attr
from multiprocessing.dummy import... | [
"random.choice",
"colored.fg",
"argparse.ArgumentParser",
"urllib.parse.urlparse",
"re.match",
"requests.get",
"os.path.isfile",
"tldextract.extract",
"os.path.realpath",
"re.findall",
"functools.partial",
"colored.attr",
"random.random",
"multiprocessing.dummy.Pool",
"sys.stdout.write"
... | [((6684, 6709), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (6707, 6709), False, 'import argparse\n'), ((8280, 8307), 'tldextract.extract', 'tldextract.extract', (['_domain'], {}), '(_domain)\n', (8298, 8307), False, 'import tldextract\n'), ((7501, 7528), 'os.path.isfile', 'os.path.isfile', ... |
"""
Solves a 3x3 square programmatically.
It is not meant to be a full blown solution for magic squares, but rather a writeup
of my thoughts on how it can be solved.
"""
import statistics
def make_pairs(I, mid):
"""
We take pairs as [ [9, 1], [8, 2], [7, 3], [6, 4]]
:param I:
:param mid:
:return:... | [
"statistics.median"
] | [((559, 579), 'statistics.median', 'statistics.median', (['I'], {}), '(I)\n', (576, 579), False, 'import statistics\n')] |
import napari
from pathlib import Path
from magicgui import magicgui
from typing import List
from cellfinder_napari.utils import brainglobe_logo
# TODO:
# how to store & fetch pre-trained models?
# TODO: params to add
NETWORK_VOXEL_SIZES = [5, 1, 1]
CUBE_WIDTH = 50
CUBE_HEIGHT = 20
CUBE_DEPTH = 20
# If using ROI, h... | [
"pathlib.Path.home",
"math.ceil",
"cellfinder_core.classify.cube_generator.get_cube_depth_min_max",
"cellfinder_core.main.main"
] | [((1099, 1110), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (1108, 1110), False, 'from pathlib import Path\n'), ((7906, 8325), 'cellfinder_core.main.main', 'cellfinder_run', (['signal', 'background', 'voxel_sizes'], {'soma_diameter': 'Soma_diameter', 'ball_xy_size': 'ball_xy_size', 'ball_z_size': 'ball_z_size',... |
from setuptools import setup, find_packages
version = {}
with open("nltools/version.py") as f:
exec(f.read(), version)
with open("requirements.txt") as f:
requirements = f.read().splitlines()
extra_setuptools_args = dict(tests_require=["pytest"])
setup(
name="nltools",
version=version["__version__"]... | [
"setuptools.find_packages"
] | [((559, 599), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "['nltools/tests']"}), "(exclude=['nltools/tests'])\n", (572, 599), False, 'from setuptools import setup, find_packages\n')] |
from responsum.utils.fits_file import FITSFile, FITSExtension as FE
import pkg_resources
class FITSExtension(FE):
# I use __new__ instead of __init__ because I need to use the classmethod .from_columns instead of the
# constructor of fits.BinTableHDU
def __init__(self, data_tuple, header_tuple):
... | [
"pkg_resources.get_distribution"
] | [((351, 393), 'pkg_resources.get_distribution', 'pkg_resources.get_distribution', (['"""cosmogrb"""'], {}), "('cosmogrb')\n", (381, 393), False, 'import pkg_resources\n')] |
#! -*- coding:utf-8
from typing import Callable, List, Optional
import numpy as np
import torch
import torchvision
__all__ = ["CIFAR10", "FashionMNIST"]
class CIFAR10(torch.utils.data.Dataset):
def __init__(self,
root: str,
train: bool = True,
tra... | [
"numpy.random.shuffle",
"torchvision.datasets.FashionMNIST",
"torchvision.datasets.CIFAR10"
] | [((709, 835), 'torchvision.datasets.CIFAR10', 'torchvision.datasets.CIFAR10', (['root'], {'train': 'train', 'transform': 'transform', 'target_transform': 'target_transform', 'download': 'download'}), '(root, train=train, transform=transform,\n target_transform=target_transform, download=download)\n', (737, 835), Fal... |
from detectron2 import model_zoo
from detectron2.engine import DefaultPredictor
from detectron2.config import get_cfg
from detectron2.utils.visualizer import Visualizer
from detectron2.data import MetadataCatalog
import torch
import numpy as np
import cv2
class Model:
def __init__(self,confidence_thresh=0.6):
... | [
"numpy.clip",
"detectron2.config.get_cfg",
"detectron2.model_zoo.get_checkpoint_url",
"numpy.zeros",
"detectron2.model_zoo.get_config_file",
"detectron2.engine.DefaultPredictor"
] | [((333, 342), 'detectron2.config.get_cfg', 'get_cfg', ([], {}), '()\n', (340, 342), False, 'from detectron2.config import get_cfg\n'), ((580, 669), 'detectron2.model_zoo.get_checkpoint_url', 'model_zoo.get_checkpoint_url', (['"""COCO-InstanceSegmentation/mask_rcnn_R_50_FPN_3x.yaml"""'], {}), "(\n 'COCO-InstanceSegme... |
from setuptools import setup
setup(
name="example-advanced-package", version="0.0.0", packages=[],
)
| [
"setuptools.setup"
] | [((30, 98), 'setuptools.setup', 'setup', ([], {'name': '"""example-advanced-package"""', 'version': '"""0.0.0"""', 'packages': '[]'}), "(name='example-advanced-package', version='0.0.0', packages=[])\n", (35, 98), False, 'from setuptools import setup\n')] |
from distutils.core import setup
setup(
name='pyASA',
packages=['pyASA'],
version='0.1.0',
description='Wrapper for the Cisco ASA REST API',
author='xpac',
author_email='<EMAIL>',
url='https://github.com/xpac1985/pyASA',
download_url='https://github.com/xpac1985/pyASA/tarball/0.1.0',
... | [
"distutils.core.setup"
] | [((34, 378), 'distutils.core.setup', 'setup', ([], {'name': '"""pyASA"""', 'packages': "['pyASA']", 'version': '"""0.1.0"""', 'description': '"""Wrapper for the Cisco ASA REST API"""', 'author': '"""xpac"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/xpac1985/pyASA"""', 'download_url': '"""https://... |
import numpy as np
from example_functions import target_function_dict
from line_search_methods import line_search_dict
from main_methods import main_method_dict
from config import best_params
from helpers import generate_x0
def run_one(_theta, _main_method, _ls_method, params, ls_params):
theta = _theta()
x0... | [
"numpy.array",
"helpers.generate_x0",
"numpy.warnings.filterwarnings"
] | [((946, 1007), 'numpy.warnings.filterwarnings', 'np.warnings.filterwarnings', (['"""ignore"""'], {'category': 'RuntimeWarning'}), "('ignore', category=RuntimeWarning)\n", (972, 1007), True, 'import numpy as np\n'), ((323, 358), 'helpers.generate_x0', 'generate_x0', (['theta.n', '*theta.bounds'], {}), '(theta.n, *theta.... |
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView
class GetTypeView(APIView):
permission_classes = [IsAuthenticated]
def get(self, request):
user = request.user
if hasattr(user, 'vendor'):
t... | [
"rest_framework.response.Response"
] | [((676, 690), 'rest_framework.response.Response', 'Response', (['data'], {}), '(data)\n', (684, 690), False, 'from rest_framework.response import Response\n')] |
'''
This is an abstract example of Extracting in an ETL pipeline.
Inspired from the "Introduction to Data Engineering" course on Datacamp.com
Author: <NAME>
'''
import requests
# Fetch the Hackernews post
resp = requests.get("https://hacker-news.firebaseio.com/v0/item/16222426.json")
# Print the response parsed as ... | [
"requests.get"
] | [((215, 287), 'requests.get', 'requests.get', (['"""https://hacker-news.firebaseio.com/v0/item/16222426.json"""'], {}), "('https://hacker-news.firebaseio.com/v0/item/16222426.json')\n", (227, 287), False, 'import requests\n')] |
"""
* 보석과 돌
J는 보석이며, S는 갖고 있는 돌이다. S에는 보석이 몇 개나 있을까? 대소문자는 구분한다.
- Example 1
Input : J = "aA", S = "aAAbbbb"
Output : 3
- Example 2
Input : J = "z", S = "ZZ"
Output : 0
"""
import collections
class Solution:
# Counter로 계산 생략
def numJewelsInStones(self, J: str, S: str) -> int:
freqs = collections.Count... | [
"collections.Counter"
] | [((303, 325), 'collections.Counter', 'collections.Counter', (['S'], {}), '(S)\n', (322, 325), False, 'import collections\n')] |
from __future__ import print_function
import time
import uuid
import Adafruit_BluefruitLE
CHARACTERISTIC_SERVICE_UUID = uuid.UUID('0000fee0-0000-1000-8000-00805f9b34fb')
CHARACTERISTIC_DATA_UUID = uuid.UUID('0000fee1-0000-1000-8000-00805f9b34fb')
provider = Adafruit_BluefruitLE.get_provider()
def main():
provi... | [
"Adafruit_BluefruitLE.get_provider",
"uuid.UUID",
"time.sleep"
] | [((123, 172), 'uuid.UUID', 'uuid.UUID', (['"""0000fee0-0000-1000-8000-00805f9b34fb"""'], {}), "('0000fee0-0000-1000-8000-00805f9b34fb')\n", (132, 172), False, 'import uuid\n'), ((200, 249), 'uuid.UUID', 'uuid.UUID', (['"""0000fee1-0000-1000-8000-00805f9b34fb"""'], {}), "('0000fee1-0000-1000-8000-00805f9b34fb')\n", (209... |
# coding=utf-8
# Copyright 2020 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"turkish_morphology.validate.analysis",
"os.path.join",
"absl.testing.parameterized.named_parameters",
"absl.testing.absltest.main",
"turkish_morphology.analysis_pb2.Analysis"
] | [((1038, 1086), 'os.path.join', 'os.path.join', (['_TESTDATA_DIR', 'f"""{basename}.pbtxt"""'], {}), "(_TESTDATA_DIR, f'{basename}.pbtxt')\n", (1050, 1086), False, 'import os\n'), ((1207, 1673), 'absl.testing.parameterized.named_parameters', 'parameterized.named_parameters', (["[{'testcase_name': 'SingleInflectionalGrou... |
import skimage.color
import matplotlib.pyplot as plt
import numpy as np
import cv2
import os
import imghdr
import time
"""
Duplicate Image Finder (DIF): function that searches a given directory for images and finds duplicate/similar images among them.
Outputs the number of found duplicate/similar image pairs with a l... | [
"matplotlib.pyplot.imshow",
"numpy.fromfile",
"os.listdir",
"os.stat",
"time.sleep",
"os.remove",
"matplotlib.pyplot.figure",
"os.path.isdir",
"imghdr.what",
"numpy.rot90",
"numpy.concatenate",
"matplotlib.pyplot.axis",
"cv2.resize",
"matplotlib.pyplot.suptitle",
"matplotlib.pyplot.show"... | [((3912, 3927), 'time.sleep', 'time.sleep', (['(0.5)'], {}), '(0.5)\n', (3922, 3927), False, 'import time\n'), ((6198, 6210), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (6208, 6210), True, 'import matplotlib.pyplot as plt\n'), ((6219, 6250), 'matplotlib.pyplot.suptitle', 'plt.suptitle', (["('MSE: %.2f'... |
# A função min_max deverá rodar em O(n) e o código não pode usar nenhuma
# lib do Python (sort, min, max e etc)
# Não pode usar qualquer laço (while, for), a função deve ser recursiva
# Ou delegar a solução para uma função puramente recursiva
import unittest
def bora(cont, seq, min, max):
if cont < len(seq):
... | [
"unittest.main"
] | [((1556, 1571), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1569, 1571), False, 'import unittest\n')] |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
import json
import boto3
import os
from aws_lambda_powertools import Logger
logger = Logger()
client = boto3.client('stepfunctions')
sfnArn = os.environ['SFN_ARN']
def lambda_handler(event, context):
# TODO impl... | [
"json.dumps",
"aws_lambda_powertools.Logger",
"boto3.client"
] | [((189, 197), 'aws_lambda_powertools.Logger', 'Logger', ([], {}), '()\n', (195, 197), False, 'from aws_lambda_powertools import Logger\n'), ((207, 236), 'boto3.client', 'boto3.client', (['"""stepfunctions"""'], {}), "('stepfunctions')\n", (219, 236), False, 'import boto3\n'), ((611, 644), 'json.dumps', 'json.dumps', ([... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests for the AES decrypter object."""
import unittest
from dfvfs.encryption import aes_decrypter
from dfvfs.lib import definitions
from tests.encryption import test_lib
class AESDecrypterTestCase(test_lib.DecrypterTestCase):
"""Tests for the AES decrypter object.... | [
"unittest.main",
"dfvfs.encryption.aes_decrypter.AESDecrypter"
] | [((3052, 3067), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3065, 3067), False, 'import unittest\n'), ((1024, 1119), 'dfvfs.encryption.aes_decrypter.AESDecrypter', 'aes_decrypter.AESDecrypter', ([], {'cipher_mode': 'definitions.ENCRYPTION_MODE_ECB', 'key': 'self._AES_KEY'}), '(cipher_mode=definitions.ENCRYPTIO... |
import torch
import numpy as np
PAD_TOKEN_INDEX = 0
def pad_masking(x, target_len):
# x: (batch_size, seq_len)
batch_size, seq_len = x.size()
padded_positions = x == PAD_TOKEN_INDEX # (batch_size, seq_len)
pad_mask = padded_positions.unsqueeze(1).expand(batch_size, target_len, seq_len)
return pa... | [
"torch.tensor",
"numpy.ones"
] | [((534, 563), 'torch.tensor', 'torch.tensor', (['subsequent_mask'], {}), '(subsequent_mask)\n', (546, 563), False, 'import torch\n'), ((456, 489), 'numpy.ones', 'np.ones', ([], {'shape': '(seq_len, seq_len)'}), '(shape=(seq_len, seq_len))\n', (463, 489), True, 'import numpy as np\n')] |
# Dedicated to the public domain under CC0: https://creativecommons.org/publicdomain/zero/1.0/.
import ast
import os
import re
import shlex
from itertools import zip_longest
from string import Template
from typing import *
from .pithy.fs import *
from .pithy.io import *
from .pithy.types import * # type: ignore
fro... | [
"string.Template",
"re.escape",
"itertools.zip_longest"
] | [((17321, 17364), 'itertools.zip_longest', 'zip_longest', (['exp.match_pattern_pairs', 'lines'], {}), '(exp.match_pattern_pairs, lines)\n', (17332, 17364), False, 'from itertools import zip_longest\n'), ((9536, 9549), 'string.Template', 'Template', (['val'], {}), '(val)\n', (9544, 9549), False, 'from string import Temp... |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
#%matplotlib inline
import codecs
import lightgbm as lgb
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score
# Read data
image_file_path = './simulated_dpc_d... | [
"sklearn.model_selection.StratifiedShuffleSplit",
"numpy.sqrt",
"pandas.DataFrame",
"pandas.merge",
"lightgbm.train",
"sklearn.metrics.mean_squared_error",
"lightgbm.Dataset",
"pandas.read_table",
"pandas.get_dummies",
"codecs.open",
"sklearn.metrics.r2_score",
"pandas.concat"
] | [((674, 703), 'pandas.get_dummies', 'pd.get_dummies', (["dpc_r['code']"], {}), "(dpc_r['code'])\n", (688, 703), True, 'import pandas as pd\n'), ((778, 809), 'pandas.concat', 'pd.concat', (['[dpc_r, g_r]'], {'axis': '(1)'}), '([dpc_r, g_r], axis=1)\n', (787, 809), True, 'import pandas as pd\n'), ((1684, 1762), 'pandas.m... |
#%%
import sys
import numpy as np
from typing import Any, List
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
sys.path.append('C:/Users/panos/Documents/Διπλωματική/code/fz')
from arfftocsv import function_labelize
import csv
colnames =['age', 'sex', 'cp', 'trestbps', 'chol',
'fbs', 'restecg', 'thal... | [
"arfftocsv.function_labelize",
"sys.path.append",
"sklearn.preprocessing.MinMaxScaler",
"pandas.concat"
] | [((130, 193), 'sys.path.append', 'sys.path.append', (['"""C:/Users/panos/Documents/Διπλωματική/code/fz"""'], {}), "('C:/Users/panos/Documents/Διπλωματική/code/fz')\n", (145, 193), False, 'import sys\n'), ((388, 487), 'arfftocsv.function_labelize', 'function_labelize', ([], {'dest': '"""labeled_data1.txt"""', 'labels': ... |
"""
The follwing constructor classes exists here:
+------------------------------------------+---------------------------------------+
| Class | Description |
+==========================================+=======================================+
| :py:class:`~... | [
"supplement.suggests.get",
"doctest.testmod"
] | [((10305, 10322), 'doctest.testmod', 'doctest.testmod', ([], {}), '()\n', (10320, 10322), False, 'import doctest\n'), ((10220, 10253), 'supplement.suggests.get', 'supplement.suggests.get', (['instance'], {}), '(instance)\n', (10243, 10253), False, 'import supplement\n')] |
#!/usr/bin/env python3
"""awspfx
Usage:
awspfx.py <profile>
awspfx.py [(-c | --current) | (-l | --list) | (-s | --swap)]
awspfx.py token [(-p | --profile) <profile>]
awspfx.py sso [(login | token)] [(-p | --profile) <profile>]
awspfx.py -h | --help
awspfx.py --version
Examples:
awspfx.py ... | [
"logging.getLogger",
"logging.StreamHandler",
"boto3.session.Session",
"configparser.ConfigParser",
"re.compile",
"sys.exit",
"docopt.docopt",
"os.listdir",
"shutil.move",
"iterfzf.iterfzf",
"logging.root.setLevel",
"tempfile.NamedTemporaryFile",
"os.path.expanduser",
"shutil.copystat",
... | [((1326, 1358), 'logging.root.setLevel', 'logging.root.setLevel', (['log_level'], {}), '(log_level)\n', (1347, 1358), False, 'import logging\n'), ((1375, 1403), 'colorlog.ColoredFormatter', 'ColoredFormatter', (['log_format'], {}), '(log_format)\n', (1391, 1403), False, 'from colorlog import ColoredFormatter\n'), ((141... |
"""
Re-tooled version of the script found on VideoToTextDNN:
https://github.com/OSUPCVLab/VideoToTextDNN/blob/master/data/process_frames.py
"""
import sys
import os
import argparse
import time
from multiprocessing import Pool
def main(args):
src_dir = args.src_dir
dst_dir = args.dst_dir
start = int(args.s... | [
"os.listdir",
"argparse.ArgumentParser",
"os.path.join",
"os.path.isdir",
"multiprocessing.Pool",
"os.mkdir",
"sys.exit",
"os.system",
"time.time"
] | [((394, 413), 'os.listdir', 'os.listdir', (['src_dir'], {}), '(src_dir)\n', (404, 413), False, 'import os\n'), ((731, 737), 'multiprocessing.Pool', 'Pool', ([], {}), '()\n', (735, 737), False, 'from multiprocessing import Pool\n'), ((1393, 1418), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (... |
from django.contrib.auth.hashers import get_hashers_by_algorithm
from django.core import checks
@checks.register(checks.Tags.security, deploy=True)
def check_for_plaintext_passwords(app_configs, **kwargs):
if "plaintext" in get_hashers_by_algorithm():
yield checks.Critical(
"Plaintext module s... | [
"django.core.checks.register",
"django.contrib.auth.hashers.get_hashers_by_algorithm",
"django.core.checks.Critical"
] | [((99, 149), 'django.core.checks.register', 'checks.register', (['checks.Tags.security'], {'deploy': '(True)'}), '(checks.Tags.security, deploy=True)\n', (114, 149), False, 'from django.core import checks\n'), ((230, 256), 'django.contrib.auth.hashers.get_hashers_by_algorithm', 'get_hashers_by_algorithm', ([], {}), '()... |
from app.extensions import db
from flask import current_app
class User(db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
access_token = db.Column(db.String())
jit_feature = db.Column(db.Boolean())
recurrence_resch_feature = db.Column(db.Boolean())
streaks_feature ... | [
"flask.current_app.task_queue.enqueue",
"app.extensions.db.Boolean",
"app.extensions.db.String",
"app.extensions.db.Column"
] | [((121, 160), 'app.extensions.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (130, 160), False, 'from app.extensions import db\n'), ((190, 201), 'app.extensions.db.String', 'db.String', ([], {}), '()\n', (199, 201), False, 'from app.extensions import db\n'), ((... |
from dataclasses import dataclass, field
from enum import Enum
from typing import Optional
from output.models.boeing_data.ipo4.ipo_xsd.ipo import AddressType
__NAMESPACE__ = "http://www.example.com/IPO"
class Usstate(Enum):
AK = "AK"
AL = "AL"
AR = "AR"
CA = "CA"
PA = "PA"
@dataclass
class Ukad... | [
"dataclasses.field"
] | [((414, 542), 'dataclasses.field', 'field', ([], {'default': 'None', 'metadata': "{'type': 'Element', 'namespace': '', 'required': True, 'pattern':\n '[A-Z]{2}\\\\d\\\\s\\\\d[A-Z]{2}'}"}), "(default=None, metadata={'type': 'Element', 'namespace': '',\n 'required': True, 'pattern': '[A-Z]{2}\\\\d\\\\s\\\\d[A-Z]{2}... |
# <NAME>
# CPSC 386-01
# 2021-11-29
# <EMAIL>
# @JaredDyreson
#
# Lab 00-04
#
# Some filler text
#
"""
This module contains the Intro display class
"""
import pygame
import functools
import sys
import pathlib
import typing
import os
import dataclasses
import random
from pprint import pprint as pp
import time
from In... | [
"pygame.sprite.groupcollide",
"Invaders.Dataclasses.point.Point",
"pygame.quit",
"pygame.event.get",
"pygame.sprite.Group",
"Invaders.Entities.enemy_matrix.EnemyMatrix",
"pygame.display.flip",
"os.path.join",
"random.choices",
"sys.exit",
"pygame.Color",
"pygame.time.set_timer",
"pygame.font... | [((1366, 1406), 'Invaders.Entities.enemy_matrix.EnemyMatrix', 'EnemyMatrix', (['(5)', '(5)', 'self._display_surface'], {}), '(5, 5, self._display_surface)\n', (1377, 1406), False, 'from Invaders.Entities.enemy_matrix import EnemyMatrix\n'), ((1820, 1834), 'Invaders.Dataclasses.point.Point', 'Point', (['(775)', '(20)'],... |
import os
import re
MODEL_FILE_FORMAT = 'weights.{epoch:02d}-{val_loss:.2f}.h5'
MODEL_REGEX_PATTERN = re.compile(r'^.*weights\.(\d+)\-\d+\.\d+\.h5$')
LAST_MODEL_FILE_FORMAT = 'last.h5'
TEAMS_WEBHOOK_URL = os.environ.get('TEAMS_WEBHOOK_URL', '') | [
"os.environ.get",
"re.compile"
] | [((103, 156), 're.compile', 're.compile', (['"""^.*weights\\\\.(\\\\d+)\\\\-\\\\d+\\\\.\\\\d+\\\\.h5$"""'], {}), "('^.*weights\\\\.(\\\\d+)\\\\-\\\\d+\\\\.\\\\d+\\\\.h5$')\n", (113, 156), False, 'import re\n'), ((206, 245), 'os.environ.get', 'os.environ.get', (['"""TEAMS_WEBHOOK_URL"""', '""""""'], {}), "('TEAMS_WEBHOO... |
# -*- test-case-name: vumi.blinkenlights.tests.test_metrics_workers -*-
import time
import random
import hashlib
from datetime import datetime
from twisted.python import log
from twisted.internet.defer import inlineCallbacks, Deferred
from twisted.internet import reactor
from twisted.internet.task import LoopingCall
... | [
"datetime.datetime.utcfromtimestamp",
"random.uniform",
"random.choice",
"random.normalvariate",
"hashlib.md5",
"vumi.blinkenlights.metrics.Count",
"twisted.python.log.msg",
"twisted.internet.task.LoopingCall",
"twisted.python.log.err",
"vumi.blinkenlights.message20110818.MetricMessage.from_dict",... | [((1273, 1318), 'vumi.blinkenlights.message20110818.MetricMessage.from_dict', 'MetricMessage.from_dict', (['vumi_message.payload'], {}), '(vumi_message.payload)\n', (1296, 1318), False, 'from vumi.blinkenlights.message20110818 import MetricMessage\n'), ((1811, 1826), 'vumi.blinkenlights.message20110818.MetricMessage', ... |
from __future__ import absolute_import
from django import forms
from django.db import transaction
from sentry.models import (
OrganizationMember,
OrganizationMemberTeam,
Team,
)
class BaseOrganizationMemberForm(forms.ModelForm):
"""
Base form used by AddOrganizationMemberForm, InviteOrganization... | [
"sentry.models.OrganizationMemberTeam",
"sentry.models.OrganizationMemberTeam.objects.filter",
"django.forms.ChoiceField",
"sentry.models.Team.objects.none",
"django.forms.CheckboxSelectMultiple"
] | [((545, 564), 'django.forms.ChoiceField', 'forms.ChoiceField', ([], {}), '()\n', (562, 564), False, 'from django import forms\n'), ((436, 455), 'sentry.models.Team.objects.none', 'Team.objects.none', ([], {}), '()\n', (453, 455), False, 'from sentry.models import OrganizationMember, OrganizationMemberTeam, Team\n'), ((... |
from datetime import datetime
from typing import List, Optional
import bcrypt
from sqlalchemy.orm import Session
from . import models, schemas
def get_user(db: Session, id: int) -> models.User:
"""Return a single user by id.
Args:
db (Session): database connection
id (int): id of the user
... | [
"bcrypt.gensalt",
"datetime.datetime.utcnow"
] | [((1617, 1633), 'bcrypt.gensalt', 'bcrypt.gensalt', ([], {}), '()\n', (1631, 1633), False, 'import bcrypt\n'), ((2633, 2650), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (2648, 2650), False, 'from datetime import datetime\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
#
# Copyright © 2020 <<EMAIL>>
#
# Distributed under terms of the BSD 3-Clause license.
import hashlib
import itertools
import json
from decimal import Decimal
from multiprocessing import (
cpu_count,
Pool,
Process,
Queue
)
class DecimalJsonEncoder(... | [
"hashlib.sha256",
"multiprocessing.Process",
"json.dumps",
"multiprocessing.cpu_count",
"itertools.count",
"multiprocessing.Pool",
"multiprocessing.Queue"
] | [((508, 558), 'json.dumps', 'json.dumps', (['data'], {'cls': 'DecimalJsonEncoder'}), '(data, cls=DecimalJsonEncoder, **kwargs)\n', (518, 558), False, 'import json\n'), ((634, 641), 'multiprocessing.Queue', 'Queue', ([], {}), '()\n', (639, 641), False, 'from multiprocessing import cpu_count, Pool, Process, Queue\n'), ((... |
#
# Copyright 2018-2021 Elyra Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writ... | [
"yaml.safe_load",
"elyra.pipeline.component.ComponentParameter"
] | [((4687, 4885), 'elyra.pipeline.component.ComponentParameter', 'ComponentParameter', ([], {'id': '"""runtime_image"""', 'name': '"""Runtime Image"""', 'data_type': '"""string"""', 'value': '""""""', 'description': '"""Docker image used as execution environment."""', 'control': '"""readonly"""', 'required': '(True)'}), ... |
from __future__ import unicode_literals
from django.utils.translation import ugettext_lazy as _
from common import MayanAppConfig
from .licenses import * # NOQA
class MIMETypesApp(MayanAppConfig):
name = 'mimetype'
verbose_name = _('MIME types')
def ready(self, *args, **kwargs):
super(MIMETyp... | [
"django.utils.translation.ugettext_lazy"
] | [((244, 259), 'django.utils.translation.ugettext_lazy', '_', (['"""MIME types"""'], {}), "('MIME types')\n", (245, 259), True, 'from django.utils.translation import ugettext_lazy as _\n')] |
from packages.levels.Level import Level
import packages.levels.levels as Levels
import packages.resources.functions as function
import packages.resources.variables as var
from packages.filesystem.Directory import Directory
from packages.filesystem.File import File
var.bash_history = ("Check")
test = Level("Instruct",... | [
"packages.levels.Level.Level"
] | [((303, 337), 'packages.levels.Level.Level', 'Level', (['"""Instruct"""', '"""Help"""', '"""Check"""'], {}), "('Instruct', 'Help', 'Check')\n", (308, 337), False, 'from packages.levels.Level import Level\n')] |
# noinspection PyUnresolvedReferences
import unittest
from cython_vst_loader.vst_loader_wrapper import allocate_float_buffer, get_float_buffer_as_list, \
free_buffer, \
allocate_double_buffer, get_double_buffer_as_list
class TestBuffers(unittest.TestCase):
def test_float_buffer(self):
pointer = ... | [
"cython_vst_loader.vst_loader_wrapper.free_buffer",
"cython_vst_loader.vst_loader_wrapper.get_double_buffer_as_list",
"cython_vst_loader.vst_loader_wrapper.allocate_float_buffer",
"cython_vst_loader.vst_loader_wrapper.get_float_buffer_as_list",
"cython_vst_loader.vst_loader_wrapper.allocate_double_buffer"
] | [((320, 353), 'cython_vst_loader.vst_loader_wrapper.allocate_float_buffer', 'allocate_float_buffer', (['(10)', '(12.345)'], {}), '(10, 12.345)\n', (341, 353), False, 'from cython_vst_loader.vst_loader_wrapper import allocate_float_buffer, get_float_buffer_as_list, free_buffer, allocate_double_buffer, get_double_buffer_... |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import uuid
import requests
class MicrosoftTranslator:
def __init__(self, subscription_key: str, subscription_region: str):
self.subscription_key = subscription_key
self.subscription_region = subscriptio... | [
"requests.post",
"uuid.uuid4"
] | [((1305, 1363), 'requests.post', 'requests.post', (['constructed_url'], {'headers': 'headers', 'json': 'body'}), '(constructed_url, headers=headers, json=body)\n', (1318, 1363), False, 'import requests\n'), ((1169, 1181), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (1179, 1181), False, 'import uuid\n')] |
# 经典面向对象的GUI写法
from tkinter import *
from tkinter import messagebox
class Application(Frame):
"""一个经典的GUI程序"""
def __init__(self,master=None):
super().__init__(master)
self.master = master
self.pack()
self.createWidget()
def createWidget(self):
"""创建组件"""
... | [
"tkinter.messagebox.showinfo"
] | [((1318, 1356), 'tkinter.messagebox.showinfo', 'messagebox.showinfo', (['"""登录界面"""', '"""您已登录，欢迎"""'], {}), "('登录界面', '您已登录，欢迎')\n", (1337, 1356), False, 'from tkinter import messagebox\n'), ((1383, 1418), 'tkinter.messagebox.showinfo', 'messagebox.showinfo', (['"""登录界面"""', '"""密码错误"""'], {}), "('登录界面', '密码错误')\n", (... |
# Grupo da Maioridade
'''Crie um programa que leia o ANO DE NASCIMENTO de
SETE PESSOAS. No final, mostre quantas pessoas ainda
não atingiram a maioridade e quantas já são maiores'''
from datetime import date
anoatual = date.today().year # Pegará o ano atual configurado na máquina
totalmaior = 0
totalmenor = 0
for pess... | [
"datetime.date.today"
] | [((220, 232), 'datetime.date.today', 'date.today', ([], {}), '()\n', (230, 232), False, 'from datetime import date\n')] |
from typing import Tuple
import numpy as np
import png
from skimage.transform import resize
def load_world(filename: str, size: Tuple[int, int], resolution: int) -> np.array:
"""Load a preconstructred track to initialize world.
Args:
filename: Full path to the track file (png).
... | [
"numpy.multiply",
"skimage.transform.resize",
"png.Reader"
] | [((778, 807), 'numpy.multiply', 'np.multiply', (['size', 'resolution'], {}), '(size, resolution)\n', (789, 807), True, 'import numpy as np\n'), ((1122, 1170), 'skimage.transform.resize', 'resize', (['world', '(width_in_cells, height_in_cells)'], {}), '(world, (width_in_cells, height_in_cells))\n', (1128, 1170), False, ... |
#! /usr/bin/env python
# Version: 0.1.1
import re
def convert_ws_header_vb_attributes(df):
output_txt = ""
for key in df.keys():
variant_array = "\'Dim "
i = 0
for word in [w.capitalize().replace('\t', '') for w in str(key).lower().split("(")[0].split(" ")]:
if i == 0:
... | [
"re.split"
] | [((660, 687), 're.split', 're.split', (['"""[^a-zA-Z]"""', 'text'], {}), "('[^a-zA-Z]', text)\n", (668, 687), False, 'import re\n')] |
import numpy as np
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import IncrementalPCA as _IncrementalPCA
from ..count_matrix.zarr import dataset_to_array
def _normalize_per_cell(matrix, cell_sum):
print('normalize per cell to CPM')
if cell_sum is None:
... | [
"pandas.Index",
"sklearn.preprocessing.StandardScaler",
"pandas.DataFrame",
"sklearn.decomposition.IncrementalPCA",
"numpy.log1p",
"pandas.concat",
"numpy.random.shuffle"
] | [((702, 754), 'sklearn.decomposition.IncrementalPCA', '_IncrementalPCA', ([], {'n_components': 'n_components'}), '(n_components=n_components, **kwargs)\n', (717, 754), True, 'from sklearn.decomposition import IncrementalPCA as _IncrementalPCA\n'), ((6155, 6175), 'pandas.concat', 'pd.concat', (['total_pcs'], {}), '(tota... |
# Predict time series w/o using OutputProjectWrapper
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
# Create time series
t_min, t_max = 0, 30
resolution = 0.1
def time_series(t):
return t * np.sin(t) / 3 + 2 * np.sin(t * 5)
def next_batch(batch_size, n_steps):
t0 = np.random.rand... | [
"numpy.random.rand",
"matplotlib.pyplot.ylabel",
"numpy.array",
"numpy.sin",
"numpy.arange",
"tensorflow.placeholder",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"tensorflow.Session",
"tensorflow.nn.dynamic_rnn",
"numpy.linspace",
"tensorflow.square",
"tensorflow.train.AdamOptimiz... | [((540, 596), 'numpy.linspace', 'np.linspace', (['t_min', 't_max', '((t_max - t_min) // resolution)'], {}), '(t_min, t_max, (t_max - t_min) // resolution)\n', (551, 596), True, 'import numpy as np\n'), ((624, 689), 'numpy.linspace', 'np.linspace', (['(12.2)', '(12.2 + resolution * (n_steps + 1))', '(n_steps + 1)'], {})... |
import os
from argparse import ArgumentParser
from glob import glob
import cv2
import numpy as np
import torch
import torchvision
import matplotlib as mpl
import matplotlib.pyplot as plt
from PIL import Image
from fiery.trainer import TrainingModule
from fiery.utils.network import NormalizeInverse
from fiery.utils.in... | [
"fiery.trainer.TrainingModule.load_from_checkpoint",
"fiery.utils.network.NormalizeInverse",
"fiery.utils.instance.predict_instance_segmentation_and_trajectories",
"torchvision.transforms.ToPILImage",
"fiery.utils.visualisation.make_contour",
"torch.from_numpy",
"matplotlib.pyplot.imshow",
"fiery.util... | [((652, 740), 'fiery.utils.instance.predict_instance_segmentation_and_trajectories', 'predict_instance_segmentation_and_trajectories', (['output'], {'compute_matched_centers': '(True)'}), '(output,\n compute_matched_centers=True)\n', (698, 740), False, 'from fiery.utils.instance import predict_instance_segmentation_... |
import asyncio
import discord
from discord.ext import commands, tasks
import os
import random
import dotenv
import difflib
import configparser
###
version = '4.0.0'
###
bot = commands.Bot(command_prefix = '!', owner_id = 272446903940153345, intents = discord.Intents.all())
bot.remove_command('help')
co... | [
"os.listdir",
"random.choice",
"configparser.ConfigParser",
"discord.Intents.all",
"discord.ext.commands.is_owner",
"dotenv.load_dotenv",
"asyncio.sleep",
"discord.ext.tasks.loop"
] | [((327, 354), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (352, 354), False, 'import configparser\n'), ((387, 407), 'dotenv.load_dotenv', 'dotenv.load_dotenv', ([], {}), '()\n', (405, 407), False, 'import dotenv\n'), ((425, 445), 'os.listdir', 'os.listdir', (['"""./cogs"""'], {}), "('./c... |
import tensorflow as tf
import numpy as np
def euclidean_dist(x, y):
return np.linalg.norm(x - y)
def limit_gpu():
gpus = tf.config.list_physical_devices('GPU')
if gpus:
try:
tf.config.set_logical_device_configuration(
gpus[0],
[tf.config.Logic... | [
"tensorflow.config.list_logical_devices",
"tensorflow.config.list_physical_devices",
"tensorflow.config.LogicalDeviceConfiguration",
"numpy.linalg.norm"
] | [((82, 103), 'numpy.linalg.norm', 'np.linalg.norm', (['(x - y)'], {}), '(x - y)\n', (96, 103), True, 'import numpy as np\n'), ((134, 172), 'tensorflow.config.list_physical_devices', 'tf.config.list_physical_devices', (['"""GPU"""'], {}), "('GPU')\n", (165, 172), True, 'import tensorflow as tf\n'), ((390, 427), 'tensorf... |
from base import BaseDataSet, BaseDataLoader
from utils import pallete
import numpy as np
import os
import scipy
import torch
from PIL import Image
import cv2
from torch.utils.data import Dataset
from torchvision import transforms
import json
class VOCDataset(BaseDataSet):
def __init__(self, **kwargs):
sel... | [
"PIL.Image.open",
"os.path.join",
"utils.pallete.get_voc_pallete"
] | [((363, 404), 'utils.pallete.get_voc_pallete', 'pallete.get_voc_pallete', (['self.num_classes'], {}), '(self.num_classes)\n', (386, 404), False, 'from utils import pallete\n'), ((503, 547), 'os.path.join', 'os.path.join', (['self.root', '"""VOCdevkit/VOC2012"""'], {}), "(self.root, 'VOCdevkit/VOC2012')\n", (515, 547), ... |
# coding: utf-8
from kerasy.Bio.tandem import find_tandem
from kerasy.utils import generateSeq
len_sequences = 1000
def get_test_data():
sequence = generateSeq(size=len_sequences,
nucleic_acid='DNA',
weights=None,
seed=123)
seque... | [
"kerasy.Bio.tandem.find_tandem",
"kerasy.utils.generateSeq"
] | [((154, 229), 'kerasy.utils.generateSeq', 'generateSeq', ([], {'size': 'len_sequences', 'nucleic_acid': '"""DNA"""', 'weights': 'None', 'seed': '(123)'}), "(size=len_sequences, nucleic_acid='DNA', weights=None, seed=123)\n", (165, 229), False, 'from kerasy.utils import generateSeq\n'), ((459, 495), 'kerasy.Bio.tandem.f... |
from PIL import Image, ImageDraw
from numpy import array, random, vstack, ones, linalg
from const import TOWERS
from copy import deepcopy
from os import path
class MapDrawer:
"""
a class for drawing Dota2Maps with replay-parsed data
"""
def __init__(self, towers, received_tables):
... | [
"PIL.Image.open",
"os.path.dirname",
"PIL.ImageDraw.Draw",
"numpy.linalg.lstsq",
"copy.deepcopy"
] | [((585, 628), 'PIL.Image.open', 'Image.open', (["(libdir + '/assets/dota2map.png')"], {}), "(libdir + '/assets/dota2map.png')\n", (595, 628), False, 'from PIL import Image, ImageDraw\n'), ((650, 676), 'PIL.ImageDraw.Draw', 'ImageDraw.Draw', (['self.image'], {}), '(self.image)\n', (664, 676), False, 'from PIL import Ima... |
def get_tokenizer(tokenizer):
if callable(tokenizer):
return tokenizer
if tokenizer == "spacy":
try:
import spacy
spacy_en = spacy.load('en')
return lambda s: [tok.text for tok in spacy_en.tokenizer(s)]
except ImportError:
print("Please in... | [
"spacy.load",
"revtok.tokenize",
"nltk.tokenize.moses.MosesTokenizer"
] | [((174, 190), 'spacy.load', 'spacy.load', (['"""en"""'], {}), "('en')\n", (184, 190), False, 'import spacy\n'), ((794, 810), 'nltk.tokenize.moses.MosesTokenizer', 'MosesTokenizer', ([], {}), '()\n', (808, 810), False, 'from nltk.tokenize.moses import MosesTokenizer\n'), ((1500, 1530), 'revtok.tokenize', 'revtok.tokeniz... |
from servee import frontendadmin
from servee.frontendadmin.insert import ModelInsert
from oldcontrib.media.image.models import Image
class ImageInsert(ModelInsert):
model = Image
frontendadmin.site.register_insert(ImageInsert) | [
"servee.frontendadmin.site.register_insert"
] | [((185, 232), 'servee.frontendadmin.site.register_insert', 'frontendadmin.site.register_insert', (['ImageInsert'], {}), '(ImageInsert)\n', (219, 232), False, 'from servee import frontendadmin\n')] |
import torch
import numpy as np
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
def binary_reg(x: torch.Tensor):
# forward: f(x) = (x>=0)
# backward: f(x) = sigmoid
a = torch.sigmoid(x)
b = a.detach()
c = (x.detach() >= 0).float()
return a - b + c
class HIN2vec(nn.Module... | [
"torch.mul",
"numpy.tile",
"torch.LongTensor",
"torch.sigmoid",
"torch.tensor",
"numpy.zeros",
"numpy.random.randint",
"torch.sum",
"torch.FloatTensor",
"torch.nn.Embedding"
] | [((205, 221), 'torch.sigmoid', 'torch.sigmoid', (['x'], {}), '(x)\n', (218, 221), False, 'import torch\n'), ((3209, 3259), 'torch.tensor', 'torch.tensor', (['[-1.0, 0.0, 1.0]'], {'requires_grad': '(True)'}), '([-1.0, 0.0, 1.0], requires_grad=True)\n', (3221, 3259), False, 'import torch\n'), ((3262, 3278), 'torch.sigmoi... |
#! /usr/bin/python3
from default_settings import default_settings
from ultron_cli import UltronCLI
if __name__ == '__main__':
default_settings()
try:
UltronCLI().cmdloop()
except KeyboardInterrupt:
print("\nInterrupted by user.")
print("Goodbye")
exit(0)
| [
"default_settings.default_settings",
"ultron_cli.UltronCLI"
] | [((132, 150), 'default_settings.default_settings', 'default_settings', ([], {}), '()\n', (148, 150), False, 'from default_settings import default_settings\n'), ((168, 179), 'ultron_cli.UltronCLI', 'UltronCLI', ([], {}), '()\n', (177, 179), False, 'from ultron_cli import UltronCLI\n')] |
import torch
import torch.nn as nn
import torch.nn.functional as F
def soft_dice_score(
output: torch.Tensor, target: torch.Tensor, smooth: float = 0.0, eps: float = 1e-7, dims=None) -> torch.Tensor:
assert output.size() == target.size()
if dims is not None:
intersection = torch.sum(output * t... | [
"torch.nn.functional.logsigmoid",
"torch.sum",
"torch.nn.functional.one_hot"
] | [((300, 336), 'torch.sum', 'torch.sum', (['(output * target)'], {'dim': 'dims'}), '(output * target, dim=dims)\n', (309, 336), False, 'import torch\n'), ((359, 395), 'torch.sum', 'torch.sum', (['(output + target)'], {'dim': 'dims'}), '(output + target, dim=dims)\n', (368, 395), False, 'import torch\n'), ((503, 529), 't... |
import inspect
import re
from functools import update_wrapper
from typing import Optional
def is_interactive() -> bool:
try:
_ = get_ipython().__class__.__name__ # type: ignore
return True
except NameError:
return False
def get_attr_docstring(class_type, attr_name) -> Optional[str]:... | [
"re.sub",
"inspect.signature"
] | [((473, 506), 're.sub', 're.sub', (['""" {3,}"""', '""""""', 'attr.__doc__'], {}), "(' {3,}', '', attr.__doc__)\n", (479, 506), False, 'import re\n'), ((1717, 1752), 're.sub', 're.sub', (['""" {3,}"""', '""""""', 'method.__doc__'], {}), "(' {3,}', '', method.__doc__)\n", (1723, 1752), False, 'import re\n'), ((899, 922)... |
import torch
def train_one_epoch(model, train_loader, loss_func, optimizer):
model.train()
running_loss = 0.0
for batch_idx, (x, y) in enumerate(train_loader):
out = model(x)
optimizer.zero_grad()
loss = loss_func(out, y)
loss.backward()
optimizer.step()
run... | [
"torch.no_grad",
"torch.save"
] | [((513, 528), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (526, 528), False, 'import torch\n'), ((2365, 2414), 'torch.save', 'torch.save', (['model', "(model_name + '_full_model.pth')"], {}), "(model, model_name + '_full_model.pth')\n", (2375, 2414), False, 'import torch\n')] |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
import json
import uuid
from typing import Callable, Mapping, Optional
import numpy as np
from caffe2.python import workspace
from caffe2.python.predictor import predictor_exporter
from .builtin_task import register_builtin_... | [
"caffe2.python.workspace.RunNet",
"caffe2.python.workspace.SwitchWorkspace",
"caffe2.python.predictor.predictor_exporter.prepare_prediction_net",
"uuid.uuid4",
"numpy.array"
] | [((721, 760), 'caffe2.python.workspace.SwitchWorkspace', 'workspace.SwitchWorkspace', (['workspace_id'], {}), '(workspace_id)\n', (746, 760), False, 'from caffe2.python import workspace\n'), ((2019, 2048), 'caffe2.python.workspace.RunNet', 'workspace.RunNet', (['predict_net'], {}), '(predict_net)\n', (2035, 2048), Fals... |
#!/usr/bin/env python
import os
import cv2 as cv
import numpy as np
from tests_common import NewOpenCVTests, unittest
class cudaobjdetect_test(NewOpenCVTests):
def setUp(self):
super(cudaobjdetect_test, self).setUp()
if not cv.cuda.getCudaEnabledDeviceCount():
self.skipTest("No CUDA-ca... | [
"cv2.cuda_GpuMat",
"tests_common.unittest.skipIf",
"cv2.cuda.HOG_create",
"tests_common.NewOpenCVTests.bootstrap",
"cv2.cuda.getCudaEnabledDeviceCount",
"cv2.imread"
] | [((353, 455), 'tests_common.unittest.skipIf', 'unittest.skipIf', (["('OPENCV_TEST_DATA_PATH' not in os.environ)", '"""OPENCV_TEST_DATA_PATH is not defined"""'], {}), "('OPENCV_TEST_DATA_PATH' not in os.environ,\n 'OPENCV_TEST_DATA_PATH is not defined')\n", (368, 455), False, 'from tests_common import NewOpenCVTests,... |
import logging
import inspect
import re
from collections import OrderedDict
from gremlinpy.gremlin import Gremlin, Param, AS
from .entity import (_Entity, Vertex, Edge, GenericVertex, GenericEdge,
ENTITY_MAP)
from .exception import (AstronomerQueryException, AstronomerMapperException)
from .traversal import Trav... | [
"logging.getLogger",
"gremlinpy.gremlin.Param",
"collections.OrderedDict",
"random.randrange",
"inspect.isclass",
"gremlinpy.gremlin.Gremlin",
"re.sub"
] | [((459, 486), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (476, 486), False, 'import logging\n'), ((1057, 1082), 're.sub', 're.sub', (['"""\\\\W"""', '"""_"""', 'param'], {}), "('\\\\W', '_', param)\n", (1063, 1082), False, 'import re\n'), ((2440, 2453), 'collections.OrderedDict', 'Ord... |
import sys
class MenuHandler(object):
def __init__(self, client, client_channel, remote_checker):
self._client = client
self._client_channel = client_channel
self._buffer = ''
self._remote_checker = remote_checker
@staticmethod
def create_from_channel(client, client_channe... | [
"sys.exit"
] | [((1873, 1884), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (1881, 1884), False, 'import sys\n'), ((2522, 2533), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (2530, 2533), False, 'import sys\n')] |
#!/usr/bin/env python3
# Calls Google Translate to produce translations.
# To use, set "language" and "dest_language" below. (They are normally the same,
# unless Google uses a different language code than we do.) Then fill in
# the definition_[language] fields with "TRANSLATE" or
# "TRANSLATE: [replacement definition... | [
"googletrans.Translator",
"time.sleep",
"fileinput.FileInput",
"re.sub",
"re.search"
] | [((1217, 1229), 'googletrans.Translator', 'Translator', ([], {}), '()\n', (1227, 1229), False, 'from googletrans import Translator\n'), ((1319, 1362), 'fileinput.FileInput', 'fileinput.FileInput', (['filename'], {'inplace': '(True)'}), '(filename, inplace=True)\n', (1338, 1362), False, 'import fileinput\n'), ((1439, 14... |
"""
Base classes and utilities for all Xena Manager (Xena) objects.
:author: <EMAIL>
"""
import time
import re
import logging
from collections import OrderedDict
from trafficgenerator.tgn_utils import TgnError
from trafficgenerator.tgn_object import TgnObject, TgnObjectsDict
logger = logging.getLogger(__name__)
c... | [
"logging.getLogger",
"collections.OrderedDict.__getitem__",
"trafficgenerator.tgn_object.TgnObjectsDict.__getitem__",
"time.sleep"
] | [((289, 316), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (306, 316), False, 'import logging\n'), ((534, 571), 'trafficgenerator.tgn_object.TgnObjectsDict.__getitem__', 'TgnObjectsDict.__getitem__', (['self', 'key'], {}), '(self, key)\n', (560, 571), False, 'from trafficgenerator.tgn_o... |
# -*- coding: utf-8 -*-
import unittest
import os # noqa: F401
import json # noqa: F401
import time
import shutil
import re
import sys
import datetime
import collections
#import simplejson
from os import environ
try:
from ConfigParser import ConfigParser # py2
except:
from configparser import ConfigParser ... | [
"os.listdir",
"configparser.ConfigParser",
"GenomeFileUtil.GenomeFileUtilImpl.SDKConfig",
"os.environ.get",
"installed_clients.WorkspaceClient.Workspace",
"os.path.join",
"os.path.isfile",
"GenomeFileUtil.GenomeFileUtilServer.MethodContext",
"os.path.isdir",
"collections.defaultdict",
"time.time... | [((962, 996), 'os.environ.get', 'environ.get', (['"""KB_AUTH_TOKEN"""', 'None'], {}), "('KB_AUTH_TOKEN', None)\n", (973, 996), False, 'from os import environ\n'), ((1015, 1034), 'GenomeFileUtil.GenomeFileUtilServer.MethodContext', 'MethodContext', (['None'], {}), '(None)\n', (1028, 1034), False, 'from GenomeFileUtil.Ge... |
#! /usr/bin/env python3
import sys
import random
import os
from faker import Factory as FFactory
OUTFILE = "samples.xmi"
NUM_SAMPLES = 10
NUM_COUNTRIES = 4
TEMPLATE = """<?xml version="1.0" encoding="ASCII"?>
<person:Root
xmi:version="2.0"
xmlns:xmi="http://www.omg.org/XMI"
xmlns:xsi="http://www.w3.org/... | [
"os.linesep.join",
"faker.Factory.create",
"sys.argv.index",
"random.randint",
"sys.argv.pop"
] | [((952, 969), 'faker.Factory.create', 'FFactory.create', ([], {}), '()\n', (967, 969), True, 'from faker import Factory as FFactory\n'), ((1935, 1955), 'sys.argv.index', 'sys.argv.index', (['"""-n"""'], {}), "('-n')\n", (1949, 1955), False, 'import sys\n'), ((2020, 2048), 'sys.argv.pop', 'sys.argv.pop', (['position_par... |
from unittest import TestCase
from unittest.mock import Mock, patch
from typeseam.app import (
load_initial_data,
)
class TestModels(TestCase):
@patch('typeseam.app.os.environ.get')
def test_load_initial_data(self, env_get):
ctx = Mock(return_value=Mock(
__exit__=Mock(),
... | [
"typeseam.app.load_initial_data",
"unittest.mock.patch",
"unittest.mock.Mock"
] | [((161, 197), 'unittest.mock.patch', 'patch', (['"""typeseam.app.os.environ.get"""'], {}), "('typeseam.app.os.environ.get')\n", (166, 197), False, 'from unittest.mock import Mock, patch\n'), ((357, 378), 'unittest.mock.Mock', 'Mock', ([], {'app_context': 'ctx'}), '(app_context=ctx)\n', (361, 378), False, 'from unittest... |
import sys
sys.path.append('../')
from abc import ABCMeta, abstractmethod
# https://www.python-course.eu/python3_abstract_classes.php
import logging
import oandapyV20
from oandapyV20 import API
import oandapyV20.endpoints.orders as orders
from oandapyV20.contrib.requests import MarketOrderRequest
class... | [
"logging.getLogger",
"oandapyV20.endpoints.orders.OrderCreate",
"oandapyV20.contrib.requests.MarketOrderRequest",
"sys.path.append",
"oandapyV20.API"
] | [((12, 34), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (27, 34), False, 'import sys\n'), ((1387, 1414), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1404, 1414), False, 'import logging\n'), ((1487, 1509), 'oandapyV20.API', 'API', (['self.access_token'], {})... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# __BEGIN_LICENSE__
# Copyright (c) 2009-2013, United States Government as represented by the
# Administrator of the National Aeronautics and Space Administration. All
# rights reserved.
#
# The NGT platform is licensed under the Apache License, Version 2.0 (the
# "Lic... | [
"os.path.exists",
"re.match",
"os.path.basename",
"sys.exit"
] | [((1179, 1190), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1187, 1190), False, 'import sys, os, re\n'), ((1285, 1308), 'os.path.exists', 'os.path.exists', (['outFile'], {}), '(outFile)\n', (1299, 1308), False, 'import sys, os, re\n'), ((1356, 1367), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1364, 1367), Fa... |
import cv2
import ProcessWithCV2
img1 = cv2.imread("D:/py/chinese/7.png")
img2 = cv2.imread("D:/py/chinese/8.png")
a = ProcessWithCV2.dHash(img1, img2, 1)
print(a)
| [
"ProcessWithCV2.dHash",
"cv2.imread"
] | [((44, 77), 'cv2.imread', 'cv2.imread', (['"""D:/py/chinese/7.png"""'], {}), "('D:/py/chinese/7.png')\n", (54, 77), False, 'import cv2\n'), ((86, 119), 'cv2.imread', 'cv2.imread', (['"""D:/py/chinese/8.png"""'], {}), "('D:/py/chinese/8.png')\n", (96, 119), False, 'import cv2\n'), ((125, 160), 'ProcessWithCV2.dHash', 'P... |