code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from database.db0 import db0, ConstDB
from database.db3 import db3, ConstDB3
from utils.errors import KeyDuplicateError, ReadOnlyDeny
from utils.utils import eui_64_to_48, eui_48_to_64
from binascii import hexlify
from enum import Enum
import enum
from userver.frequency_plan import FrequencyPlan
from userver.object.as... | [
"utils.utils.eui_64_to_48",
"database.db0.db0.hgetall",
"database.db_sql.db_sql.session.delete",
"database.db0.db0.exists",
"binascii.hexlify",
"utils.errors.KeyDuplicateError",
"database.db0.db0.keys",
"database.db0.db0.pipeline",
"sqlalchemy.ForeignKey",
"sqlalchemy.BINARY",
"eviltransform.wgs... | [((2130, 2171), 'eviltransform.wgs2gcj', 'eviltransform.wgs2gcj', (['self.lat', 'self.lng'], {}), '(self.lat, self.lng)\n', (2151, 2171), False, 'import eviltransform\n'), ((3764, 3773), 'sqlalchemy.BINARY', 'BINARY', (['(8)'], {}), '(8)\n', (3770, 3773), False, 'from sqlalchemy import Column, String, BINARY\n'), ((381... |
import logging
import pytz
from urllib.parse import urlencode, urljoin, urlparse, parse_qs
import requests
from django.conf import settings
from ol_openedx_canvas_integration.constants import DEFAULT_ASSIGNMENT_POINTS
log = logging.getLogger(__name__)
class CanvasClient:
def __init__(self, canvas_course_id):
... | [
"urllib.parse.urlencode",
"requests.Session",
"requests.utils.parse_header_links",
"logging.getLogger",
"urllib.parse.parse_qs",
"urllib.parse.urlparse"
] | [((228, 255), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (245, 255), False, 'import logging\n'), ((564, 582), 'requests.Session', 'requests.Session', ([], {}), '()\n', (580, 582), False, 'import requests\n'), ((1064, 1077), 'urllib.parse.urlparse', 'urlparse', (['url'], {}), '(url)\n'... |
import builtins
import collections
import contextlib
import glob
import io
import os
import string
from typing import Dict, Any, Tuple, List, Collection, Optional
import attrs
import pandas as pd
from databutler.pat import astlib
from databutler.pat.analysis.type_analysis.mypy_types import SerializedMypyType
DF_TYPE... | [
"databutler.pat.astlib.with_deep_replacements",
"io.StringIO",
"os.path.dirname",
"databutler.pat.astlib.walk",
"collections.defaultdict",
"databutler.pat.astlib.iter_body_stmts",
"databutler.pat.astlib.is_constant",
"databutler.pat.astlib.get_constant_value",
"databutler.pat.astlib.parse_expr",
"... | [((887, 921), 'attrs.define', 'attrs.define', ([], {'eq': '(False)', 'repr': '(False)'}), '(eq=False, repr=False)\n', (899, 921), False, 'import attrs\n'), ((1248, 1273), 'attrs.field', 'attrs.field', ([], {'factory': 'dict'}), '(factory=dict)\n', (1259, 1273), False, 'import attrs\n'), ((2735, 2780), 'databutler.pat.a... |
## @package bot
# Module that sets up the Geometrize Twitter bot.
#
# Invoke this script to run the bot i.e. "python bot.py".
import sys
import config
import dependency_locator
import geometrize
import geometrize_bot
import launch_text
import on_status_event
import tweepy
# Print welcome text.
launch_text.print_la... | [
"geometrize.test_geometrize",
"tweepy.API",
"config.validate_credentials",
"on_status_event.on_on_demand_status_event",
"dependency_locator.get_geometrize_executable_path",
"launch_text.print_launch_text",
"sys.exit",
"on_status_event.on_account_watcher_status_event",
"dependency_locator.geometrize_... | [((300, 331), 'launch_text.print_launch_text', 'launch_text.print_launch_text', ([], {}), '()\n', (329, 331), False, 'import launch_text\n'), ((1034, 1062), 'geometrize.test_geometrize', 'geometrize.test_geometrize', ([], {}), '()\n', (1060, 1062), False, 'import geometrize\n'), ((1306, 1382), 'tweepy.OAuthHandler', 't... |
from django.views.generic.base import View
from django.template.response import HttpResponse
from share.oaipmh.repository import OAIRepository
class OAIPMHView(View):
CONTENT_TYPE = 'text/xml'
def get(self, request):
return self.oai_response(**request.GET)
def post(self, request):
retur... | [
"share.oaipmh.repository.OAIRepository",
"django.template.response.HttpResponse"
] | [((416, 431), 'share.oaipmh.repository.OAIRepository', 'OAIRepository', ([], {}), '()\n', (429, 431), False, 'from share.oaipmh.repository import OAIRepository\n'), ((509, 558), 'django.template.response.HttpResponse', 'HttpResponse', (['xml'], {'content_type': 'self.CONTENT_TYPE'}), '(xml, content_type=self.CONTENT_TY... |
import pandas as pd
import psycopg2
#from sqlalchemy import create_engine
psql_credeintal = {
'database': 'wode',
'user': 'wode',
'password': '***',
'host': '192.168.3.11',
'port': '5432'
}
con = psycopg2.connect(**psql_credeintal)
def get_winrate(user_id):
query = "SEL... | [
"pandas.read_sql_query",
"psycopg2.connect"
] | [((241, 276), 'psycopg2.connect', 'psycopg2.connect', ([], {}), '(**psql_credeintal)\n', (257, 276), False, 'import psycopg2\n'), ((425, 454), 'pandas.read_sql_query', 'pd.read_sql_query', (['query', 'con'], {}), '(query, con)\n', (442, 454), True, 'import pandas as pd\n')] |
from django.core.files.base import ContentFile
import base64
import uuid
def get_report_image(data):
_, image_binary = data.split(';base64')
decoded_image = base64.b64decode(image_binary)
img_name = str(uuid.uuid4())[:10] + '.png'
data = ContentFile(decoded_image, name=img_name)
return data
| [
"uuid.uuid4",
"base64.b64decode",
"django.core.files.base.ContentFile"
] | [((168, 198), 'base64.b64decode', 'base64.b64decode', (['image_binary'], {}), '(image_binary)\n', (184, 198), False, 'import base64\n'), ((257, 298), 'django.core.files.base.ContentFile', 'ContentFile', (['decoded_image'], {'name': 'img_name'}), '(decoded_image, name=img_name)\n', (268, 298), False, 'from django.core.f... |
#!/usr/bin/python
#
##########################################################################
#
# Social-Engineer Toolkit Persistence Service
#
# Right now this is a pretty lame attempt at a service but will grow over time. The text file it reads in from isn't
# really a good idea, but it... | [
"win32serviceutil.HandleCommandLine",
"subprocess.Popen",
"os.path.abspath",
"sys.getwindowsversion",
"servicemanager.StartServiceCtrlDispatcher",
"win32event.SetEvent",
"time.sleep",
"win32event.WaitForSingleObject",
"servicemanager.PrepareToHostSingle",
"win32event.CreateEvent",
"servicemanage... | [((1068, 1122), 'win32serviceutil.ServiceFramework.__init__', 'win32serviceutil.ServiceFramework.__init__', (['self', 'args'], {}), '(self, args)\n', (1110, 1122), False, 'import win32serviceutil\n'), ((1148, 1188), 'win32event.CreateEvent', 'win32event.CreateEvent', (['None', '(0)', '(0)', 'None'], {}), '(None, 0, 0, ... |
import requests
from model.json_check import *
from model.input_data import *
# Запрос на получение настроек всех объектов CAM
def test_GetV1AllCamerasCode200():
data = "success"
response = requests.get(url="http://"+slave_ip+":"+restPort+"/api/v1/cameras/", auth=auth)
user_resp_code = "200"
assert st... | [
"requests.get"
] | [((200, 291), 'requests.get', 'requests.get', ([], {'url': "('http://' + slave_ip + ':' + restPort + '/api/v1/cameras/')", 'auth': 'auth'}), "(url='http://' + slave_ip + ':' + restPort + '/api/v1/cameras/',\n auth=auth)\n", (212, 291), False, 'import requests\n'), ((528, 623), 'requests.get', 'requests.get', ([], {'... |
import random
from impiccato_disegno import d_impiccato, logo
from parole_impiccato import lista_parole
scelta_parola = random.choice(lista_parole)
print(logo)
game_over = False
energia = len(d_impiccato)-1
campo_gioco = []
for i in scelta_parola:
campo_gioco += '_'
while not game_over:
indovina = input('In... | [
"random.choice"
] | [((121, 148), 'random.choice', 'random.choice', (['lista_parole'], {}), '(lista_parole)\n', (134, 148), False, 'import random\n')] |
import unittest
from pyoxigraph import *
XSD_STRING = NamedNode("http://www.w3.org/2001/XMLSchema#string")
XSD_INTEGER = NamedNode("http://www.w3.org/2001/XMLSchema#integer")
RDF_LANG_STRING = NamedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#langString")
class TestNamedNode(unittest.TestCase):
def test_cons... | [
"unittest.main"
] | [((7347, 7362), 'unittest.main', 'unittest.main', ([], {}), '()\n', (7360, 7362), False, 'import unittest\n')] |
import getpass # importing getpass
dpass = getpass.getpass(prompt = "Enter the password: ") # by default it shows 'password'
print(f"The entered password is {dpass}") | [
"getpass.getpass"
] | [((46, 92), 'getpass.getpass', 'getpass.getpass', ([], {'prompt': '"""Enter the password: """'}), "(prompt='Enter the password: ')\n", (61, 92), False, 'import getpass\n')] |
from django.db import models
import datetime
class Region(models.Model):
name = models.CharField(max_length=200)
class University(models.Model):
address = models.CharField(max_length=255)
affilation_name = models.CharField(max_length=255)
author_count = models.IntegerField(default=0)
city = mode... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"datetime.date",
"django.db.models.FloatField",
"django.db.models.BooleanField",
"django.db.models.IntegerField",
"django.db.models.DateField"
] | [((86, 118), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(200)'}), '(max_length=200)\n', (102, 118), False, 'from django.db import models\n'), ((167, 199), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (183, 199), False, 'from django.db... |
import enum
import datetime
from chat_bots.models import Sender
from slack_bot.bot import SlackBot
from telegram_bot.bot import TelegramBot
class MessengerType(enum.Enum):
Telegram = 'Telegram'
Slack = 'Slack'
class SenderBots:
new_employee_channel_id = None
new_employee_chat_bot = None
access_r... | [
"chat_bots.models.Sender.objects.first",
"datetime.date.today",
"datetime.timedelta",
"slack_bot.bot.SlackBot",
"chat_bots.models.Sender.objects.filter",
"telegram_bot.bot.TelegramBot",
"datetime.datetime.combine",
"datetime.datetime.now"
] | [((2521, 2543), 'chat_bots.models.Sender.objects.first', 'Sender.objects.first', ([], {}), '()\n', (2541, 2543), False, 'from chat_bots.models import Sender\n'), ((438, 460), 'chat_bots.models.Sender.objects.first', 'Sender.objects.first', ([], {}), '()\n', (458, 460), False, 'from chat_bots.models import Sender\n'), (... |
import math
import random
__BASE_SEED = 1
def constant_thresholds(graph, value):
"""Sets a constant threshold for every node of the graph."""
# Store threshold assignment in a dictionary
thresholds = dict()
# Add a constant attribute to each node
for node in graph.Nodes():
thresholds[n... | [
"random.seed",
"math.floor"
] | [((1132, 1163), 'random.seed', 'random.seed', (['(__BASE_SEED + seed)'], {}), '(__BASE_SEED + seed)\n', (1143, 1163), False, 'import random\n'), ((750, 779), 'math.floor', 'math.floor', (['(degree * fraction)'], {}), '(degree * fraction)\n', (760, 779), False, 'import math\n')] |
"""
Minimal character-level Vanilla RNN model. Written b_y <NAME> (@karpathy)
BSD License
"""
import numpy as np
import unicodedata
import string
import codecs
# data I/O
data = codecs.open('data/potter.txt', 'r', encoding='utf8', errors='ignore').read()
fake = codecs.open('data/output.txt', 'w', encoding='utf8')
char... | [
"unicodedata.normalize",
"numpy.zeros_like",
"codecs.open",
"numpy.copy",
"numpy.random.randn",
"numpy.log",
"unicodedata.category",
"numpy.zeros",
"numpy.clip",
"numpy.exp",
"numpy.dot",
"numpy.sqrt"
] | [((263, 315), 'codecs.open', 'codecs.open', (['"""data/output.txt"""', '"""w"""'], {'encoding': '"""utf8"""'}), "('data/output.txt', 'w', encoding='utf8')\n", (274, 315), False, 'import codecs\n'), ((1301, 1327), 'numpy.zeros', 'np.zeros', (['(hidden_size, 1)'], {}), '((hidden_size, 1))\n', (1309, 1327), True, 'import ... |
import sys
input = sys.stdin.readline
import heapq as hq
# input
t = int(input())
for _ in range(t):
chapter = int(input())
pages = list(map(int, input().split()))
# process
'''
각 장이 섞여도 됨.
>> 힙에서 제일 작은 거 두 개 합치고 다시 넣음.
'''
sol = 0
hq.heapify(pages)
for _ in range(chapter - 1):
cost = hq.heappop(pages) + hq.... | [
"heapq.heappush",
"heapq.heapify",
"heapq.heappop"
] | [((240, 257), 'heapq.heapify', 'hq.heapify', (['pages'], {}), '(pages)\n', (250, 257), True, 'import heapq as hq\n'), ((351, 375), 'heapq.heappush', 'hq.heappush', (['pages', 'cost'], {}), '(pages, cost)\n', (362, 375), True, 'import heapq as hq\n'), ((297, 314), 'heapq.heappop', 'hq.heappop', (['pages'], {}), '(pages)... |
"""Optimization result."""
import warnings
from collections import Counter
from copy import deepcopy
from typing import Sequence, Union
import numpy as np
import pandas as pd
from ..objective import History
from ..problem import Problem
from ..util import assign_clusters, delete_nan_inf
OptimizationResult = Union['... | [
"pandas.DataFrame",
"copy.deepcopy",
"numpy.argmax",
"collections.Counter",
"numpy.isnan",
"numpy.argmin",
"numpy.max",
"numpy.mean",
"numpy.array",
"numpy.min",
"warnings.warn"
] | [((5219, 5238), 'copy.deepcopy', 'deepcopy', (['self.list'], {}), '(self.list)\n', (5227, 5238), False, 'from copy import deepcopy\n'), ((9657, 9674), 'pandas.DataFrame', 'pd.DataFrame', (['lst'], {}), '(lst)\n', (9669, 9674), True, 'import pandas as pd\n'), ((10229, 10359), 'warnings.warn', 'warnings.warn', (['"""get_... |
import datetime
import pytest
from unittest.mock import patch
from django.core.exceptions import ValidationError
from freezegun import freeze_time
from phonenumber_field.phonenumber import PhoneNumber
from wagtail.core.models import Page
from wagtail_extensions.blocks import (
DepartmentBlock, ImagesBlock, LinkBl... | [
"wagtail.core.models.Page",
"wagtail_extensions.blocks.OpeningTimeBlock",
"wagtail_extensions.blocks.OpeningTimesBlock.time_keyfunc",
"wagtail_extensions.blocks.OpeningTimesBlock",
"datetime.time",
"wagtail_extensions.blocks.OpeningTimesBlock.group_times",
"wagtail.core.models.Page.objects.get",
"unit... | [((3823, 3848), 'freezegun.freeze_time', 'freeze_time', (['"""2017-01-01"""'], {}), "('2017-01-01')\n", (3834, 3848), False, 'from freezegun import freeze_time\n'), ((4437, 4462), 'freezegun.freeze_time', 'freeze_time', (['"""2017-01-01"""'], {}), "('2017-01-01')\n", (4448, 4462), False, 'from freezegun import freeze_t... |
"""
BlueSky simulation client class
"""
# TODO: Need to re-add the tests for string parsing/units from the old API tests
import os
from typing import List
from semver import VersionInfo
from .bluesky_aircraft_controls import BlueSkyAircraftControls
from .bluesky_simulator_controls import BlueSkySimulatorControls
from... | [
"bluebird.sim_client.bluesky.bluesky_client.BlueSkyClient",
"os.getenv",
"semver.VersionInfo.parse"
] | [((548, 575), 'os.getenv', 'os.getenv', (['"""BS_MIN_VERSION"""'], {}), "('BS_MIN_VERSION')\n", (557, 575), False, 'import os\n'), ((695, 729), 'semver.VersionInfo.parse', 'VersionInfo.parse', (['_BS_MIN_VERSION'], {}), '(_BS_MIN_VERSION)\n', (712, 729), False, 'from semver import VersionInfo\n'), ((1623, 1638), 'blueb... |
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 27 08:49:21 2020
@author: rafae
"""
import pandas as pd
import numpy as np
def gerarbanco():
banco = pd.read_stata("Microcefalia MS analysis 20160609.dta")
circ = pd.read_csv("circumference.csv",sep=";",index_col='sem')
banco.index = range(... | [
"pandas.read_csv",
"pandas.DataFrame",
"pandas.read_stata"
] | [((170, 224), 'pandas.read_stata', 'pd.read_stata', (['"""Microcefalia MS analysis 20160609.dta"""'], {}), "('Microcefalia MS analysis 20160609.dta')\n", (183, 224), True, 'import pandas as pd\n'), ((237, 295), 'pandas.read_csv', 'pd.read_csv', (['"""circumference.csv"""'], {'sep': '""";"""', 'index_col': '"""sem"""'})... |
from redis import StrictRedis
class SentinelClient(object):
def __init__(self, url, db=None, name='default', health_check_interval=30):
"""create a redis client.
Args:
url: redis server url.
db: redis database, default 0.
name: client name, default 'default'.
... | [
"redis.StrictRedis.from_url"
] | [((452, 578), 'redis.StrictRedis.from_url', 'StrictRedis.from_url', ([], {'url': 'url', 'db': 'db', 'client_name': 'name', 'health_check_interval': 'health_check_interval', 'decode_responses': '(True)'}), '(url=url, db=db, client_name=name,\n health_check_interval=health_check_interval, decode_responses=True)\n', (4... |
from django.utils.translation import ugettext_lazy as _
MALE = "m"
FEMALE = "f"
UNSPECIFIED = "-"
GENDERS = {(MALE, _("male")),
(FEMALE, _("female")),
(UNSPECIFIED, _("don't want to answer"))}
| [
"django.utils.translation.ugettext_lazy"
] | [((117, 126), 'django.utils.translation.ugettext_lazy', '_', (['"""male"""'], {}), "('male')\n", (118, 126), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((149, 160), 'django.utils.translation.ugettext_lazy', '_', (['"""female"""'], {}), "('female')\n", (150, 160), True, 'from django.utils.transl... |
import os
import logging
import unittest
from Uefi.Capsule.CatGenerator import *
#must run from build env or set PYTHONPATH env variable to point to the PythonLibrary folder
class CatGeneratorTest(unittest.TestCase):
def test_win10_OS(self):
o = CatGenerator("x64", "win10")
self.assertEqual(o.OperatingSyst... | [
"os.path.join"
] | [((1463, 1515), 'os.path.join', 'os.path.join', (['"""c:"""', '"""test"""', '"""badpath"""', '"""inf2cat.exe"""'], {}), "('c:', 'test', 'badpath', 'inf2cat.exe')\n", (1475, 1515), False, 'import os\n')] |
import numpy as np
import matplotlib.pyplot as plt
from typing import Tuple, Union, TypeVar, Iterable, Dict
from goa import problems
T = TypeVar("T")
def plot_population(
problem: problems.BaseProblem,
X: Union[T, Iterable[T]],
ax: plt.Axes = None,
c: str = "darkblue",
linestyle: str = ":",
... | [
"numpy.subtract",
"numpy.asarray",
"matplotlib.pyplot.figure",
"numpy.cos",
"typing.TypeVar"
] | [((141, 153), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (148, 153), False, 'from typing import Tuple, Union, TypeVar, Iterable, Dict\n'), ((608, 635), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (618, 635), True, 'import matplotlib.pyplot as plt\n'), (... |
# Standard library
import os
from pathlib import Path
# Third party
from cryptography.fernet import Fernet
from dotenv import load_dotenv
# Constants
CRYPTO_KEY_ENV_VAR = 'CRYPTO_KEY'
ENV_VAR_EXIST = f'The {CRYPTO_KEY_ENV_VAR} environment variable already exist. Cannot continue as the crypto key may still be in use.... | [
"dotenv.load_dotenv",
"os.environ.get",
"cryptography.fernet.Fernet.generate_key",
"pathlib.Path.home"
] | [((408, 445), 'dotenv.load_dotenv', 'load_dotenv', ([], {'dotenv_path': 'ENV_VAR_PATH'}), '(dotenv_path=ENV_VAR_PATH)\n', (419, 445), False, 'from dotenv import load_dotenv\n'), ((337, 348), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (346, 348), False, 'from pathlib import Path\n'), ((487, 521), 'os.environ.ge... |
import csv
import config
import awb
infilename = config.datafolder+'wikidata/wdlid_ElhId.csv'
resourceitem = "Q19" #Q19: Elhuyar
#positem = "Q8" # Q7: substantibo, Q8: aditza
with open(infilename, encoding="utf-8") as csvfile:
sourcedict = csv.DictReader(csvfile)
lex_elh = {}
for row in sourcedict:
lex_elh[row['... | [
"csv.DictReader",
"awb.updateclaim",
"awb.setqualifier"
] | [((243, 266), 'csv.DictReader', 'csv.DictReader', (['csvfile'], {}), '(csvfile)\n', (257, 266), False, 'import csv\n'), ((516, 560), 'awb.updateclaim', 'awb.updateclaim', (['awbid', '"""P1"""', 'wdid', '"""string"""'], {}), "(awbid, 'P1', wdid, 'string')\n", (531, 560), False, 'import awb\n'), ((571, 644), 'awb.setqual... |
import numpy as np
from casim.calculations import word_entropy
def test_word_entropy():
test_arr = np.array([1, 0, 0, 1, 1, 0, 1, 0])
assert np.round(word_entropy(test_arr, 3), decimals=1) == 2.5
| [
"casim.calculations.word_entropy",
"numpy.array"
] | [((105, 139), 'numpy.array', 'np.array', (['[1, 0, 0, 1, 1, 0, 1, 0]'], {}), '([1, 0, 0, 1, 1, 0, 1, 0])\n', (113, 139), True, 'import numpy as np\n'), ((161, 186), 'casim.calculations.word_entropy', 'word_entropy', (['test_arr', '(3)'], {}), '(test_arr, 3)\n', (173, 186), False, 'from casim.calculations import word_en... |
import numpy as np
import matplotlib.pyplot as plt
import glob
from sys import argv
from os.path import exists as file_exists
methods = ['drude', 'c36']
mol1, mol2 = str(argv[1]), str(argv[2])
sysname = mol1+'_'+mol2
def blockavg(x,nblocks=30):
lblock = int(len(x)/nblocks)
m = []
for i in range(nblocks):
... | [
"matplotlib.pyplot.savefig",
"numpy.concatenate",
"numpy.std",
"matplotlib.pyplot.close",
"matplotlib.pyplot.legend",
"os.path.exists",
"matplotlib.pyplot.figure",
"numpy.mean",
"numpy.array",
"numpy.loadtxt",
"glob.glob",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib... | [((420, 431), 'numpy.array', 'np.array', (['m'], {}), '(m)\n', (428, 431), True, 'import numpy as np\n'), ((1330, 1344), 'numpy.array', 'np.array', (['osmp'], {}), '(osmp)\n', (1338, 1344), True, 'import numpy as np\n'), ((1374, 1386), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (1384, 1386), True, 'imp... |
# Copyright 2022 Google LLC
# 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
# https://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, sof... | [
"tensorflow.image.random_crop",
"tensorflow.data.TFRecordDataset",
"tensorflow.io.decode_image",
"tensorflow.io.parse_single_example",
"tensorflow.concat",
"tensorflow.constant",
"absl.logging.warning",
"tensorflow.data.experimental.sample_from_datasets",
"tensorflow.io.FixedLenFeature",
"tensorfl... | [((2435, 2482), 'tensorflow.io.parse_single_example', 'tf.io.parse_single_example', (['sample', 'feature_map'], {}), '(sample, feature_map)\n', (2461, 2482), True, 'import tensorflow as tf\n'), ((4124, 4157), 'tensorflow.concat', 'tf.concat', (['image_to_crop'], {'axis': '(-1)'}), '(image_to_crop, axis=-1)\n', (4133, 4... |
import matplotlib.pyplot as plt
import numpy as np
#returns the binding energy predicted by nuclear liquid drop model
def BE_liquidDrop(N,Z): #N=num of neutrons, Z=num of protons
#num of nucleons
A = N+Z
#physical constants (from Alex's notes, in MeV)
a1 = 15.49
a2 = 17.23
a3 = 0.697
a4 = 22.6
#nuclear li... | [
"numpy.zeros",
"matplotlib.pyplot.imshow",
"matplotlib.pyplot.show"
] | [((1336, 1392), 'matplotlib.pyplot.imshow', 'plt.imshow', (['mat'], {'interpolation': '"""nearest"""', 'origin': '"""lower"""'}), "(mat, interpolation='nearest', origin='lower')\n", (1346, 1392), True, 'import matplotlib.pyplot as plt\n'), ((1412, 1422), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (1420, 14... |
import gym
from gym.spaces import Box
import numpy as np
import torch as T
import rl.environments
from rl.data.buffer import TrajBuffer, ReplayBuffer
# from rl.data.buffer import TrajBuffer, ReplayBufferNP
# def make_env(env_id, seed, idx, capture_video, run_name):
# def thunk():
# print('in thunk')
# ... | [
"gym.make",
"rl.data.buffer.ReplayBuffer",
"torch.Tensor",
"rl.data.buffer.TrajBuffer",
"torch.no_grad"
] | [((1634, 1648), 'gym.make', 'gym.make', (['name'], {}), '(name)\n', (1642, 1648), False, 'import gym\n'), ((1890, 1904), 'gym.make', 'gym.make', (['name'], {}), '(name)\n', (1898, 1904), False, 'import gym\n'), ((2726, 2817), 'rl.data.buffer.TrajBuffer', 'TrajBuffer', (['self.obs_dim', 'self.act_dim', 'horizon', 'num_t... |
#!/usr/bin/env python
#Update your .twconfig file on this same directory
#with your own api keys and secrets
#Get them signing up at https://apps.twitter.com
#Install required modules with
#'pip install -r requirements.txt'
import configparser
import os
import sys
import json
import twitter
def jdefault(o):
r... | [
"sys.stdout.write",
"configparser.RawConfigParser",
"json.dumps"
] | [((477, 520), 'sys.stdout.write', 'sys.stdout.write', (['"""reading config file... """'], {}), "('reading config file... ')\n", (493, 520), False, 'import sys\n'), ((532, 562), 'configparser.RawConfigParser', 'configparser.RawConfigParser', ([], {}), '()\n', (560, 562), False, 'import configparser\n'), ((675, 716), 'sy... |
import tensorflow as tf
def neural_mf(user_input, item_input, y_, num_users, num_items, embed_partitioner=None):
embed_dim = 8
layers = [64, 32, 16, 8]
learning_rate = 0.01
with tf.compat.v1.variable_scope('nmf', dtype=tf.float32):
with tf.device('/cpu:0'):
User_Embedding = tf.comp... | [
"tensorflow.nn.relu",
"tensorflow.compat.v1.variable_scope",
"tensorflow.nn.embedding_lookup",
"tensorflow.device",
"tensorflow.reduce_mean",
"tensorflow.concat",
"tensorflow.nn.sigmoid_cross_entropy_with_logits",
"tensorflow.compat.v1.train.GradientDescentOptimizer",
"tensorflow.multiply",
"tenso... | [((196, 248), 'tensorflow.compat.v1.variable_scope', 'tf.compat.v1.variable_scope', (['"""nmf"""'], {'dtype': 'tf.float32'}), "('nmf', dtype=tf.float32)\n", (223, 248), True, 'import tensorflow as tf\n'), ((263, 282), 'tensorflow.device', 'tf.device', (['"""/cpu:0"""'], {}), "('/cpu:0')\n", (272, 282), True, 'import te... |
import pytest
from anndata import AnnData
from pandas.testing import assert_frame_equal
import numpy as np
from squidpy.gr import moran, ripley_k, co_occurrence
MORAN_K = "moranI"
def test_ripley_k(adata: AnnData):
"""Check ripley score and shape."""
ripley_k(adata, cluster_key="leiden")
# assert rip... | [
"pandas.testing.assert_frame_equal",
"squidpy.gr.co_occurrence",
"numpy.testing.assert_allclose",
"pytest.raises",
"squidpy.gr.ripley_k",
"numpy.random.choice",
"numpy.array_equal",
"pytest.mark.parametrize",
"squidpy.gr.moran"
] | [((1825, 1866), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""n_jobs"""', '[1, 2]'], {}), "('n_jobs', [1, 2])\n", (1848, 1866), False, 'import pytest\n'), ((3614, 3679), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["('n_jobs', 'n_splits')", '[(1, 2), (2, 2)]'], {}), "(('n_jobs', 'n_splits'), [(... |
"""
Tests for pyhap.characteristic
"""
import uuid
from unittest import mock
import pytest
import pyhap.characteristic as characteristic
from pyhap.characteristic import Characteristic
PROPERTIES = {
"Format": characteristic.HAP_FORMAT.INT,
"Permissions": [characteristic.HAP_PERMISSIONS.READ]
}
def get_char... | [
"uuid.uuid1",
"pytest.raises",
"unittest.mock.Mock"
] | [((1509, 1520), 'unittest.mock.Mock', 'mock.Mock', ([], {}), '()\n', (1518, 1520), False, 'from unittest import mock\n'), ((2733, 2744), 'unittest.mock.Mock', 'mock.Mock', ([], {}), '()\n', (2742, 2744), False, 'from unittest import mock\n'), ((1351, 1376), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(Valu... |
from random_survival_forest import RandomSurvivalForest, concordance_index
from lifelines import datasets
from sklearn.model_selection import train_test_split
import time
rossi = datasets.load_rossi()
# Attention: duration column must be index 0, event column index 1 in y
y = rossi.loc[:, ["arrest", "week"]]
X = rossi... | [
"random_survival_forest.concordance_index",
"sklearn.model_selection.train_test_split",
"time.time",
"random_survival_forest.RandomSurvivalForest",
"lifelines.datasets.load_rossi"
] | [((180, 201), 'lifelines.datasets.load_rossi', 'datasets.load_rossi', ([], {}), '()\n', (199, 201), False, 'from lifelines import datasets\n'), ((377, 432), 'sklearn.model_selection.train_test_split', 'train_test_split', (['X', 'y'], {'test_size': '(0.25)', 'random_state': '(10)'}), '(X, y, test_size=0.25, random_state... |
import gym
import numpy as np
import torch
import torch.optim as optim
from utils_main import make_env, save_files
from neural_network import ActorCritic
from ppo_method import ppo
from common.multiprocessing_env import SubprocVecEnv
from itertools import count
use_cuda = torch.cuda.is_available()
device = torch.devic... | [
"numpy.stack",
"ppo_method.ppo",
"utils_main.save_files",
"gym.make",
"common.multiprocessing_env.SubprocVecEnv",
"numpy.save",
"neural_network.ActorCritic",
"torch.FloatTensor",
"torch.cat",
"itertools.count",
"numpy.hstack",
"torch.cuda.is_available",
"torch.device",
"utils_main.make_env... | [((274, 299), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (297, 299), False, 'import torch\n'), ((309, 352), 'torch.device', 'torch.device', (["('cuda' if use_cuda else 'cpu')"], {}), "('cuda' if use_cuda else 'cpu')\n", (321, 352), False, 'import torch\n'), ((456, 475), 'common.multiprocess... |
import tensorflow as tf
from .config import cfg
class YoloHead(tf.keras.layers.Layer):
def __init__(self, grid_size, classes, strides, anchors, xyscale, i):
super().__init__()
self.grid_size = grid_size
self.classes = classes
self.strides = strides
self.anchors = anchors
... | [
"tensorflow.range",
"tensorflow.math.reduce_max",
"tensorflow.reshape",
"tensorflow.concat",
"tensorflow.constant",
"tensorflow.stack",
"tensorflow.cast",
"tensorflow.shape",
"tensorflow.exp",
"tensorflow.boolean_mask",
"tensorflow.split",
"tensorflow.sigmoid",
"tensorflow.expand_dims"
] | [((470, 564), 'tensorflow.reshape', 'tf.reshape', (['feature_map', '(batch_size, self.grid_size, self.grid_size, 3, 5 + self.classes)'], {}), '(feature_map, (batch_size, self.grid_size, self.grid_size, 3, 5 +\n self.classes))\n', (480, 564), True, 'import tensorflow as tf\n'), ((654, 709), 'tensorflow.split', 'tf.sp... |
"""
Author: <NAME>
File: menu.py
A general class for creating menus
Parameters:
pos - (x,y) position for the top-left corner of the menu
dims - (width, height) pixels of the menu
commands - list of dictionaries specifying the button attributes
padding - (horizontal, vertical) padding between border an... | [
"pygame.Surface",
"polybius.graphics.components.Button",
"pygame.font.SysFont",
"polybius.graphics.basics.drawable.Drawable.__init__",
"polybius.graphics.utils.window.Window.__init__"
] | [((1042, 1092), 'polybius.graphics.basics.drawable.Drawable.__init__', 'Drawable.__init__', (['self', '""""""', 'pos'], {'worldBound': '(False)'}), "(self, '', pos, worldBound=False)\n", (1059, 1092), False, 'from polybius.graphics.basics.drawable import Drawable\n'), ((1101, 1122), 'polybius.graphics.utils.window.Wind... |
from flask import flash, redirect, render_template, request, url_for
from flask_login import login_required
from sqlalchemy import and_
from . import unitOfMeasurements
from . forms import UnitOfMeasurementForm
from .. import db
from .. decorators import adminRequired
from .. models import UnitOfMeasurement
modelName ... | [
"sqlalchemy.and_",
"flask.url_for",
"flask.flash",
"flask.render_template"
] | [((521, 625), 'flask.render_template', 'render_template', (['"""unitOfMeasurements/unitOfMeasurements.html"""'], {'unitOfMeasurements': 'unitOfMeasurements'}), "('unitOfMeasurements/unitOfMeasurements.html',\n unitOfMeasurements=unitOfMeasurements)\n", (536, 625), False, 'from flask import flash, redirect, render_te... |
from unittest import mock
import pytest
from bs4 import BeautifulSoup
from conf import wsgi
@pytest.mark.django_db
@pytest.mark.parametrize('script_name,prefix', (('/sso', '/sso/accounts/'), ('', '/accounts/')))
def test_set_script_name(rf, script_name, prefix):
environ = rf._base_environ(
PATH_INFO='/a... | [
"conf.wsgi.application",
"pytest.mark.parametrize",
"bs4.BeautifulSoup"
] | [((120, 219), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""script_name,prefix"""', "(('/sso', '/sso/accounts/'), ('', '/accounts/'))"], {}), "('script_name,prefix', (('/sso', '/sso/accounts/'),\n ('', '/accounts/')))\n", (143, 219), False, 'import pytest\n'), ((487, 546), 'conf.wsgi.application', 'wsg... |
# Generated by Django 2.1.2 on 2018-11-04 16:16
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('game_catalog', '0010_auto_20181104_1036'),
]
operations = [
migrations.RemoveField(
model_name=... | [
"django.db.migrations.RemoveField"
] | [((273, 339), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""publishedgame"""', 'name': '"""edition"""'}), "(model_name='publishedgame', name='edition')\n", (295, 339), False, 'from django.db import migrations, models\n'), ((384, 454), 'django.db.migrations.RemoveField', 'migratio... |
import asyncio
from bashbot.commands import Command
from bashbot.commands.syntax import SyntaxBuilder
from bashbot.session_manager import SessionManager
class RenameCommand(Command):
def __init__(self):
super().__init__()
self.name = "Rename terminal"
self.aliases = [".rename"]
s... | [
"bashbot.session_manager.SessionManager.get_session",
"asyncio.get_event_loop",
"bashbot.commands.syntax.SyntaxBuilder"
] | [((627, 670), 'bashbot.session_manager.SessionManager.get_session', 'SessionManager.get_session', (['message.channel'], {}), '(message.channel)\n', (653, 670), False, 'from bashbot.session_manager import SessionManager\n'), ((1027, 1051), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (1049, 1051... |
import os, sys
if __name__ == "__main__":
negative_identity_weight = [0, 0, 0]
positive_identity_weight = [0, 0, 0]
negative_classes_weight = [0, 0, 0]
positive_classes_weight = [0, 0, 0]
negative_policy_weight = [0, 0, 0]
positive_policy_weight = [0, 0, 0]
for i in range(len(negative_iden... | [
"os.system"
] | [((421, 451), 'os.system', 'os.system', (['"""rm -rf ./resource"""'], {}), "('rm -rf ./resource')\n", (430, 451), False, 'import os, sys\n'), ((460, 529), 'os.system', 'os.system', (['f"""python ./SST/image_classification_policy.py --log {log}"""'], {}), "(f'python ./SST/image_classification_policy.py --log {log}')\n",... |
#!/usr/bin/env python3
"""
Limits:
- can't read brackets in brackets
- avoid using more then one bracket per line. Normally it should work, but you should use it carefull
- problems by differncing ttl/domaine, if domain[:-1].isdigit()"""
VERSION = 1.1
DOMAIN_MAX_LENGHT = 255
CLASSES = ["IN", "HS", "CH",... | [
"os.path.isfile",
"sqlite3.connect",
"time.strftime",
"os.path.basename"
] | [((9084, 9108), 'os.path.basename', 'path.basename', (['self.file'], {}), '(self.file)\n', (9097, 9108), True, 'import os.path as path\n'), ((12963, 12981), 'time.strftime', 'strftime', (['"""%Y%m%d"""'], {}), "('%Y%m%d')\n", (12971, 12981), False, 'from time import strftime\n'), ((13868, 13885), 'sqlite3.connect', 'sq... |
import pytorch_lightning as pl
import torch
import typing as th
import torchmetrics
from .. import utils as ebad_utils
class AnoTrainer(pl.LightningModule):
def __init__(
self,
model_cls: th.Union[str, torch.nn.Module],
input_shape: th.Union[th.Tuple[int], th.List[int]],
... | [
"torchmetrics.AUROC",
"torch.rand_like",
"torch.cat",
"torch.randn_like"
] | [((646, 692), 'torchmetrics.AUROC', 'torchmetrics.AUROC', ([], {'num_classes': '(2)', 'pos_label': '(1)'}), '(num_classes=2, pos_label=1)\n', (664, 692), False, 'import torchmetrics\n'), ((719, 765), 'torchmetrics.AUROC', 'torchmetrics.AUROC', ([], {'num_classes': '(2)', 'pos_label': '(1)'}), '(num_classes=2, pos_label... |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
"""
Given an URL in string, make a request, fetch its content,
and parse using BeautifulSoup.
"""
import time
import requests
import logging
import urllib.parse as urlparse
from bs4 import BeautifulSoup
class URLContentFetc... | [
"requests.get",
"bs4.BeautifulSoup",
"urllib.parse.urlparse",
"time.time"
] | [((1719, 1746), 'urllib.parse.urlparse', 'urlparse.urlparse', (['self.url'], {}), '(self.url)\n', (1736, 1746), True, 'import urllib.parse as urlparse\n'), ((2022, 2033), 'time.time', 'time.time', ([], {}), '()\n', (2031, 2033), False, 'import time\n'), ((2050, 2150), 'requests.get', 'requests.get', (['self.url'], {'he... |
from utils.models import base, product
#
# Bronze Age
#
BronzePottery = base.ManufactureBuilding(
name="🏺🏠 Гончарня",
products=[product.dish, product.jug, product.amphora],
create_price=[340, 490],
create_time_sec=1800,
manpower=108
)
BronzePlantation = base.ManufactureBuilding(
name="🍇🏠 ... | [
"utils.models.base.ManufactureBuilding"
] | [((74, 243), 'utils.models.base.ManufactureBuilding', 'base.ManufactureBuilding', ([], {'name': '"""🏺🏠 Гончарня"""', 'products': '[product.dish, product.jug, product.amphora]', 'create_price': '[340, 490]', 'create_time_sec': '(1800)', 'manpower': '(108)'}), "(name='🏺🏠 Гончарня', products=[product.dish,\n produc... |
# Generated by Django 2.1.3 on 2018-11-09 00:49
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('workertasks', '0002_auto_20181109_0046'),
]
operations = [
migrations.AlterField(
model_name='assignment',
name='beg... | [
"django.db.models.DateTimeField",
"django.db.models.IntegerField"
] | [((347, 378), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'null': '(True)'}), '(null=True)\n', (367, 378), False, 'from django.db import migrations, models\n'), ((507, 538), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'null': '(True)'}), '(null=True)\n', (527, 538), False, 'from ... |
import cotk
from cotk._utils.file_utils import get_resource_file_path
from cotk.dataloader.dataloader import *
from collections import Counter
import numpy as np
from itertools import chain
class Score(DataField):
def get_next(self, dataset):
r"""read text and returns the next label(integer). Note that it... | [
"itertools.chain.from_iterable",
"collections.Counter",
"numpy.max",
"numpy.array"
] | [((15676, 15731), 'numpy.array', 'np.array', (["[self.data[key]['score'][i] for i in indexes]"], {}), "([self.data[key]['score'][i] for i in indexes])\n", (15684, 15731), True, 'import numpy as np\n'), ((15048, 15074), 'numpy.max', 'np.max', (["res['post_length']"], {}), "(res['post_length'])\n", (15054, 15074), True, ... |
import string
import numpy as np
import pandas as pd
import pytest
from plotnine import (ggplot, aes, geom_point, geom_jitter, geom_bar,
geom_col, geom_boxplot, geom_text, geom_rect,
after_stat, position_dodge, position_dodge2,
position_jitter, positio... | [
"plotnine.geom_boxplot",
"plotnine.position_dodge2",
"numpy.ones",
"numpy.arange",
"plotnine.position_dodge",
"plotnine.aes",
"plotnine.position_stack",
"pandas.DataFrame",
"plotnine.position_jitter",
"plotnine.after_stat",
"numpy.random.RandomState",
"plotnine.position_nudge",
"pytest.raise... | [((520, 553), 'numpy.random.RandomState', 'np.random.RandomState', (['(1234567890)'], {}), '(1234567890)\n', (541, 553), True, 'import numpy as np\n'), ((560, 612), 'pandas.DataFrame', 'pd.DataFrame', (["{'x': [1, 2, 1, 2], 'y': [1, 1, 2, 2]}"], {}), "({'x': [1, 2, 1, 2], 'y': [1, 1, 2, 2]})\n", (572, 612), True, 'impo... |
from setuptools import setup, find_packages
NAME = 'golr-schema-generator'
DESCRIPTION = 'GOlr Schema Generator'
URL = 'https://github.com/deepakunni3/golr-schema-generator'
AUTHOR = '<NAME>'
EMAIL = '<EMAIL>'
REQUIRES_PYTHON = '>=3.7.0'
VERSION = '0.0.1'
LICENSE = 'BSD3'
REQUIRED = [
'PyYAML>=5.3'
]
EXTRAS = {
... | [
"setuptools.find_packages"
] | [((593, 608), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (606, 608), False, 'from setuptools import setup, find_packages\n')] |
import json
import click
from tokenizer import get_grouped_tokens, TokenName
NULL = "null"
#from click documentation to support alias command
class AliasedGroup(click.Group):
def get_command(self, ctx, cmd_name):
rv = click.Group.get_command(self, ctx, cmd_name)
if rv is not None:
ret... | [
"click.Group.get_command",
"json.load",
"click.option",
"click.echo",
"json.dumps",
"click.command",
"click.File",
"click.ClickException",
"tokenizer.get_grouped_tokens"
] | [((645, 660), 'click.command', 'click.command', ([], {}), '()\n', (658, 660), False, 'import click\n'), ((662, 785), 'click.option', 'click.option', (['"""--expression"""', '"""-e"""'], {'type': 'click.STRING', 'help': '"""jq style expression to search in the json"""', 'required': '(True)'}), "('--expression', '-e', ty... |
import os
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
MAIN_DB_URL = os.path.join(BASE_DIR, 'bucketlist.sqlite')
TEST_DB_URL = os.path.join(BASE_DIR, 'test.sqlite')
class BaseConfig(object):
'''
The class holds base config for each environment
'''
SECRET_KEY = os.getenv('SECRET_KEY', 'This s... | [
"os.path.dirname",
"os.path.join",
"os.getenv"
] | [((79, 122), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""bucketlist.sqlite"""'], {}), "(BASE_DIR, 'bucketlist.sqlite')\n", (91, 122), False, 'import os\n'), ((137, 174), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""test.sqlite"""'], {}), "(BASE_DIR, 'test.sqlite')\n", (149, 174), False, 'import os\n'), ((38,... |
import datetime
import os
from typing import List, Optional
import unittest
from parentopticon.db import test_utilities
from parentopticon.db.model import ColumnInteger, ColumnText, Model
class ModelTests(test_utilities.DBTestCase):
"Test all of our logic around the model class."
class MyTable(Model):
COLUMNS = {... | [
"parentopticon.db.model.ColumnText",
"parentopticon.db.model.ColumnInteger"
] | [((330, 381), 'parentopticon.db.model.ColumnInteger', 'ColumnInteger', ([], {'autoincrement': '(True)', 'primary_key': '(True)'}), '(autoincrement=True, primary_key=True)\n', (343, 381), False, 'from parentopticon.db.model import ColumnInteger, ColumnText, Model\n'), ((395, 410), 'parentopticon.db.model.ColumnInteger',... |
# -*- coding: utf-8 -*-
"""The UTMPX binary file event formatter."""
from plaso.formatters import interface
from plaso.formatters import manager
from plaso.lib import errors
class UtmpxSessionFormatter(interface.ConditionalEventFormatter):
"""Formatter for an UTMPX session event."""
DATA_TYPE = u'mac:utmpx:even... | [
"plaso.formatters.manager.FormattersManager.RegisterFormatter"
] | [((1969, 2035), 'plaso.formatters.manager.FormattersManager.RegisterFormatter', 'manager.FormattersManager.RegisterFormatter', (['UtmpxSessionFormatter'], {}), '(UtmpxSessionFormatter)\n', (2012, 2035), False, 'from plaso.formatters import manager\n')] |
import pytest
import numpy as np
from sklearn.datasets import load_iris
from numpy.testing import assert_array_equal
from numpy.testing import assert_allclose
from .._kdclassifier import KDClassifierRF
from .._RBFSamplerORF import RBFSamplerORF
from .._RBFSamplerSORF import RBFSamplerSORF
@pytest.fixture
def data()... | [
"sklearn.datasets.load_iris"
] | [((333, 359), 'sklearn.datasets.load_iris', 'load_iris', ([], {'return_X_y': '(True)'}), '(return_X_y=True)\n', (342, 359), False, 'from sklearn.datasets import load_iris\n')] |
from itertools import cycle, islice
import re
distances = {}
for line in open('input.txt'):
m = re.match(r'(\w+) can fly (\d+) km/s for (\d+) seconds, '
r'but then must rest for (\d+) seconds.', line)
reindeer, speed, time, rest = m.groups()
distances[reindeer] = cycle([int(speed)] * int(... | [
"re.match",
"itertools.islice"
] | [((102, 215), 're.match', 're.match', (['"""(\\\\w+) can fly (\\\\d+) km/s for (\\\\d+) seconds, but then must rest for (\\\\d+) seconds."""', 'line'], {}), "(\n '(\\\\w+) can fly (\\\\d+) km/s for (\\\\d+) seconds, but then must rest for (\\\\d+) seconds.'\n , line)\n", (110, 215), False, 'import re\n'), ((360, ... |
import datetime as dt
import pandas
import random
import smtplib
from astroid import Pass
MY_EMAIL = "your_email"
PASSWORD = "<PASSWORD>"
today = dt.datetime.now()
today_tuple = (today.month, today.day)
data = pandas.read_csv("birthdays.csv")
birthday_dict = {(data_row.month, data_row.day): data_row for (index, da... | [
"pandas.read_csv",
"smtplib.SMTP_SSL",
"datetime.datetime.now",
"random.randint"
] | [((149, 166), 'datetime.datetime.now', 'dt.datetime.now', ([], {}), '()\n', (164, 166), True, 'import datetime as dt\n'), ((214, 246), 'pandas.read_csv', 'pandas.read_csv', (['"""birthdays.csv"""'], {}), "('birthdays.csv')\n", (229, 246), False, 'import pandas\n'), ((651, 685), 'smtplib.SMTP_SSL', 'smtplib.SMTP_SSL', (... |
# -*- coding: utf-8 -*-
from __future__ import (absolute_import, division, print_function)
import warnings
from math import exp
import numpy as np
def fit_factory(discard=1):
def fit(x, y):
p = np.polyfit(x, y, 1)
v = np.polyval(p, x)
e = np.abs(y - v)
drop_idxs = np.argsort(e)[-... | [
"numpy.abs",
"numpy.log",
"numpy.polyfit",
"numpy.polyval",
"numpy.argsort",
"numpy.diff",
"numpy.array",
"warnings.warn",
"numpy.delete",
"numpy.all"
] | [((210, 229), 'numpy.polyfit', 'np.polyfit', (['x', 'y', '(1)'], {}), '(x, y, 1)\n', (220, 229), True, 'import numpy as np\n'), ((242, 258), 'numpy.polyval', 'np.polyval', (['p', 'x'], {}), '(p, x)\n', (252, 258), True, 'import numpy as np\n'), ((271, 284), 'numpy.abs', 'np.abs', (['(y - v)'], {}), '(y - v)\n', (277, 2... |
# -*- coding: utf-8 -*-
# Learn more: https://github.com/kennethreitz/setup.py
import os, sys
from setuptools import setup, find_packages
def read_requirements() -> List:
"""Parse requirements from requirements.txt."""
reqs_path = os.path.join('.', 'requirements.txt')
with open(reqs_path, 'r') as f:
... | [
"os.path.join",
"setuptools.find_packages"
] | [((242, 279), 'os.path.join', 'os.path.join', (['"""."""', '"""requirements.txt"""'], {}), "('.', 'requirements.txt')\n", (254, 279), False, 'import os, sys\n'), ((667, 707), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "('tests', 'docs')"}), "(exclude=('tests', 'docs'))\n", (680, 707), False, 'from se... |
from flatpak_indexer.models import FlatpakBuildModel, ImageModel, ImageBuildModel, RegistryModel
IMAGE1 = {
"Annotations": {"key1": "value1"},
"Architecture": "amd64",
"Digest": "sha256:baabaa",
"Labels": {"key2": "value2"},
"MediaType": "application/vnd.docker.distribution.manifest.v2+json",
... | [
"flatpak_indexer.models.ImageBuildModel.from_json",
"flatpak_indexer.models.RegistryModel.from_json",
"flatpak_indexer.models.ImageModel.from_json"
] | [((1756, 1789), 'flatpak_indexer.models.RegistryModel.from_json', 'RegistryModel.from_json', (['REGISTRY'], {}), '(REGISTRY)\n', (1779, 1789), False, 'from flatpak_indexer.models import FlatpakBuildModel, ImageModel, ImageBuildModel, RegistryModel\n'), ((1897, 1930), 'flatpak_indexer.models.RegistryModel.from_json', 'R... |
import time
import random
from MT19937 import seed_mt
from MT19937 import extract_number
def delay( seconds ): #delay thì Ctrl + C được, còn time.sleep() thì không
start = time.time()
while time.time() - start < seconds:
pass
def main():
start_time = time.time()
print('Pending.... | [
"MT19937.extract_number",
"random.randint",
"MT19937.seed_mt",
"time.time"
] | [((185, 196), 'time.time', 'time.time', ([], {}), '()\n', (194, 196), False, 'import time\n'), ((286, 297), 'time.time', 'time.time', ([], {}), '()\n', (295, 297), False, 'import time\n'), ((400, 418), 'MT19937.seed_mt', 'seed_mt', (['timestamp'], {}), '(timestamp)\n', (407, 418), False, 'from MT19937 import seed_mt\n'... |
from praline.client.project.pipeline.stage_resources import StageResources
from praline.client.project.pipeline.stages.stage import stage
from praline.client.repository.remote_proxy import RemoteProxy
from praline.common.file_system import FileSystem, join
from typing import Any, Dict
clang_format_style_file_contents... | [
"praline.common.file_system.join",
"praline.client.project.pipeline.stages.stage.stage"
] | [((1044, 1176), 'praline.client.project.pipeline.stages.stage.stage', 'stage', ([], {'requirements': "[['project_directory']]", 'output': "['clang_format_style_file', 'clang_format_executable']", 'predicate': 'predicate'}), "(requirements=[['project_directory']], output=[\n 'clang_format_style_file', 'clang_format_e... |
import unittest
from kalliope.core.NeuronModule import MissingParameterException
from kalliope.neurons.slack.slack import Slack
class TestSlack(unittest.TestCase):
def setUp(self):
self.slack_token="<PASSWORD>"
self.channel = "kalliochannel"
self.message = "kalliomessage"
def testPa... | [
"kalliope.neurons.slack.slack.Slack"
] | [((457, 484), 'kalliope.neurons.slack.slack.Slack', 'Slack', ([], {}), '(**parameters_to_test)\n', (462, 484), False, 'from kalliope.neurons.slack.slack import Slack\n')] |
# -*- coding: utf-8 -*- #
# Copyright 2016 Google LLC. All Rights Reserved.
#
# 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 requir... | [
"six.iteritems",
"googlecloudsdk.command_lib.util.args.labels_util.ProcessUpdateArgsLazy",
"googlecloudsdk.api_lib.util.apis.GetClientInstance",
"googlecloudsdk.core.properties.VALUES.core.project.GetOrFail",
"googlecloudsdk.core.resources.REGISTRY.Parse",
"apitools.base.py.list_pager.YieldFromList",
"g... | [((1140, 1179), 'googlecloudsdk.api_lib.util.apis.GetClientInstance', 'apis.GetClientInstance', (['"""spanner"""', '"""v1"""'], {}), "('spanner', 'v1')\n", (1162, 1179), False, 'from googlecloudsdk.api_lib.util import apis\n'), ((1189, 1228), 'googlecloudsdk.api_lib.util.apis.GetMessagesModule', 'apis.GetMessagesModule... |
from setuptools import setup
import pkg_resources
import autocomplete
def get_metadata_version():
"""
Tries to get the version from the django_autocomplete.egg-info directory.
"""
try:
pkg = list(pkg_resources.find_distributions('.', True))[0]
except IndexError:
return autocomplete... | [
"pkg_resources.find_distributions",
"autocomplete.get_mercurial_version",
"setuptools.setup"
] | [((431, 1075), 'setuptools.setup', 'setup', ([], {'name': '"""django-autocomplete"""', 'version': 'version', 'description': '"""autocomplete utilities for django"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""http://bitbucket.org/tyrion/django-autocomplete"""', 'download_url': '"""http://bit... |
# -*- coding: utf-8 -*-
"""Testing the functions in typhon.plots.
"""
import os
from typhon import plots
class TestPlots:
"""Testing the plot functions."""
def test_figsize(self):
"""Test golden ratio for figures sizes."""
ret = plots.figsize(10)
assert ret == (10, 6.1803398874989481... | [
"typhon.plots.get_subplot_arrangement",
"typhon.plots.styles",
"os.path.isfile",
"typhon.plots.get_available_styles",
"typhon.plots.figsize"
] | [((256, 273), 'typhon.plots.figsize', 'plots.figsize', (['(10)'], {}), '(10)\n', (269, 273), False, 'from typhon import plots\n'), ((445, 477), 'typhon.plots.get_subplot_arrangement', 'plots.get_subplot_arrangement', (['(8)'], {}), '(8)\n', (474, 477), False, 'from typhon import plots\n'), ((758, 773), 'typhon.plots.st... |
# encoding: utf-8
import ckan.plugins as plugins
import ckan.plugins.toolkit as toolkit
import logging
try:
from ckan.common import config # CKAN 2.7 and later
except ImportError:
from pylons import config # CKAN 2.7 and later
log = logging.getLogger(__name__)
def dataset_count():
"""Return a count of a... | [
"ckan.plugins.implements",
"pylons.config.get",
"ckan.plugins.toolkit.add_template_directory",
"ckan.plugins.toolkit.get_action",
"ckan.plugins.toolkit.add_public_directory",
"ckan.plugins.toolkit.add_resource",
"logging.getLogger"
] | [((243, 270), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (260, 270), False, 'import logging\n'), ((1074, 1113), 'ckan.plugins.implements', 'plugins.implements', (['plugins.IConfigurer'], {}), '(plugins.IConfigurer)\n', (1092, 1113), True, 'import ckan.plugins as plugins\n'), ((1118, 1... |
'''
This file is used for changing icons color from black to white, so icon color could be
changed in code.
Icon images are from https://github.com/iconic/open-iconic/tree/master/png
'''
import os
from PIL import Image # https://pillow.readthedocs.io/en/stable/
def find_files():
""" Finds all files from icons fo... | [
"os.fsdecode",
"os.fsencode",
"os.listdir",
"PIL.Image.open"
] | [((370, 391), 'os.fsencode', 'os.fsencode', (['"""icons/"""'], {}), "('icons/')\n", (381, 391), False, 'import os\n'), ((449, 470), 'os.listdir', 'os.listdir', (['directory'], {}), '(directory)\n', (459, 470), False, 'import os\n'), ((832, 849), 'PIL.Image.open', 'Image.open', (['image'], {}), '(image)\n', (842, 849), ... |
from django.core.management.base import BaseCommand
from reader.importer.PerseusBatchImporter import PerseusBatchImporter
from reader.importer.batch_import import JSONImportPolicy
import os
import sys
class Command(BaseCommand):
help = "Imports all Perseus XML documents from a directory that match the i... | [
"reader.importer.batch_import.JSONImportPolicy",
"os.path.split",
"reader.importer.PerseusBatchImporter.PerseusBatchImporter"
] | [((2171, 2189), 'reader.importer.batch_import.JSONImportPolicy', 'JSONImportPolicy', ([], {}), '()\n', (2187, 2189), False, 'from reader.importer.batch_import import JSONImportPolicy\n'), ((2294, 2453), 'reader.importer.PerseusBatchImporter.PerseusBatchImporter', 'PerseusBatchImporter', ([], {'perseus_directory': 'dire... |
"""An "optimizer" that draws random samples.
Scientific Machine Learning Benchmark
A benchmark of regression models in chem- and materials informatics.
2019-2020, Citrine Informatics.
"""
from typing import Optional, Any
from smlb import (
params,
Random,
RandomVectorSampler,
VectorSpaceData,
Opt... | [
"smlb.RandomVectorSampler",
"smlb.params.integer"
] | [((903, 939), 'smlb.params.integer', 'params.integer', (['num_samples'], {'above': '(0)'}), '(num_samples, above=0)\n', (917, 939), False, 'from smlb import params, Random, RandomVectorSampler, VectorSpaceData, Optimizer, TrackedTransformation\n'), ((964, 1031), 'smlb.RandomVectorSampler', 'RandomVectorSampler', ([], {... |
try:
import orjson as json
except ImportError:
import json
import toml
import yaml
def format_requirements(data: dict) -> str:
result = []
for group, values in data.items():
result.append(f"### {group.upper()}\n")
for extras, version in values.items():
result.append(f"{ext... | [
"toml.dumps",
"yaml.dump",
"json.dumps"
] | [((457, 473), 'json.dumps', 'json.dumps', (['data'], {}), '(data)\n', (467, 473), False, 'import json\n'), ((609, 625), 'toml.dumps', 'toml.dumps', (['data'], {}), '(data)\n', (619, 625), False, 'import toml\n'), ((668, 683), 'yaml.dump', 'yaml.dump', (['data'], {}), '(data)\n', (677, 683), False, 'import yaml\n')] |
#!/usr/bin/env python3
import os, numpy as np, argparse
def relFit(nu, eps): return 7.33972668 * np.power(eps, 1/6.0) / np.sqrt(nu)
def etaFit(nu, eps): return np.power(eps, -0.25) * np.power(nu, 0.75)
def lambdaFit(nu, eps): return 5.35507603 * np.power(eps,-1/6.0) * np.sqrt(nu);
def runspec(nu, eps, run, cs... | [
"argparse.ArgumentParser",
"numpy.power",
"os.system",
"numpy.linspace",
"numpy.log10",
"os.getenv",
"numpy.sqrt"
] | [((762, 779), 'numpy.sqrt', 'np.sqrt', (['(nu / eps)'], {}), '(nu / eps)\n', (769, 779), True, 'import os, numpy as np, argparse\n'), ((1307, 1324), 'numpy.sqrt', 'np.sqrt', (['(nu / eps)'], {}), '(nu / eps)\n', (1314, 1324), True, 'import os, numpy as np, argparse\n'), ((1329, 1496), 'os.system', 'os.system', (['("""e... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from collections import defaultdict
import numpy as np
def find_smallest_positive(alist):
# find first positive value
minpos = -1
for x in alist:
if x > 0:
minpos = x
... | [
"collections.defaultdict",
"numpy.mean"
] | [((3311, 3328), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (3322, 3328), False, 'from collections import defaultdict\n'), ((4362, 4382), 'numpy.mean', 'np.mean', (['importances'], {}), '(importances)\n', (4369, 4382), True, 'import numpy as np\n')] |
import torch.nn as nn
from ..registry import HEADS
from ..utils import ConvModule
from .bbox_head import BBoxHead
import torch
import torch.nn.functional as F
import mmcv
from mmdet.core import mask_target, mask_bg_target, force_fp32, bbox_target, bbox_overlaps
from ..losses import accuracy
from ..builder import build... | [
"torch.nn.ReLU",
"torch.nn.ModuleList",
"torch.nn.init.xavier_uniform_",
"mmdet.core.mask_target",
"torch.cat",
"torch.nn.init.constant_",
"torch.nn.Linear",
"mmdet.core.mask_bg_target"
] | [((4509, 4530), 'torch.nn.ReLU', 'nn.ReLU', ([], {'inplace': '(True)'}), '(inplace=True)\n', (4516, 4530), True, 'import torch.nn as nn\n'), ((5421, 5436), 'torch.nn.ModuleList', 'nn.ModuleList', ([], {}), '()\n', (5434, 5436), True, 'import torch.nn as nn\n'), ((6058, 6073), 'torch.nn.ModuleList', 'nn.ModuleList', ([]... |
#!/usr/bin/python3
from services.loggerServices.loggerService import LoggerService
logger = LoggerService().logger
def create_match(self, data):
return self.client.FMT["matches"].insert_one(data).inserted_id
def update_match(self, data):
return self.client.FMT["matches"].update_one(data, upsert=True).inser... | [
"services.loggerServices.loggerService.LoggerService"
] | [((93, 108), 'services.loggerServices.loggerService.LoggerService', 'LoggerService', ([], {}), '()\n', (106, 108), False, 'from services.loggerServices.loggerService import LoggerService\n')] |
#!/usr/bin/env python3
import json
import logging
import os
import re
import subprocess # nosec
import sys
from typing import Dict, Optional, Tuple, cast
SRC_VERSION_RE = re.compile(r"^.*\(([^=]*)===?([^=]*)\)$")
VERSION_RE = re.compile(r"^([^=]*)==([^=]*)$")
LOG = logging.getLogger(__name__)
def _get_package_versi... | [
"json.dump",
"subprocess.check_output",
"logging.getLogger",
"re.compile"
] | [((173, 215), 're.compile', 're.compile', (['"""^.*\\\\(([^=]*)===?([^=]*)\\\\)$"""'], {}), "('^.*\\\\(([^=]*)===?([^=]*)\\\\)$')\n", (183, 215), False, 'import re\n'), ((228, 260), 're.compile', 're.compile', (['"""^([^=]*)==([^=]*)$"""'], {}), "('^([^=]*)==([^=]*)$')\n", (238, 260), False, 'import re\n'), ((268, 295)... |
# -*- coding: utf-8 -*-
##############################################################################
#
# OpenERP, Open Source Management Solution
# Copyright (C) 2004-2010 Tiny SPRL (<http://tiny.be>).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU... | [
"subprocess.Popen",
"os.unlink",
"tempfile.mkstemp",
"os.close",
"os.path.splitext",
"os.write",
"logging.getLogger"
] | [((1064, 1091), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1081, 1091), False, 'import logging\n'), ((2877, 2905), 'tempfile.mkstemp', 'tempfile.mkstemp', ([], {'suffix': 'ext'}), '(suffix=ext)\n', (2893, 2905), False, 'import tempfile\n'), ((2922, 2943), 'os.write', 'os.write', (['f... |
#!/usr/bin/env python3
from __future__ import print_function
import morfessor
import sys
import logging
import lzma
import os
import math
def main(allowed_chars_file, model):
allowed_chars = {line.strip() for line in open(allowed_chars_file, encoding='utf-8') if len(line.strip()) == 1}
model = morfessor.M... | [
"morfessor.MorfessorIO",
"sys.exit",
"logging.basicConfig"
] | [((575, 614), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (594, 614), False, 'import logging\n'), ((1005, 1017), 'sys.exit', 'sys.exit', (['(-1)'], {}), '(-1)\n', (1013, 1017), False, 'import sys\n'), ((309, 332), 'morfessor.MorfessorIO', 'morfessor.Morfessor... |
from __future__ import print_function
from create_tree import *
import numpy as np
import random
DATA_DIR = "../data/"
def curriculum_depth(i, num_examples, max_depth):
curriculum_max_depth= int((max_depth*i)/num_examples)
#print(i, curriculum_max_depth,)
if curriculum_max_depth > 0:
random_depth ... | [
"numpy.random.randint"
] | [((326, 365), 'numpy.random.randint', 'np.random.randint', (['curriculum_max_depth'], {}), '(curriculum_max_depth)\n', (343, 365), True, 'import numpy as np\n'), ((857, 877), 'numpy.random.randint', 'np.random.randint', (['(2)'], {}), '(2)\n', (874, 877), True, 'import numpy as np\n')] |
# Copyright 2015 F5 Networks Inc.
#
# 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 writi... | [
"io.StringIO",
"pytest.config.getoption",
"distutils.version.LooseVersion",
"pytest.fixture",
"pytest.raises"
] | [((943, 975), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (957, 975), False, 'import pytest\n'), ((1343, 1375), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1357, 1375), False, 'import pytest\n'), ((1649, 1681), 'pytes... |
"""
功能：分形树
版本：1.0
日期：2018/08/19
"""
import turtle
def draw_branch(branch_length, pen_size):
if(branch_length > 0):
turtle.forward(branch_length)
turtle.right(20)
draw_branch(branch_length-10, pen_size)
turtle.left(40)
draw_branch(branch_length-10, pen_size)
... | [
"turtle.backward",
"turtle.forward",
"turtle.exitonclick",
"turtle.right",
"turtle.penup",
"turtle.left",
"turtle.pendown"
] | [((415, 431), 'turtle.right', 'turtle.right', (['(90)'], {}), '(90)\n', (427, 431), False, 'import turtle\n'), ((436, 450), 'turtle.penup', 'turtle.penup', ([], {}), '()\n', (448, 450), False, 'import turtle\n'), ((455, 474), 'turtle.forward', 'turtle.forward', (['(300)'], {}), '(300)\n', (469, 474), False, 'import tur... |
# Generated by Django 2.1.4 on 2019-04-26 07:24
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('core', '0014_auto_20190417_1639'),
]
operations = [
migrations.AlterUniqueTogether(
name='documentpart',
unique_together={('... | [
"django.db.migrations.AlterUniqueTogether"
] | [((224, 321), 'django.db.migrations.AlterUniqueTogether', 'migrations.AlterUniqueTogether', ([], {'name': '"""documentpart"""', 'unique_together': "{('order', 'document')}"}), "(name='documentpart', unique_together={(\n 'order', 'document')})\n", (254, 321), False, 'from django.db import migrations\n')] |
# Generated by Django 2.2.13 on 2021-07-22 14:49
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('des', '0032_auto_20210713_2127'),
]
operations = [
migrations.AlterField(
model_name='astrometryjob',
name='status'... | [
"django.db.models.IntegerField"
] | [((340, 522), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'choices': "[(1, 'Idle'), (2, 'Running'), (3, 'Completed'), (4, 'Failed'), (5,\n 'Aborted'), (6, 'Warning'), (7, 'Launched')]", 'default': '(1)', 'verbose_name': '"""Status"""'}), "(choices=[(1, 'Idle'), (2, 'Running'), (3, 'Completed'),\n ... |
import pytest
from pyformlang.finite_automaton import NondeterministicFiniteAutomaton
from project import BooleanMatrices
@pytest.fixture
def nfa():
nfa = NondeterministicFiniteAutomaton()
nfa.add_transitions(
[
(0, "X", 1),
(0, "X", 2),
(1, "Y", 2),
(1... | [
"pyformlang.finite_automaton.NondeterministicFiniteAutomaton",
"pytest.mark.parametrize",
"project.BooleanMatrices"
] | [((441, 542), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""label,expected_nnz"""', "[('X', 2), ('Y', 1), ('Z', 1), ('S', 1), ('W', 2)]"], {}), "('label,expected_nnz', [('X', 2), ('Y', 1), ('Z', 1),\n ('S', 1), ('W', 2)])\n", (464, 542), False, 'import pytest\n'), ((888, 1033), 'pytest.mark.parametrize... |
# -*- coding: utf-8 -*-
from scripts import tabledef
from flask import session
from sqlalchemy.orm import sessionmaker
from contextlib import contextmanager
import bcrypt
import sys, subprocess, ipaddress, time, datetime, json, os, csv, copy
from watson_developer_cloud import DiscoveryV1
EnvID="5aec3469-82f9-49cb-9... | [
"sqlalchemy.orm.sessionmaker",
"watson_developer_cloud.DiscoveryV1"
] | [((911, 1021), 'watson_developer_cloud.DiscoveryV1', 'DiscoveryV1', ([], {'version': '"""2018-03-05"""', 'username': '"""9e523dc4-1206-4898-a30f-faf75cd8526b"""', 'password': '"""<PASSWORD>"""'}), "(version='2018-03-05', username=\n '9e523dc4-1206-4898-a30f-faf75cd8526b', password='<PASSWORD>')\n", (922, 1021), Fals... |
# -*- coding: utf-8 -*-
from celery.task import task
@task
def publish_recipe(recipe):
from recipes.models import Recipe
try:
recipe = Recipe.objects.get(id=recipe.id)
recipe.published=True
recipe.save()
except Recipe.DoesNotExist:
pass | [
"recipes.models.Recipe.objects.get"
] | [((141, 173), 'recipes.models.Recipe.objects.get', 'Recipe.objects.get', ([], {'id': 'recipe.id'}), '(id=recipe.id)\n', (159, 173), False, 'from recipes.models import Recipe\n')] |
# Copyright (c) 2018-2021 Trim21 <<EMAIL>>
# Copyright (c) 2008-2014 <NAME> <<EMAIL>>
# Licensed under the MIT license.
from typing import TYPE_CHECKING, Any, Dict, Tuple, Union, Generator
from typing_extensions import Literal
from transmission_rpc.lib_types import Field
if TYPE_CHECKING:
from transmission_rpc.c... | [
"transmission_rpc.lib_types.Field"
] | [((1972, 1990), 'transmission_rpc.lib_types.Field', 'Field', (['value', '(True)'], {}), '(value, True)\n', (1977, 1990), False, 'from transmission_rpc.lib_types import Field\n'), ((2086, 2104), 'transmission_rpc.lib_types.Field', 'Field', (['value', '(True)'], {}), '(value, True)\n', (2091, 2104), False, 'from transmis... |
from decimal import Decimal as D
from django.test import TestCase
from nose.plugins.attrib import attr
import mock
from oscar.apps.shipping import methods
from oscar.apps.shipping.models import OrderAndItemCharges
@attr('shipping')
class TestStandardMethods(TestCase):
def setUp(self):
self.non_discount... | [
"decimal.Decimal",
"oscar.apps.shipping.methods.TaxExclusiveOfferDiscount",
"mock.Mock",
"oscar.apps.shipping.methods.Free",
"nose.plugins.attrib.attr"
] | [((219, 235), 'nose.plugins.attrib.attr', 'attr', (['"""shipping"""'], {}), "('shipping')\n", (223, 235), False, 'from nose.plugins.attrib import attr\n'), ((832, 843), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (841, 843), False, 'import mock\n'), ((947, 1005), 'oscar.apps.shipping.methods.TaxExclusiveOfferDiscount',... |
# Network
import numpy as np
import pandas as pd
import simulator
import random
from igraph import *
import matplotlib.pyplot as plt
class Network():
"""docstring for Network"""
def __init__(self, simulator):
# Genero un grafo random
self.g = Graph.Erdos_Renyi(simulator.num_nodi,simulator.p_link)
# Ini... | [
"pandas.DataFrame",
"numpy.count_nonzero",
"numpy.concatenate",
"numpy.copy",
"matplotlib.pyplot.clf",
"numpy.zeros",
"numpy.nonzero",
"numpy.random.random",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.savefig"
] | [((408, 441), 'numpy.zeros', 'np.zeros', (['(simulator.num_nodi, 1)'], {}), '((simulator.num_nodi, 1))\n', (416, 441), True, 'import numpy as np\n'), ((458, 506), 'numpy.zeros', 'np.zeros', (['(simulator.num_nodi, 1)'], {'dtype': 'np.int8'}), '((simulator.num_nodi, 1), dtype=np.int8)\n', (466, 506), True, 'import numpy... |
from django.contrib import admin
# Register your models here.
from .models import shortenedUrl
admin.site.register(shortenedUrl) | [
"django.contrib.admin.site.register"
] | [((97, 130), 'django.contrib.admin.site.register', 'admin.site.register', (['shortenedUrl'], {}), '(shortenedUrl)\n', (116, 130), False, 'from django.contrib import admin\n')] |
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import division
from __future__ import absolute_import
from future import standard_library
import twitter_scraper as twitter_scraper
import json
import codecs
standard_library.install_aliases()
def main():
def build_list... | [
"codecs.open",
"twitter_scraper.scraper.Scraper.get_tweets",
"future.standard_library.install_aliases",
"json.dumps",
"twitter_scraper.scraper.SearchParams"
] | [((253, 287), 'future.standard_library.install_aliases', 'standard_library.install_aliases', ([], {}), '()\n', (285, 287), False, 'from future import standard_library\n'), ((1052, 1109), 'twitter_scraper.scraper.Scraper.get_tweets', 'twitter_scraper.scraper.Scraper.get_tweets', (['search_params'], {}), '(search_params)... |
import yaml
import click
from accelbyte_py_sdk.api.iam import admin_get_banned_users_v3
from ._utils import login_as as login_as_internal
@click.command()
@click.argument("active_only", type=bool)
@click.argument("ban_type")
@click.argument("offset", type=int)
@click.argument("limit", type=int)
@click.option("--na... | [
"click.argument",
"click.echo",
"click.option",
"click.command",
"click.Choice",
"accelbyte_py_sdk.api.iam.admin_get_banned_users_v3"
] | [((144, 159), 'click.command', 'click.command', ([], {}), '()\n', (157, 159), False, 'import click\n'), ((161, 201), 'click.argument', 'click.argument', (['"""active_only"""'], {'type': 'bool'}), "('active_only', type=bool)\n", (175, 201), False, 'import click\n'), ((203, 229), 'click.argument', 'click.argument', (['""... |
from aocd import get_data
def part1(a):
return sum(len(l) - len(l.encode('utf-8').decode('unicode_escape')) + 2 for l in a)
def part2(a):
return sum(len(l.encode('unicode_escape').decode('utf-8').replace('"', '\\"')) - len(l) + 2 for l in a)
if __name__ == '__main__':
data = get_data(day=8, year=2015)... | [
"aocd.get_data"
] | [((294, 320), 'aocd.get_data', 'get_data', ([], {'day': '(8)', 'year': '(2015)'}), '(day=8, year=2015)\n', (302, 320), False, 'from aocd import get_data\n')] |
from adafruit_led_animation.animation import Animation
import adafruit_framebuf
class TextScroll(Animation):
def __init__(self, grid_object, speed, text, color, font_name='font5x8.bin', name=None):
self._text = text
self._font_name = font_name
self._frame = 0
# We're only using th... | [
"adafruit_framebuf.FrameBuffer"
] | [((461, 584), 'adafruit_framebuf.FrameBuffer', 'adafruit_framebuf.FrameBuffer', (['self._buffer', 'grid_object.width', 'grid_object.height'], {'buf_format': 'adafruit_framebuf.MVLSB'}), '(self._buffer, grid_object.width, grid_object.\n height, buf_format=adafruit_framebuf.MVLSB)\n', (490, 584), False, 'import adafru... |
import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, models, activations
from models.cnn_gru.cnn import CNN, Encoder
class CnnGru(tf.keras.Model):
def __init__(self, seq_len):
super().__init__()
self.seq_len = seq_len
self.cnn = CNN()... | [
"models.cnn_gru.cnn.Encoder",
"tensorflow.nn.relu",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.Dense",
"models.cnn_gru.cnn.CNN",
"tensorflow.keras.layers.Flatten"
] | [((315, 320), 'models.cnn_gru.cnn.CNN', 'CNN', ([], {}), '()\n', (318, 320), False, 'from models.cnn_gru.cnn import CNN, Encoder\n'), ((416, 442), 'models.cnn_gru.cnn.Encoder', 'Encoder', (['self.cnn', 'ip_dims'], {}), '(self.cnn, ip_dims)\n', (423, 442), False, 'from models.cnn_gru.cnn import CNN, Encoder\n'), ((465, ... |
'''Create an omim mapping based on information from Face2Gene using the
Face2Gene library.'''
from pprint import pprint
import json
from lib.api.face2gene import Face2Gene
from lib.model.config import ConfigManager
config_data = ConfigManager()
f2g_session = Face2Gene(config=config_data)
s_list = f2g_session.brows... | [
"lib.api.face2gene.Face2Gene",
"lib.model.config.ConfigManager",
"json.dump"
] | [((232, 247), 'lib.model.config.ConfigManager', 'ConfigManager', ([], {}), '()\n', (245, 247), False, 'from lib.model.config import ConfigManager\n'), ((263, 292), 'lib.api.face2gene.Face2Gene', 'Face2Gene', ([], {'config': 'config_data'}), '(config=config_data)\n', (272, 292), False, 'from lib.api.face2gene import Fac... |
from googletrans import LANGUAGES
from googletrans import Translator
translator = Translator()
async def ajuda(message, comandos :dict):
msg = "```\n"
for c in comandos.keys():
msg += comandos[c][1]+'\n'
msg += "```"
await message.channel.send(msg)
async def traduz(message, _):
msg = message.conten... | [
"googletrans.LANGUAGES.values",
"googletrans.Translator",
"googletrans.LANGUAGES.keys"
] | [((83, 95), 'googletrans.Translator', 'Translator', ([], {}), '()\n', (93, 95), False, 'from googletrans import Translator\n'), ((1063, 1079), 'googletrans.LANGUAGES.keys', 'LANGUAGES.keys', ([], {}), '()\n', (1077, 1079), False, 'from googletrans import LANGUAGES\n'), ((495, 511), 'googletrans.LANGUAGES.keys', 'LANGUA... |