code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from copy import deepcopy
import json
FILTERS_KW = ["SELECT", "FROM", "WHERE", "ORDER BY", "LIMIT", "SAME", "CONTAINS_COREFERENCE"]
LIMITS = {"FIRST": "1", "SECOND": "2", "THIRD": "3"}
# name resolution for properties: DOES NOT EXIST
# that is: "triples"/"properties"/"column names" are equivalent, and a
# single mem... | [
"droidlet.interpreter.tests.all_test_commands.FILTERS.items",
"json.loads",
"ipdb.set_trace",
"copy.deepcopy"
] | [((2474, 2485), 'copy.deepcopy', 'deepcopy', (['d'], {}), '(d)\n', (2482, 2485), False, 'from copy import deepcopy\n'), ((21621, 21654), 'droidlet.interpreter.tests.all_test_commands.FILTERS.items', 'all_test_commands.FILTERS.items', ([], {}), '()\n', (21652, 21654), False, 'from droidlet.interpreter.tests import all_t... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
from alipay.aop.api.response.AlipayResponse import AlipayResponse
from alipay.aop.api.domain.GroupFundBill import GroupFundBill
from alipay.aop.api.domain.GroupFundBill import GroupFundBill
class AlipayFundTransGroupfundsFundbillsQueryResponse(AlipayResponse)... | [
"alipay.aop.api.domain.GroupFundBill.GroupFundBill.from_alipay_dict"
] | [((1032, 1069), 'alipay.aop.api.domain.GroupFundBill.GroupFundBill.from_alipay_dict', 'GroupFundBill.from_alipay_dict', (['value'], {}), '(value)\n', (1062, 1069), False, 'from alipay.aop.api.domain.GroupFundBill import GroupFundBill\n'), ((1463, 1496), 'alipay.aop.api.domain.GroupFundBill.GroupFundBill.from_alipay_dic... |
""" ProtoRPC message class definitions for TicTicToe API. """
from protorpc import messages, message_types
import endpoints
"""Resource containers used for passing to the API from requester"""
"""Hopefully these names are self explanatory, nothing special here"""
GAME_REQUEST = endpoints.ResourceContainer(
game_k... | [
"protorpc.messages.StringField",
"protorpc.messages.BooleanField",
"protorpc.messages.IntegerField",
"protorpc.messages.MessageField"
] | [((1118, 1156), 'protorpc.messages.StringField', 'messages.StringField', (['(1)'], {'required': '(True)'}), '(1, required=True)\n', (1138, 1156), False, 'from protorpc import messages, message_types\n'), ((1275, 1313), 'protorpc.messages.StringField', 'messages.StringField', (['(1)'], {'required': '(True)'}), '(1, requ... |
#!/usr/bin/env python
# Generic code for a classifier
#
# Subscribes to a feature vector (custom_msgs/Float32MultiArray) and a label (custom_msgs/String)
# Uses upcoming feature data to fit a classifier to predict the label
# Interface with topic command (Start/Stop learning)
import rospy
import numpy as np
import si... | [
"scipy.io.savemat",
"rospy.init_node",
"scipy.io.loadmat",
"numpy.array",
"rospy.Rate",
"copy.deepcopy",
"sys.exit",
"numpy.greater",
"threading.Lock",
"numpy.concatenate",
"joblib.load",
"rospy.Subscriber",
"joblib.dump",
"rospy.Time.now",
"EpicToolbox.mkdirfile",
"rospy.Publisher",
... | [((914, 922), 'custom_msgs.msg.String', 'String', ([], {}), '()\n', (920, 922), False, 'from custom_msgs.msg import String, Float32MultiArray\n'), ((937, 948), 'std_msgs.msg.String', 'StdString', ([], {}), '()\n', (946, 948), True, 'from std_msgs.msg import String as StdString\n'), ((960, 1011), 'rospy.Publisher', 'ros... |
import json
import csv
import pandas as pd
def read_csv(file_name, names, delimiter='t'):
with open(file_name, 'r', encoding='utf-8') as file_obj:
for line in file_obj.readlines():
line.replace('\n', '').replace(' ', '\t')
if delimiter == 't':
sep = '\t'
elif delimiter == 'b':... | [
"pandas.read_csv"
] | [((384, 511), 'pandas.read_csv', 'pd.read_csv', (['file_name'], {'sep': 'sep', 'quoting': 'csv.QUOTE_NONE', 'encoding': '"""utf-8"""', 'skip_blank_lines': '(False)', 'header': 'None', 'names': 'names'}), "(file_name, sep=sep, quoting=csv.QUOTE_NONE, encoding='utf-8',\n skip_blank_lines=False, header=None, names=name... |
import unittest
from rcwa import Source, Layer, Plotter, Crystal, Solver, LayerStack
from rcwa.shorthand import *
from rcwa.testing import *
from rcwa.matrices import *
from rcwa import numpyArrayFromFile, testLocation, numpyArrayFromSeparatedColumnsFile
import numpy as np
class TestSolver(unittest.TestCase):
de... | [
"numpy.arange",
"rcwa.Source",
"rcwa.Crystal",
"rcwa.Solver",
"numpy.array",
"numpy.loadtxt",
"rcwa.LayerStack",
"rcwa.numpyArrayFromSeparatedColumnsFile",
"rcwa.Layer",
"numpy.transpose",
"rcwa.numpyArrayFromFile"
] | [((5963, 5984), 'rcwa.Layer', 'Layer', ([], {'er': '(2.0)', 'ur': '(1.0)'}), '(er=2.0, ur=1.0)\n', (5968, 5984), False, 'from rcwa import Source, Layer, Plotter, Crystal, Solver, LayerStack\n'), ((6013, 6034), 'rcwa.Layer', 'Layer', ([], {'er': '(9.0)', 'ur': '(1.0)'}), '(er=9.0, ur=1.0)\n', (6018, 6034), False, 'from ... |
from os import path
import numpy as np
from PIL import Image
from scipy import ndimage
from glob import glob
from medraw_handler import medraw2mask
from skimage.color import label2rgb
for f_idx in [1, 2]: # process two images
auto_label = np.array(Image.open('auto_segs/{}_auto_seg.png'.format(f_idx)))
he_imag... | [
"os.path.exists",
"PIL.Image.fromarray",
"medraw_handler.medraw2mask",
"scipy.ndimage.measurements.label",
"scipy.ndimage.binary_fill_holes",
"numpy.zeros",
"skimage.color.label2rgb",
"numpy.zeros_like"
] | [((445, 460), 'os.path.exists', 'path.exists', (['fn'], {}), '(fn)\n', (456, 460), False, 'from os import path\n'), ((664, 690), 'numpy.zeros_like', 'np.zeros_like', (['human_label'], {}), '(human_label)\n', (677, 690), True, 'import numpy as np\n'), ((484, 499), 'medraw_handler.medraw2mask', 'medraw2mask', (['fn'], {}... |
# -*- coding: utf-8 -*-
"""
TencentBlueKing is pleased to support the open source community by making 蓝鲸智云-用户管理(Bk-User) available.
Copyright (C) 2017-2021 THL A29 Limited, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except in compliance with the Lic... | [
"enum.auto"
] | [((843, 849), 'enum.auto', 'auto', ([], {}), '()\n', (847, 849), False, 'from enum import auto\n'), ((915, 921), 'enum.auto', 'auto', ([], {}), '()\n', (919, 921), False, 'from enum import auto\n'), ((949, 955), 'enum.auto', 'auto', ([], {}), '()\n', (953, 955), False, 'from enum import auto\n'), ((996, 1002), 'enum.au... |
from coc import utils
from datetime import datetime
from discord.ext import commands, tasks
class DatabaseBackground(commands.Cog):
def __init__(self, bot):
self.bot = bot
self.update.start()
def cog_unload(self):
self.update.cancel()
@commands.command(name="add_user")
async ... | [
"datetime.datetime.now",
"discord.ext.tasks.loop",
"discord.ext.commands.command",
"coc.utils.correct_tag"
] | [((276, 309), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""add_user"""'}), "(name='add_user')\n", (292, 309), False, 'from discord.ext import commands, tasks\n'), ((684, 707), 'discord.ext.tasks.loop', 'tasks.loop', ([], {'minutes': '(3.0)'}), '(minutes=3.0)\n', (694, 707), False, 'from discord... |
# This file is being contributed to pyasn1-modules software.
#
# Created by <NAME>.
#
# Copyright (c) 2019, Vigil Security, LLC
# License: http://snmplabs.com/pyasn1/license.html
#
# Algorithm Identifiers for Ed25519, Ed448, X25519, and X448
#
# ASN.1 source from:
# https://www.rfc-editor.org/rfc/rfc8410.txt
... | [
"pyasn1.type.univ.ObjectIdentifier"
] | [((697, 736), 'pyasn1.type.univ.ObjectIdentifier', 'univ.ObjectIdentifier', (['"""192.168.127.12"""'], {}), "('192.168.127.12')\n", (718, 736), False, 'from pyasn1.type import univ\n'), ((750, 789), 'pyasn1.type.univ.ObjectIdentifier', 'univ.ObjectIdentifier', (['"""192.168.127.12"""'], {}), "('192.168.127.12')\n", (77... |
import pygame
from math import sin, cos, pi
import constants
class Projectile(pygame.sprite.Sprite):
"""
Represents projectile object.
Attributes:
_id: ID of the projectile (unique)
..others
"""
def __init__(self, id, owner, x, y, angle, turret, attributes):
super().__init... | [
"math.cos",
"math.sin",
"pygame.transform.rotozoom"
] | [((769, 822), 'pygame.transform.rotozoom', 'pygame.transform.rotozoom', (['self.image', 'self._angle', '(1)'], {}), '(self.image, self._angle, 1)\n', (794, 822), False, 'import pygame\n'), ((1799, 1828), 'math.sin', 'sin', (['(self._angle * (pi / 180))'], {}), '(self._angle * (pi / 180))\n', (1802, 1828), False, 'from ... |
# Copyright (c) 2017 OpenAI (http://openai.com)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, p... | [
"numpy.prod",
"numpy.allclose",
"numpy.corrcoef",
"numpy.array",
"numpy.concatenate",
"numpy.zeros_like",
"numpy.var"
] | [((1948, 1957), 'numpy.var', 'np.var', (['y'], {}), '(y)\n', (1954, 1957), True, 'import numpy as np\n'), ((2109, 2126), 'numpy.var', 'np.var', (['y'], {'axis': '(0)'}), '(y, axis=0)\n', (2115, 2126), True, 'import numpy as np\n'), ((2299, 2341), 'numpy.concatenate', 'np.concatenate', (['[arr.flat for arr in arrs]'], {... |
from bs4 import BeautifulSoup
from ._helpers import text_values, column_titles, lists2dict, clean_string, MetaList
def events(oscn_html):
events = MetaList()
soup = BeautifulSoup(oscn_html, "html.parser")
events_start = soup.find("h2", "section events")
events_table = events_start.find_next_sibling()... | [
"bs4.BeautifulSoup"
] | [((176, 215), 'bs4.BeautifulSoup', 'BeautifulSoup', (['oscn_html', '"""html.parser"""'], {}), "(oscn_html, 'html.parser')\n", (189, 215), False, 'from bs4 import BeautifulSoup\n')] |
import sys, matplotlib.pyplot as plt
file = open(sys.argv[1], 'r') # e.g. BIG_4_SportsChampions.csv
x = range(1780,2000)
y = [0] * len(x)
for line in file:
if line[0]=='#': continue
vars = line.split(',')
year = int(vars[0]) - x[0]
year = max(year, 0)
year = min(year, len(y)-1)
y[year] += 1
file.close()
z = [... | [
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((508, 522), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (520, 522), True, 'import sys, matplotlib.pyplot as plt\n'), ((630, 640), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (638, 640), True, 'import sys, matplotlib.pyplot as plt\n')] |
#/usr/bin/env python3
# -*- coding: UTF-8 -*-
#
# This file is part of ubuntu-first-steps
#
# Copyright (c) 2020 <NAME> <a.k.a. atareao>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software with... | [
"threading.Thread.__init__",
"shlex.split",
"os.environ.copy",
"gi.require_version",
"time.sleep",
"gi.repository.GObject.GObject.__init__",
"gi.repository.GLib.idle_add"
] | [((1213, 1249), 'gi.require_version', 'gi.require_version', (['"""GObject"""', '"""2.0"""'], {}), "('GObject', '2.0')\n", (1231, 1249), False, 'import gi\n'), ((1254, 1287), 'gi.require_version', 'gi.require_version', (['"""GLib"""', '"""2.0"""'], {}), "('GLib', '2.0')\n", (1272, 1287), False, 'import gi\n'), ((1927, 1... |
# -*- coding: utf-8 -*-
# Licensed under a 3-clause BSD style license - see LICENSE.rst
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import sys
if sys.version_info[0] == 3:
xrange = range
# Test that local imports work
from .shared import shared_fu... | [
"sys.stdout.write"
] | [((723, 744), 'sys.stdout.write', 'sys.stdout.write', (['"""X"""'], {}), "('X')\n", (739, 744), False, 'import sys\n')] |
from __future__ import unicode_literals
from django.contrib.contenttypes.fields import GenericRelation, GenericForeignKey
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.db.models import ForeignKey, CASCADE
from django.utils.encoding import python_2_unicode_compatibl... | [
"django.db.models.ForeignKey",
"django.db.models.PositiveIntegerField",
"django.contrib.contenttypes.fields.GenericForeignKey",
"django.db.models.CharField",
"django.contrib.contenttypes.fields.GenericRelation"
] | [((390, 422), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (406, 422), False, 'from django.db import models\n'), ((438, 467), 'django.db.models.PositiveIntegerField', 'models.PositiveIntegerField', ([], {}), '()\n', (465, 467), False, 'from django.db import mode... |
"""Test fixture configuration."""
import pytest
import os
import uuid
import pathlib
from datetime import datetime
from baselayer.app import models
from baselayer.app.config import load_config
from baselayer.app.test_util import ( # noqa: F401
driver,
set_server_url,
)
from skyportal.tests.fixtures import T... | [
"skyportal.models.User",
"skyportal.models.DBSession.query",
"pytest.fixture",
"skyportal.tests.fixtures.InstrumentFactory",
"baselayer.app.models.init_db",
"skyportal.tests.fixtures.ObservingRunFactory",
"astroplan.download_IERS_A",
"astroplan.utils.IERS_A_in_cache",
"baselayer.app.models.Role.quer... | [((911, 965), 'baselayer.app.test_util.set_server_url', 'set_server_url', (['f"""http://localhost:{cfg[\'ports.app\']}"""'], {}), '(f"http://localhost:{cfg[\'ports.app\']}")\n', (925, 965), False, 'from baselayer.app.test_util import driver, set_server_url\n'), ((1018, 1051), 'baselayer.app.models.init_db', 'models.ini... |
from setuptools import setup, find_packages
import crisscross.metadata
with open("README.md", "r") as f:
long_description = f.read()
setup(
name='crisscross',
version=crisscross.metadata.version,
author='pnlng',
description='',
long_description=long_description,
long_description_content_... | [
"setuptools.find_packages"
] | [((637, 652), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (650, 652), False, 'from setuptools import setup, find_packages\n')] |
from deepproblog.utils import check_path
template = """
[Default]
batch_size = {0}
infoloss = {1}
name = poker_batch_{0}_infoloss_{1}
"""
i = 0
check_path("parameter_cfg/0.cfg")
for batch_size in [10, 25, 50, 100]:
for infoloss in [0, 0.5, 1.0, 2.0, 4.0]:
with open("parameter_cfg/{}.cfg".format(i), "w") ... | [
"deepproblog.utils.check_path"
] | [((146, 179), 'deepproblog.utils.check_path', 'check_path', (['"""parameter_cfg/0.cfg"""'], {}), "('parameter_cfg/0.cfg')\n", (156, 179), False, 'from deepproblog.utils import check_path\n'), ((517, 547), 'deepproblog.utils.check_path', 'check_path', (['"""experiment/0.cfg"""'], {}), "('experiment/0.cfg')\n", (527, 547... |
# -*- coding:utf-8 -*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import ast
import json
import math
import os
import six
import numpy as np
import paddle.fluid as fluid
from paddle.fluid.core import PaddleTensor, AnalysisConfig, create... | [
"os.path.exists",
"paddle.fluid.io.load_inference_model",
"paddlehub.module.module.moduleinfo",
"simnet_bow.processor.postprocess",
"argparse.ArgumentParser",
"simnet_bow.processor.preprocess",
"os.path.join",
"paddle.fluid.CPUPlace",
"paddlehub.io.parser.txt_parser.parse",
"simnet_bow.processor.l... | [((821, 1023), 'paddlehub.module.module.moduleinfo', 'moduleinfo', ([], {'name': '"""simnet_bow"""', 'version': '"""1.1.0"""', 'summary': '"""Baidu\'s open-source similarity network model based on bow_pairwise."""', 'author': '"""baidu-nlp"""', 'author_email': '""""""', 'type': '"""nlp/sentiment_analysis"""'}), '(name=... |
'''
parse out all the domains from various txt based sink lists
'''
from typing import List
import validators
class GeneralParser:
def __init__(self, response_list: List, debug: bool=None):
self.response_list = response_list
self.sink_list = []
self.debug = debug
def parse(self) -> Lis... | [
"validators.domain"
] | [((1216, 1239), 'validators.domain', 'validators.domain', (['item'], {}), '(item)\n', (1233, 1239), False, 'import validators\n')] |
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 8 20:13:52 2019
@author: Wei-Hsiang, Shen
"""
import tensorflow as tf
from tensorflow.keras import layers
def downsample(filters, size, apply_batchnorm=True):
result = tf.keras.Sequential()
result.add(layers.Conv2D(filters, size, strides=2, padding='same', use... | [
"tensorflow.keras.layers.Input",
"tensorflow.keras.layers.Conv2D",
"tensorflow.keras.layers.Conv2DTranspose",
"tensorflow.keras.layers.Concatenate",
"tensorflow.keras.Sequential",
"tensorflow.keras.layers.ReLU",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.LeakyReLU",
"tensorflow.kera... | [((224, 245), 'tensorflow.keras.Sequential', 'tf.keras.Sequential', ([], {}), '()\n', (243, 245), True, 'import tensorflow as tf\n'), ((526, 547), 'tensorflow.keras.Sequential', 'tf.keras.Sequential', ([], {}), '()\n', (545, 547), True, 'import tensorflow as tf\n'), ((834, 876), 'tensorflow.keras.layers.Input', 'tf.ker... |
from itertools import combinations
import numpy as np
import utility
def sol2(vet1, indice, vet_in):
out = []
while indice >= 1:
# converto in lista la combinations
vet2 = list(combinations(vet1, indice))
for riga in vet2:
# trasformo il vettore in input in un array
... | [
"itertools.combinations",
"numpy.array"
] | [((203, 229), 'itertools.combinations', 'combinations', (['vet1', 'indice'], {}), '(vet1, indice)\n', (215, 229), False, 'from itertools import combinations\n'), ((331, 345), 'numpy.array', 'np.array', (['riga'], {}), '(riga)\n', (339, 345), True, 'import numpy as np\n')] |
# -*- coding: utf-8 -*-
'''
Data class for accessing data for raw data
'''
from mlab_api.data.table_config import get_table_config
from mlab_api.data.base_data import Data
import mlab_api.data.bigtable_utils as bt
class RawData(Data):
'''
Pull out some raw data
'''
def get_raw_test_results(self):
... | [
"mlab_api.data.table_config.get_table_config"
] | [((431, 485), 'mlab_api.data.table_config.get_table_config', 'get_table_config', (['self.table_configs', 'None', 'table_name'], {}), '(self.table_configs, None, table_name)\n', (447, 485), False, 'from mlab_api.data.table_config import get_table_config\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from ascii_art import Bar
def test_bar():
data = {
"cats": 6,
"ferrets": 15,
"dogs": 2,
}
bar = Bar(data, bar_char="=", width=20, sort=True)
expected_output = '\n'.join(
[
'',
'ferrets | ============... | [
"ascii_art.Bar"
] | [((181, 225), 'ascii_art.Bar', 'Bar', (['data'], {'bar_char': '"""="""', 'width': '(20)', 'sort': '(True)'}), "(data, bar_char='=', width=20, sort=True)\n", (184, 225), False, 'from ascii_art import Bar\n')] |
import argparse
from GeneralTools.architectures import get_mnist_architectures, cifar_default
def parse_run_args():
parser = argparse.ArgumentParser()
parser.add_argument('--filename', '-file', type=str, default=None)
parser.add_argument('--dataset', '-data', type=str, default='mnist')
parser.add_argument('... | [
"GeneralTools.architectures.cifar_default",
"argparse.ArgumentParser"
] | [((129, 154), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (152, 154), False, 'import argparse\n'), ((5308, 5328), 'GeneralTools.architectures.cifar_default', 'cifar_default', (['d_enc'], {}), '(d_enc)\n', (5321, 5328), False, 'from GeneralTools.architectures import get_mnist_architectures, c... |
""" Schema to represent a knowledge base to build models of eukaryotes
:Author: <NAME> <<EMAIL>>
:Date: 2018-09-10
:Copyright: 2018, Karr Lab
:License: MIT
"""
from wc_utils.util import chem
import enum
import obj_model
from wc_kb import core
#####################
#####################
# Enumeration classes
class ... | [
"obj_model.StringAttribute",
"obj_model.ManyToManyAttribute",
"wc_utils.util.chem.EmpiricalFormula",
"obj_model.ManyToOneAttribute",
"obj_model.LongStringAttribute",
"wc_kb.core.DatabaseReferenceAttribute",
"obj_model.EnumAttribute",
"obj_model.PositiveIntegerAttribute",
"obj_model.OneToOneAttribute... | [((1052, 1079), 'obj_model.StringAttribute', 'obj_model.StringAttribute', ([], {}), '()\n', (1077, 1079), False, 'import obj_model\n'), ((1091, 1129), 'obj_model.EnumAttribute', 'obj_model.EnumAttribute', (['core.GeneType'], {}), '(core.GeneType)\n', (1114, 1129), False, 'import obj_model\n'), ((2733, 2779), 'obj_model... |
#!/usr/bin/python3
import operator
import sys
import json
import os
sys.path.append(os.getcwd())
sys.path.append("..")
sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../"))
import log
import log.logger
import traceback
import datetime
import sqlalchemy
import stmanage
import requests
import r... | [
"dataproof.dataproof.wallets.update_wallet",
"dataproof.dataproof.wallets",
"stmanage.get_exchang_chains",
"sys.exit",
"sys.path.append",
"comm.parseargs.parseargs",
"stmanage.get_libra_nodes",
"log.logger.getLogger",
"stmanage.get_receiver_address_list",
"stmanage.set_conf_env",
"stmanage.get_c... | [((97, 118), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (112, 118), False, 'import sys\n'), ((1262, 1288), 'log.logger.getLogger', 'log.logger.getLogger', (['name'], {}), '(name)\n', (1282, 1288), False, 'import log\n'), ((84, 95), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (93, 95), False, ... |
import subprocess
import sys
def install(package):
subprocess.check_call([sys.executable, "-m", "pip", "install", bs4])
import requests
from bs4 import BeautifulSoup
with open('simple.html') as html_file: # parses html file
soup = BeautifulSoup(html_file, 'lxml') #
#
# print(soup.prettify()) ... | [
"bs4.BeautifulSoup",
"subprocess.check_call"
] | [((57, 125), 'subprocess.check_call', 'subprocess.check_call', (["[sys.executable, '-m', 'pip', 'install', bs4]"], {}), "([sys.executable, '-m', 'pip', 'install', bs4])\n", (78, 125), False, 'import subprocess\n'), ((254, 286), 'bs4.BeautifulSoup', 'BeautifulSoup', (['html_file', '"""lxml"""'], {}), "(html_file, 'lxml'... |
#!/usr/bin/env python2
# coding: utf-8
"""Tester for documentation."""
import unittest
import doctest
import os
import glob
SNIPPET_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "libtriton", "bindings", "python", "objects")
class TestDoc(unittest.TestCase):
"""Holder to run examples as tests."""
fo... | [
"os.path.dirname",
"os.path.join",
"os.path.basename",
"doctest.testfile"
] | [((152, 177), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (167, 177), False, 'import os\n'), ((357, 391), 'os.path.join', 'os.path.join', (['SNIPPET_DIR', '"""*.cpp"""'], {}), "(SNIPPET_DIR, '*.cpp')\n", (369, 391), False, 'import os\n'), ((520, 573), 'doctest.testfile', 'doctest.testfile'... |
from flask import (
Blueprint, current_app, flash, g, redirect, render_template, request, url_for, send_from_directory
)
import os
import io
import webbrowser
import shutil
from werkzeug.exceptions import abort
from werkzeug.utils import secure_filename
from flaskr.auth import login_required
from flaskr.db import g... | [
"flask.render_template",
"os.path.exists",
"flask.send_from_directory",
"flask.flash",
"os.makedirs",
"hashlib.md5",
"os.path.join",
"flask.url_for",
"os.remove",
"werkzeug.exceptions.abort",
"flask.Blueprint",
"flaskr.db.get_db"
] | [((347, 377), 'flask.Blueprint', 'Blueprint', (['"""myfiles"""', '__name__'], {}), "('myfiles', __name__)\n", (356, 377), False, 'from flask import Blueprint, current_app, flash, g, redirect, render_template, request, url_for, send_from_directory\n'), ((596, 604), 'flaskr.db.get_db', 'get_db', ([], {}), '()\n', (602, 6... |
from threading import Lock
from PyQt5.Qt import QImage
from PyQt5.Qt import QIcon
from PyQt5.Qt import QStyle
from PyQt5.Qt import Qt
from PyQt5.Qt import QUrl
from PyQt5.Qt import QBuffer
from PyQt5.Qt import QByteArray
from PyQt5.Qt import QIODevice
from PyQt5.Qt import QDateTime
from PyQt5.Qt import QPixmap
from PyQ... | [
"PyQt5.Qt.QImage",
"mc.common.globalvars.gVar.executor.submit",
"PyQt5.Qt.pyqtProperty",
"PyQt5.Qt.QBuffer",
"threading.Lock",
"PyQt5.Qt.QIcon.fromTheme",
"PyQt5.Qt.QApplication.style",
"mc.common.models.HistoryDbModel.select",
"mc.common.models.IconsDbModel.delete",
"mc.common.models.IconsDbModel... | [((2342, 2393), 'PyQt5.Qt.pyqtProperty', 'pyqtProperty', (['QIcon', '_bookmarkIcon', 'setBookmarkIcon'], {}), '(QIcon, _bookmarkIcon, setBookmarkIcon)\n', (2354, 2393), False, 'from PyQt5.Qt import pyqtProperty\n'), ((958, 966), 'PyQt5.Qt.QImage', 'QImage', ([], {}), '()\n', (964, 966), False, 'from PyQt5.Qt import QIm... |
import requests
texas_woeid = "2512937"
def run():
conn = requests.get("https://www.metaweather.com/api/location/{0}/".format(texas_woeid)).json()
print(conn)
bbc_weather = conn["consolidated_weather"][0]["weather_state_name"]
temp = conn["consolidated_weather"]
logger.info("consolidate weather"... | [
"util.logger.init_logger",
"util.logger.get_logger",
"dotenv.load_dotenv"
] | [((419, 465), 'dotenv.load_dotenv', 'load_dotenv', (['"""env_files/american_junction.env"""'], {}), "('env_files/american_junction.env')\n", (430, 465), False, 'from dotenv import load_dotenv\n'), ((552, 565), 'util.logger.init_logger', 'init_logger', ([], {}), '()\n', (563, 565), False, 'from util.logger import init_l... |
"""pysat URL Configuration for School.Create
"""
from django.urls import path
from utils.views import view_maker
from utils.params import ParamType
from utils.permission import ActionType
from school.views import theme
urlpatterns = [
path('create', view_maker(theme.create_theme, 'POST', [
ParamType.Scho... | [
"utils.views.view_maker"
] | [((257, 442), 'utils.views.view_maker', 'view_maker', (['theme.create_theme', '"""POST"""', '[ParamType.SchoolIdWithDefault, ParamType.ThemeName, ParamType.\n ThemeDescription, ParamType.ThemeDeadline]'], {'action': 'ActionType.ThemeCreate'}), "(theme.create_theme, 'POST', [ParamType.SchoolIdWithDefault,\n ParamT... |
"""Imports"""
import json
import pytest
import demistomock as demisto
from netaddr import IPAddress
IOC_RES_LEN = 38
'''Tests'''
@pytest.mark.helper_commands
class TestHelperFunctions:
@pytest.mark.get_outbound_ioc_values
def test_get_outbound_ioc_values_1(self, mocker):
"""Test on_demand"""
... | [
"ExportIndicators.create_values_for_returned_dict",
"json.loads",
"ExportIndicators.list_to_str",
"ExportIndicators.ips_to_ranges",
"ExportIndicators.find_indicators_with_limit",
"ExportIndicators.panos_url_formatting",
"ExportIndicators.create_proxysg_out_format",
"netaddr.IPAddress",
"ExportIndica... | [((30730, 30772), 'ExportIndicators.ips_to_ranges', 'ips_to_ranges', (['ip_list', 'COLLAPSE_TO_RANGES'], {}), '(ip_list, COLLAPSE_TO_RANGES)\n', (30743, 30772), False, 'from ExportIndicators import ips_to_ranges, COLLAPSE_TO_CIDR\n'), ((31412, 31452), 'ExportIndicators.ips_to_ranges', 'ips_to_ranges', (['ip_list', 'COL... |
from pages.administration_page import AdminPage
from pages.course_page import CreateCoursePage
from pages.login_page import LoginPage
from pages.profile_page import ProfilePage
class Application:
def __init__(self, driver, url):
self.driver = driver
self.url = url
self.login = LoginPage(se... | [
"pages.administration_page.AdminPage",
"pages.profile_page.ProfilePage",
"pages.login_page.LoginPage",
"pages.course_page.CreateCoursePage"
] | [((308, 323), 'pages.login_page.LoginPage', 'LoginPage', (['self'], {}), '(self)\n', (317, 323), False, 'from pages.login_page import LoginPage\n'), ((347, 364), 'pages.profile_page.ProfilePage', 'ProfilePage', (['self'], {}), '(self)\n', (358, 364), False, 'from pages.profile_page import ProfilePage\n'), ((386, 401), ... |
# For more details, see
# http://docs.sqlalchemy.org/en/latest/orm/tutorial.html#declare-a-mapping
from anthill.framework.db import db
from anthill.framework.utils import timezone
from anthill.framework.utils.translation import translate as _
from anthill.framework.utils.asynchronous import as_future, thread_pool_exec ... | [
"anthill.framework.utils.translation.translate",
"anthill.framework.utils.asynchronous.thread_pool_exec",
"anthill.framework.db.db.Column",
"sqlalchemy.orm.validates",
"anthill.framework.utils.timezone.now",
"anthill.framework.db.db.String",
"re.sub",
"anthill.framework.utils.crypto.get_random_string"... | [((826, 851), 're.sub', 're.sub', (['"""[-\\\\s]"""', '""""""', 'key'], {}), "('[-\\\\s]', '', key)\n", (832, 851), False, 'import re\n'), ((971, 1030), 'anthill.framework.db.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)', 'autoincrement': '(True)'}), '(db.Integer, primary_key=True, autoincrement=Tr... |
"""
Tests for Github Actions Django Modernizer Script
"""
import os
import shutil
from os.path import dirname, basename, join
from edx_repo_tools.codemods.django3 import GithubCIDjangoModernizer
from edx_repo_tools.utils import YamlLoader
def setup_local_copy(filepath, tmpdir):
current_directory = dirname(__file... | [
"edx_repo_tools.codemods.django3.GithubCIDjangoModernizer",
"edx_repo_tools.utils.YamlLoader",
"shutil.copy2",
"os.path.join",
"os.path.dirname",
"os.path.basename"
] | [((306, 323), 'os.path.dirname', 'dirname', (['__file__'], {}), '(__file__)\n', (313, 323), False, 'from os.path import dirname, basename, join\n'), ((341, 374), 'os.path.join', 'join', (['current_directory', 'filepath'], {}), '(current_directory, filepath)\n', (345, 374), False, 'from os.path import dirname, basename,... |
import winrm
import os
print('\n********************************\n')
print(os.environ['winrm_endpoint'])
print(os.environ['domain_username'])
print('\n********************************\n')
s = winrm.Session(os.environ['winrm_endpoint'], auth=(os.environ['domain_username'], os.environ['domain_password']), transport='nt... | [
"winrm.Session"
] | [((194, 329), 'winrm.Session', 'winrm.Session', (["os.environ['winrm_endpoint']"], {'auth': "(os.environ['domain_username'], os.environ['domain_password'])", 'transport': '"""ntlm"""'}), "(os.environ['winrm_endpoint'], auth=(os.environ[\n 'domain_username'], os.environ['domain_password']), transport='ntlm')\n", (207... |
import os
import pytest
import taichi as ti
from taichi import approx
def run_mpm88_test():
dim = 2
N = 64
n_particles = N * N
n_grid = 128
dx = 1 / n_grid
inv_dx = 1 / dx
dt = 2.0e-4
p_vol = (dx * 0.5)**2
p_rho = 1
p_mass = p_vol * p_rho
E = 400
x = ti.Vector.field(... | [
"taichi.Vector.zero",
"taichi.test",
"taichi.ndarray",
"os.getenv",
"taichi.Matrix.ndarray",
"taichi.approx",
"taichi.Matrix",
"taichi.Vector.field",
"taichi.field",
"numpy.zeros",
"taichi.Matrix.zero",
"taichi.Vector",
"taichi.any_arr",
"taichi.Vector.ndarray",
"taichi.Matrix.field"
] | [((3540, 3549), 'taichi.test', 'ti.test', ([], {}), '()\n', (3547, 3549), True, 'import taichi as ti\n'), ((3882, 3959), 'taichi.test', 'ti.test', ([], {'require': 'ti.extension.async_mode', 'exclude': '[ti.metal]', 'async_mode': '(True)'}), '(require=ti.extension.async_mode, exclude=[ti.metal], async_mode=True)\n', (3... |
import os
class BaseConfig:
DATABASE_URI = ''
REDIS_HOST = ''
REDIS_PORT = 0
class DevelopmentConfig(BaseConfig):
DATABASE_SERVER = 'postgresql+asyncpg://sapl@127.0.0.1:5432'
DATABASE_NAME = 'sapl'
REDIS_HOST = '127.0.0.1'
REDIS_PORT = 16379
class ProductionConfig(BaseConfig):
DATA... | [
"os.getenv"
] | [((761, 791), 'os.getenv', 'os.getenv', (['"""SAPL_CONFIGRATION"""'], {}), "('SAPL_CONFIGRATION')\n", (770, 791), False, 'import os\n')] |
"""
Image manipulation.
This module defines functions which work on sanpera_ ``Image`` objects.
.. _sanpera: https://pypi.python.org/pypi/sanpera
"""
from __future__ import division
from sanpera.image import Image
from sanpera import geometry
from libweasyl.exceptions import ThumbnailingError
COVER_SIZE = 1024, ... | [
"sanpera.image.Image",
"sanpera.geometry.Rectangle",
"libweasyl.exceptions.ThumbnailingError"
] | [((2186, 2193), 'sanpera.image.Image', 'Image', ([], {}), '()\n', (2191, 2193), False, 'from sanpera.image import Image\n'), ((4733, 4797), 'sanpera.geometry.Rectangle', 'geometry.Rectangle', (['border', '(0)', '(border + width)', 'image.size.height'], {}), '(border, 0, border + width, image.size.height)\n', (4751, 479... |
"""
Data access functions
---------------------
"""
from __future__ import absolute_import
from os.path import join as pjoin, basename, dirname
import subprocess
import tempfile
import logging
import numpy as np
import h5py
import rasterio
from rasterio.crs import CRS
from rasterio.warp import reproject
from rasterio... | [
"numpy.uint8",
"tempfile.TemporaryDirectory",
"rasterio.open",
"rasterio.band",
"rasterio.warp.reproject",
"wagl.geobox.GriddedGeoBox",
"os.path.dirname",
"numpy.zeros",
"wagl.geobox.GriddedGeoBox.from_dataset",
"numpy.empty",
"wagl.tiling.generate_tiles",
"os.path.basename",
"logging.error"... | [((2564, 2594), 'numpy.empty', 'np.empty', (['stack_shape', 'a.dtype'], {}), '(stack_shape, a.dtype)\n', (2572, 2594), True, 'import numpy as np\n'), ((13165, 13259), 'wagl.geobox.GriddedGeoBox', 'GriddedGeoBox', ([], {'shape': 'subs.shape', 'origin': '(ul_x, ul_y)', 'pixelsize': 'geobox.pixelsize', 'crs': 'prj'}), '(s... |
"""
Copyright BOOSTRY Co., Ltd.
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 writing,
software distr... | [
"app.model.blockchain.IbetShareContract",
"pytz.timezone",
"unittest.mock.call",
"app.model.db.Token",
"app.model.db.AdditionalTokenInfo",
"tests.account_config.config_eth_account",
"unittest.mock.patch"
] | [((991, 1003), 'pytz.timezone', 'timezone', (['TZ'], {}), '(TZ)\n', (999, 1003), False, 'from pytz import timezone\n'), ((1457, 1519), 'unittest.mock.patch', 'mock.patch', (['"""app.model.blockchain.token.IbetShareContract.get"""'], {}), "('app.model.blockchain.token.IbetShareContract.get')\n", (1467, 1519), False, 'fr... |
#!/usr/bin/env python
from utils import utils, inspector
from bs4 import BeautifulSoup
from datetime import datetime
import re
import logging
# oldest year: 1979
def run(options):
crawl_index(SEMIANNUAL_REPORTS_URL, options)
crawl_index(AUDIT_REPORTS_URL, options, True)
crawl_index(PEER_REVIEW_REPORTS_URL, opt... | [
"utils.inspector.save_report",
"re.compile",
"datetime.datetime.strptime",
"utils.utils.run",
"logging.info",
"bs4.BeautifulSoup",
"utils.inspector.year_range",
"datetime.datetime.strftime",
"utils.utils.download"
] | [((4050, 4097), 're.compile', 're.compile', (['"""LinkServID=([-0-9A-F]*)&showMeta="""'], {}), "('LinkServID=([-0-9A-F]*)&showMeta=')\n", (4060, 4097), False, 'import re\n'), ((4106, 4253), 're.compile', 're.compile', (['"""javascript:newWin=window.open\\\\(\'/(\\\\?LinkServID=([-0-9A-F]*)&showMeta=0)\',\'NewWin[0-9]*\... |
from trip_planner.client import TripPlanner
MOCK_BART_STATION_LIST = {
'stations': {
'station': [
{
"name": "West Oakland",
"abbr": "WOAK",
"gtfs_latitude": "37.804872",
"gtfs_longitude": "-122.295140",
"address": "... | [
"trip_planner.client.TripPlanner"
] | [((5482, 5497), 'trip_planner.client.TripPlanner', 'TripPlanner', (['""""""'], {}), "('')\n", (5493, 5497), False, 'from trip_planner.client import TripPlanner\n'), ((5985, 6000), 'trip_planner.client.TripPlanner', 'TripPlanner', (['""""""'], {}), "('')\n", (5996, 6000), False, 'from trip_planner.client import TripPlan... |
import random
import torch as t
from py.data.XYDataset import XYDataset
from py.util.Config import dtype, device, en_stops
from nltk.tokenize import word_tokenize
import numpy as np
def genericDescriptionClassifier(description, embedding):
some_generic_descriptions = ['work', 'success', 'test', 'filter',
... | [
"random.choice",
"torch.as_tensor",
"torch.load",
"nltk.tokenize.word_tokenize",
"torch.save",
"torch.empty",
"torch.rand"
] | [((4270, 4327), 'torch.as_tensor', 't.as_tensor', (['self.body_tensors'], {'dtype': 'dtype', 'device': '"""cpu"""'}), "(self.body_tensors, dtype=dtype, device='cpu')\n", (4281, 4327), True, 'import torch as t\n'), ((4376, 4440), 'torch.as_tensor', 't.as_tensor', (['self.description_tensors'], {'dtype': 'dtype', 'device... |
import argparse
import json
import logging
from bar_chart import create_bar_chart
logger = logging.getLogger(__name__)
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('mode', metavar='M', type=str... | [
"logging.getLogger",
"bar_chart.create_bar_chart",
"argparse.ArgumentParser",
"logging.basicConfig"
] | [((92, 119), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (109, 119), False, 'import logging\n'), ((152, 191), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (171, 191), False, 'import logging\n'), ((205, 266), 'argparse.Argument... |
from time import sleep
n1 = int(input('Primeiro número:'))
n2 = int(input('Segundo número'))
opcao = 0
while opcao != 5:
print(''' [ 1 ] Somar
[ 2 ] Multiplicar
[ 3 ] Maior
[ 4 ] Novos números
[ 5 ] Sair do programa''')
opcao = int(input('\033[33m Qual é a sua opção? \033[m'))
if opcao ==... | [
"time.sleep"
] | [((1084, 1092), 'time.sleep', 'sleep', (['(2)'], {}), '(2)\n', (1089, 1092), False, 'from time import sleep\n')] |
from brownie import *
import json
def main():
thisNetwork = network.show_active()
if thisNetwork == "development":
acct = accounts[0]
# configFile = open('./scripts/contractInteraction/testnet_contracts.json')
elif thisNetwork == "testnet" or thisNetwork == "rsk-mainnet":
acct = a... | [
"json.load"
] | [((670, 691), 'json.load', 'json.load', (['configFile'], {}), '(configFile)\n', (679, 691), False, 'import json\n')] |
from elasticsearch import Elasticsearch
class UserModel:
elast = Elasticsearch('localhost', port=9200)
elast_idx = "gordologo-users"
def __init__(self, _id, username, email, password_hash):
self.id = _id
self.username = username
self.email = email
self.password_hash = pass... | [
"elasticsearch.Elasticsearch"
] | [((71, 108), 'elasticsearch.Elasticsearch', 'Elasticsearch', (['"""localhost"""'], {'port': '(9200)'}), "('localhost', port=9200)\n", (84, 108), False, 'from elasticsearch import Elasticsearch\n')] |
import bpy
import os
from collections import defaultdict
from Utility.Logging_Extension import logger
# http://blender.stackexchange.com/questions/8936/does-switching-from-blender-render-to-cycles-mess-things-up
# * All matierals in cycles use nodes (even if you set up the material in the Properties panel, it will c... | [
"bpy.path.abspath",
"Utility.Logging_Extension.logger.warning",
"Utility.Logging_Extension.logger.info",
"bpy.data.materials.new",
"collections.defaultdict",
"bpy.data.images.load",
"Utility.Logging_Extension.logger.debug",
"Utility.Logging_Extension.logger.vinfo"
] | [((1715, 1750), 'Utility.Logging_Extension.logger.info', 'logger.info', (['"""rearrange_nodes: ..."""'], {}), "('rearrange_nodes: ...')\n", (1726, 1750), False, 'from Utility.Logging_Extension import logger\n'), ((2194, 2232), 'Utility.Logging_Extension.logger.info', 'logger.info', (['"""create_viewer_node: ..."""'], {... |
# coding=utf-8
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# 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/lice... | [
"datasets.BuilderConfig",
"os.path.join",
"datasets.DatasetInfo",
"datasets.Version",
"datasets.Value",
"csv.reader"
] | [((2099, 2124), 'datasets.Version', 'datasets.Version', (['"""1.1.3"""'], {}), "('1.1.3')\n", (2115, 2124), False, 'import datasets\n'), ((2157, 2256), 'datasets.BuilderConfig', 'datasets.BuilderConfig', ([], {'name': '"""gutenberg"""', 'description': '"""Data pulled from the Gutenberg project"""'}), "(name='gutenberg'... |
"""Tests for the :mod:`campy.datastructures.shuffle` module."""
# These reference shuffled values are being generated by Python running
# 3.7.2 (default, Dec 27 2018, 07:35:06) \n[Clang 10.0.0 (clang-1000.11.45.5)]
# on macOS 10.14.2
from campy.datastructures.shuffle import shuffle
import random
def test_shuffle_li... | [
"random.seed",
"campy.datastructures.shuffle.shuffle"
] | [((330, 345), 'random.seed', 'random.seed', (['(41)'], {}), '(41)\n', (341, 345), False, 'import random\n'), ((439, 454), 'random.seed', 'random.seed', (['(41)'], {}), '(41)\n', (450, 454), False, 'import random\n'), ((549, 564), 'random.seed', 'random.seed', (['(41)'], {}), '(41)\n', (560, 564), False, 'import random\... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import argparse
import cv2
parser = argparse.ArgumentParser()
parser.add_argument('--path', default='../data/Lena.png', help='Image path.')
parser.add_argument('--out_png', default='../data/Lena_compressed.png',
help='Output image path for lossless re... | [
"cv2.imwrite",
"cv2.imread",
"argparse.ArgumentParser"
] | [((85, 110), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (108, 110), False, 'import argparse\n'), ((499, 522), 'cv2.imread', 'cv2.imread', (['params.path'], {}), '(params.path)\n', (509, 522), False, 'import cv2\n'), ((599, 665), 'cv2.imwrite', 'cv2.imwrite', (['params.out_png', 'img', '[cv2... |
"""
rename generated sync asdf file based on the cmt solution files. (relocation)
"""
import subprocess
import click
import obspy
from os.path import join
from glob import glob
def rename_single(mapper, filepath):
# filename = filepath.split("/")[-1]
# filename_new = mapper[filename]
# filepath_new = join... | [
"click.option",
"os.path.join",
"obspy.read_events",
"subprocess.call",
"click.command"
] | [((1084, 1099), 'click.command', 'click.command', ([], {}), '()\n', (1097, 1099), False, 'import click\n'), ((1101, 1178), 'click.option', 'click.option', (['"""--cmts_dir"""'], {'required': '(True)', 'type': 'str', 'help': '"""the cmt directory"""'}), "('--cmts_dir', required=True, type=str, help='the cmt directory')\... |
#!/usr/bin/env python
"""Executable for generating point clouds from RGB-D frames."""
import argparse
import cv2
import logging as log
from tqdm import tqdm
from clubs_dataset_tools.filesystem_tools import (
read_images, find_files_with_extension_in_folder, find_all_folders,
find_rgb_d_image_folders, compare_... | [
"logging.basicConfig",
"logging.debug",
"argparse.ArgumentParser",
"clubs_dataset_tools.filesystem_tools.compare_image_names",
"clubs_dataset_tools.filesystem_tools.create_stereo_point_cloud_folder",
"clubs_dataset_tools.filesystem_tools.create_point_cloud_folder",
"cv2.undistort",
"clubs_dataset_tool... | [((1556, 1624), 'clubs_dataset_tools.filesystem_tools.find_files_with_extension_in_folder', 'find_files_with_extension_in_folder', (['(scene_folder + sensor_folder[0])'], {}), '(scene_folder + sensor_folder[0])\n', (1591, 1624), False, 'from clubs_dataset_tools.filesystem_tools import read_images, find_files_with_exten... |
from A2C import Agent, Learner, envMaker, config, ray
from A2C.nets import AC_AtariHalf
from A2C.functions import seeder, trainSync, graphResults
from A2C.functions import NCPUS, expDir, saveConfig, Saver
from torch.utils.tensorboard import SummaryWriter
from math import ceil
EXP = "a2c"
NAME = "Seaquest-v0"
envmake ... | [
"torch.utils.tensorboard.SummaryWriter",
"math.ceil",
"A2C.functions.trainSync",
"A2C.ray.remote",
"A2C.Agent.remote",
"A2C.Learner.remote",
"A2C.envMaker",
"A2C.functions.saveConfig",
"A2C.functions.graphResults",
"A2C.ray.shutdown",
"A2C.functions.Saver",
"A2C.functions.seeder",
"A2C.ray.i... | [((322, 336), 'A2C.envMaker', 'envMaker', (['NAME'], {}), '(NAME)\n', (330, 336), False, 'from A2C import Agent, Learner, envMaker, config, ray\n'), ((614, 636), 'math.ceil', 'ceil', (['(28 / (NCPUS - 1))'], {}), '(28 / (NCPUS - 1))\n', (618, 636), False, 'from math import ceil\n'), ((734, 751), 'A2C.functions.expDir',... |
"""Run the Celery jobs."""
import os
from app import celery, create_app
import app.tasks
flask_app = create_app(os.getenv('FLASK_CONFIG') or 'default')
flask_app.app_context().push()
| [
"os.getenv"
] | [((113, 138), 'os.getenv', 'os.getenv', (['"""FLASK_CONFIG"""'], {}), "('FLASK_CONFIG')\n", (122, 138), False, 'import os\n')] |
import random
import math
class RNA(object):
def __init__(self,
entradas=3,
arquitectura=[2, 1],
alpha=0.5,
aleatoria=None,
permitir_logs=False):
self.red = []
self.arquitectura = arquitectura
... | [
"random.uniform",
"math.sqrt",
"math.exp"
] | [((3484, 3514), 'math.sqrt', 'math.sqrt', (['(buffer / n_ejemplos)'], {}), '(buffer / n_ejemplos)\n', (3493, 3514), False, 'import math\n'), ((612, 633), 'random.uniform', 'random.uniform', (['(-1)', '(1)'], {}), '(-1, 1)\n', (626, 633), False, 'import random\n'), ((1506, 1520), 'math.exp', 'math.exp', (['(-raw)'], {})... |
"""
create a public archive at `--out`
"""
import os
import zipfile
from typing import IO
from argparse import ArgumentParser
from functools import lru_cache
import orjson
from loguru import logger
from sqlalchemy.orm import Session
from pol import sa
from pol.db.tables import (
ChiiPerson,
ChiiEpisode,
C... | [
"zipfile.ZipFile",
"argparse.ArgumentParser",
"loguru.logger.info",
"pol.db.tables.ChiiPerson.prsn_id.desc",
"loguru.logger.catch",
"pol.db.tables.ChiiSubject.subject_id.desc",
"pol.sa.sync_session_maker",
"os.path.abspath",
"pol.db.tables.ChiiCharacter.crt_id.desc",
"pol.api.v0.utils.get_career",... | [((492, 506), 'loguru.logger.catch', 'logger.catch', ([], {}), '()\n', (504, 506), False, 'from loguru import logger\n'), ((532, 548), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (546, 548), False, 'from argparse import ArgumentParser\n'), ((729, 752), 'pol.sa.sync_session_maker', 'sa.sync_session_ma... |
import datetime
def log_msg(msg):
now = datetime.datetime.now()
msg = '{} - {}'.format(now.strftime('%d/%m/%Y %H:%M:%S'), msg)
f = open('log/log-{}.txt'.format(now.strftime('%Y-%m-%d')), "a")
f.writelines(msg + '\n')
f.close()
print(msg, flush=True) | [
"datetime.datetime.now"
] | [((45, 68), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (66, 68), False, 'import datetime\n')] |
#!/usr/bin/env python
import ctypes
from flask import Flask, request, send_file
from PIL import ImageGrab
from StringIO import StringIO
# http://msdn.microsoft.com/en-us/library/windows/desktop/ms646260%28v=vs.85%29.aspx
MOUSEEVENTF_LEFTDOWN = 2
MOUSEEVENTF_LEFTUP = 4
app = Flask(__name__)
@app.route('/')
def index... | [
"StringIO.StringIO",
"flask.request.args.get",
"flask.Flask",
"PIL.ImageGrab.grab",
"flask.send_file"
] | [((277, 292), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (282, 292), False, 'from flask import Flask, request, send_file\n'), ((428, 444), 'PIL.ImageGrab.grab', 'ImageGrab.grab', ([], {}), '()\n', (442, 444), False, 'from PIL import ImageGrab\n'), ((455, 465), 'StringIO.StringIO', 'StringIO', ([], {}),... |
# Copyright 2014-present PlatformIO <<EMAIL>>
#
# 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... | [
"os.path.join",
"SCons.Script.DefaultEnvironment",
"SCons.Script.Default",
"SCons.Script.AlwaysBuild"
] | [((769, 789), 'SCons.Script.DefaultEnvironment', 'DefaultEnvironment', ([], {}), '()\n', (787, 789), False, 'from SCons.Script import COMMAND_LINE_TARGETS, AlwaysBuild, Builder, Default, DefaultEnvironment\n'), ((5485, 5509), 'SCons.Script.AlwaysBuild', 'AlwaysBuild', (['target_size'], {}), '(target_size)\n', (5496, 55... |
from fluxrgnn import dataloader, utils
from fluxrgnn.models import *
import torch
from torch.utils.data import random_split, Subset
from torch.optim import lr_scheduler
from torch_geometric.data import DataLoader, DataListLoader
from torch_geometric.utils import to_dense_adj
from omegaconf import DictConfig, OmegaConf
... | [
"torch.utils.data.ConcatDataset",
"torch.pow",
"torch.cuda.is_available",
"fluxrgnn.dataloader.load_dataset",
"numpy.arange",
"fluxrgnn.utils.finalize_results",
"fluxrgnn.utils.plot_training_curves",
"torch.autograd.set_detect_anomaly",
"numpy.ones",
"torch_geometric.utils.to_dense_adj",
"os.pat... | [((2464, 2500), 'torch.utils.data.ConcatDataset', 'torch.utils.data.ConcatDataset', (['data'], {}), '(data)\n', (2494, 2500), False, 'import torch\n'), ((3248, 3317), 'torch_geometric.data.DataLoader', 'DataLoader', (['train_data'], {'batch_size': 'cfg.model.batch_size', 'shuffle': '(True)'}), '(train_data, batch_size=... |
"""This module contains tools supporting the main application."""
import torch
import torchvision.transforms as transforms
from PIL import Image
from typing import Tuple
from doggofier.models import ResNet50, VGG16
def transform_image(image_path: str) -> torch.Tensor:
"""Prepares an image for inference by applyi... | [
"PIL.Image.open",
"torch.load",
"torch.exp",
"doggofier.models.VGG16",
"doggofier.models.ResNet50",
"torchvision.transforms.Normalize",
"torchvision.transforms.Resize",
"torchvision.transforms.ToTensor"
] | [((783, 805), 'PIL.Image.open', 'Image.open', (['image_path'], {}), '(image_path)\n', (793, 805), False, 'from PIL import Image\n'), ((1579, 1618), 'doggofier.models.ResNet50', 'ResNet50', (['num_classes'], {'pretrained': '(False)'}), '(num_classes, pretrained=False)\n', (1587, 1618), False, 'from doggofier.models impo... |
# Copyright (c) 2019, Adobe Inc. All rights reserved.
#
# This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
# 4.0 International Public License. To view a copy of this license, visit
# https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode.
# DWT code borrow from https://github.... | [
"pywt.Wavelet",
"torch.tensor",
"torch.cuda.is_available",
"torch.nn.Parameter",
"torch.nn.functional.pad",
"torch.zeros"
] | [((1530, 1557), 'pywt.Wavelet', 'pywt.Wavelet', (['self.wavename'], {}), '(self.wavename)\n', (1542, 1557), False, 'import pywt\n'), ((1577, 1605), 'torch.tensor', 'torch.tensor', (['wavelet.rec_lo'], {}), '(wavelet.rec_lo)\n', (1589, 1605), False, 'import torch\n'), ((1626, 1654), 'torch.tensor', 'torch.tensor', (['wa... |
"""
Copyright (C) 2013-2016 <NAME>.
Licensed under the Apache 2.0 License (see LICENSE file).
time_masks.py
~~~~~~~~~~~~~
Functions to pick timesteps from data given certain criteria.
"""
import pandas as pd
from . import time_funcs
def _get_array(data, var, tech, locations):
arr = data[var]
arr = arr.lo... | [
"pandas.Timedelta",
"pandas.TimeGrouper",
"pandas.date_range"
] | [((3496, 3526), 'pandas.TimeGrouper', 'pd.TimeGrouper', (['groupby_length'], {}), '(groupby_length)\n', (3510, 3526), True, 'import pandas as pd\n'), ((4542, 4586), 'pandas.date_range', 'pd.date_range', (['start_hour', 'day[0]'], {'freq': '"""1H"""'}), "(start_hour, day[0], freq='1H')\n", (4555, 4586), True, 'import pa... |
# -*- coding: utf-8 -*-
from app.core.dropin.base_i2c_dropin import BaseI2CDropIn
from logging import Logger
from prometheus_client import Gauge, Counter, metrics, Info, Enum
from typing import Optional, Dict
class DropIn(BaseI2CDropIn):
"""
Drop-in to use Adafruit's BME280 sensor using I2C.
"""
DEFA... | [
"prometheus_client.Gauge",
"busio.I2C",
"prometheus_client.Info",
"adafruit_bme280.Adafruit_BME280_I2C",
"prometheus_client.Enum",
"prometheus_client.Counter"
] | [((2590, 2729), 'prometheus_client.Enum', 'Enum', (["(self.DROP_IN_ID + '_drop_in_status')", '"""Current status of the drop-in"""', "['drop_in_name']"], {'states': "['starting', 'ready', 'measuring']"}), "(self.DROP_IN_ID + '_drop_in_status', 'Current status of the drop-in',\n ['drop_in_name'], states=['starting', '... |
from kivy.animation import Animation
from kivy.clock import Clock
from kivy.lang.builder import Builder
from kivy.properties import (
BooleanProperty,
ListProperty,
NumericProperty,
OptionProperty,
StringProperty,
)
from kivy.uix.boxlayout import BoxLayout
from kivymd.theming import ThemableBehavio... | [
"kivy.properties.NumericProperty",
"kivy.lang.builder.Builder.load_string",
"kivy.animation.Animation",
"kivy.properties.OptionProperty",
"kivy.properties.ListProperty",
"kivy.properties.StringProperty"
] | [((323, 1235), 'kivy.lang.builder.Builder.load_string', 'Builder.load_string', (['"""\n<AKCircularProgress>:\n\n canvas.before:\n Color:\n rgba: root.background_circle_color if root.background_circle_color else app.theme_cls.primary_light\n Line:\n circle: ( self.x+ self.width/2, ... |
"""Copyright (c) 2021 <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicen... | [
"percolate.framework.choice_input",
"percolate.framework.StreamInput",
"percolate.framework.ArrayOutput",
"percolate.framework.free_int_input",
"percolate.framework.int_input"
] | [((6141, 6173), 'percolate.framework.StreamInput', 'StreamInput', (['self', '"""input_array"""'], {}), "(self, 'input_array')\n", (6152, 6173), False, 'from percolate.framework import StreamInput\n'), ((6206, 6255), 'percolate.framework.free_int_input', 'free_int_input', (['self', '"""number_of_peaks"""', '(1)', '(2)',... |
from .DistributedMinigameAI import *
from direct.distributed.ClockDelta import *
from direct.interval.IntervalGlobal import *
from direct.fsm import ClassicFSM
from direct.fsm import State
from direct.actor import Actor
from . import DivingGameGlobals
import random
import random
import types
class DistributedDivingGam... | [
"random.random",
"direct.fsm.State.State"
] | [((12091, 12106), 'random.random', 'random.random', ([], {}), '()\n', (12104, 12106), False, 'import random\n'), ((7323, 7338), 'random.random', 'random.random', ([], {}), '()\n', (7336, 7338), False, 'import random\n'), ((7365, 7380), 'random.random', 'random.random', ([], {}), '()\n', (7378, 7380), False, 'import ran... |
# Copyright 2015 Amazon.com, Inc. or its affiliates. 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. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file accompa... | [
"boto3.session.Session",
"os.makedirs",
"json.dump",
"os.path.join",
"tempfile.mkdtemp",
"shutil.rmtree",
"botocore.docs.bcdoc.restdoc.DocumentStructure",
"botocore.compat.OrderedDict",
"botocore.loaders.Loader"
] | [((920, 938), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (936, 938), False, 'import tempfile\n'), ((967, 1021), 'os.path.join', 'os.path.join', (['self.root_dir', '"""myservice"""', '"""2014-01-01"""'], {}), "(self.root_dir, 'myservice', '2014-01-01')\n", (979, 1021), False, 'import os\n'), ((1043, 1073)... |
# This file is Copyright 2019 Volatility Foundation and licensed under the Volatility Software License 1.0
# which is available at https://www.volatilityfoundation.org/license/vsl-v1.0
#
import hashlib
import json
import logging
import os
from typing import Set, Any, Dict
from volatility.framework import constants
v... | [
"logging.getLogger",
"os.path.exists",
"json.dumps",
"os.path.join",
"os.path.dirname",
"jsonschema.validate",
"json.load"
] | [((328, 355), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (345, 355), False, 'import logging\n'), ((386, 439), 'os.path.join', 'os.path.join', (['constants.CACHE_PATH', '"""valid_isf.cache"""'], {}), "(constants.CACHE_PATH, 'valid_isf.cache')\n", (398, 439), False, 'import os\n'), ((63... |
import FWCore.ParameterSet.Config as cms
siTrackerMultiRecHitUpdator = cms.ESProducer("SiTrackerMultiRecHitUpdatorESProducer",
ComponentName = cms.string('SiTrackerMultiRecHitUpdator'),
TTRHBuilder = cms.string('WithAngleAndTemplate'),
HitPropagator = cms.string('trackingRecHitPropagator'),
#AnnealingP... | [
"FWCore.ParameterSet.Config.string",
"FWCore.ParameterSet.Config.double",
"FWCore.ParameterSet.Config.bool",
"FWCore.ParameterSet.Config.vdouble"
] | [((148, 189), 'FWCore.ParameterSet.Config.string', 'cms.string', (['"""SiTrackerMultiRecHitUpdator"""'], {}), "('SiTrackerMultiRecHitUpdator')\n", (158, 189), True, 'import FWCore.ParameterSet.Config as cms\n'), ((209, 243), 'FWCore.ParameterSet.Config.string', 'cms.string', (['"""WithAngleAndTemplate"""'], {}), "('Wit... |
#!/usr/bin/env python3
#
# TLA+/TLC generator for parametric SetSndRcv example.
# See SetSndRcv.tla / SetSndRcv_NoFullDrop.tla / SetSndRcv_NoFullDropCard.tla for the description.
#
# <NAME>, 2020
import sys
import os
sys.path.append(os.path.dirname(sys.argv[0]) + "/../../scripts")
import genutils as g
def print_tla()... | [
"os.path.dirname",
"genutils.init"
] | [((1013, 1044), 'genutils.init', 'g.init', (['"""SetSndRcv"""', '"""TLA+/TLC"""'], {}), "('SetSndRcv', 'TLA+/TLC')\n", (1019, 1044), True, 'import genutils as g\n'), ((1069, 1114), 'genutils.init', 'g.init', (['"""SetSndRcv"""', '"""TLA+/TLC"""', '"""NoFullDrop"""'], {}), "('SetSndRcv', 'TLA+/TLC', 'NoFullDrop')\n", (1... |
import numpy as np
from typing import Callable
from .base_score import BaseScore
class BleiLaffertyScore(BaseScore):
"""
This score implements method described in 2009 paper
Blei, <NAME>., and <NAME>erty. "Topic models." Text Mining.
Chapman and Hall/CRC, 2009. 101-124.
At the core this score he... | [
"numpy.sum",
"numpy.log"
] | [((1537, 1559), 'numpy.log', 'np.log', (['(phi + blei_eps)'], {}), '(phi + blei_eps)\n', (1543, 1559), True, 'import numpy as np\n'), ((1580, 1603), 'numpy.sum', 'np.sum', (['log_phi'], {'axis': '(1)'}), '(log_phi, axis=1)\n', (1586, 1603), True, 'import numpy as np\n'), ((2180, 2229), 'numpy.sum', 'np.sum', (['modalit... |
#! /usr/bin/python
"""
This script generates markdown files for all the MAVLink message definition XML at:
https://github.com/mavlink/mavlink/tree/master/message_definitions/v1.0
The files can be imported into a gitbook to display the messages as HTML
The script runs on both Python2 and Python 3. The following li... | [
"os.path.exists",
"os.makedirs",
"lxml.etree.XSLT",
"lxml.etree.fromstring",
"re.sub",
"os.walk"
] | [((1019, 1042), 'lxml.etree.fromstring', 'ET.fromstring', (['xsl_file'], {}), '(xsl_file)\n', (1032, 1042), True, 'import lxml.etree as ET\n'), ((11669, 11710), 'os.walk', 'os.walk', (['xml_message_definitions_dir_name'], {}), '(xml_message_definitions_dir_name)\n', (11676, 11710), False, 'import os\n'), ((756, 787), '... |
import os
import sys
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
import numpy as np
from astropy.io import fits
# ------------------------------------------------------------
# Input
opacity = os.path.join(sys.argv[1], "")
# ------------------------------------------------------------
cou... | [
"os.listdir",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xlabel",
"numpy.size",
"os.path.join",
"matplotlib.pyplot.plot",
"numpy.linspace",
"numpy.zeros",
"astropy.io.fits.getdata",
"astropy.io.fits.open",
"matplotlib.pyplot.yscale",
"matplotlib.pyplot.xscale"... | [((222, 251), 'os.path.join', 'os.path.join', (['sys.argv[1]', '""""""'], {}), "(sys.argv[1], '')\n", (234, 251), False, 'import os\n'), ((344, 363), 'os.listdir', 'os.listdir', (['opacity'], {}), '(opacity)\n', (354, 363), False, 'import os\n'), ((533, 552), 'os.listdir', 'os.listdir', (['opacity'], {}), '(opacity)\n'... |
from feed.models import FeedGroup
import time
def create_feed_group(username, tag):
'''
By username and tag, creats a new group feed.
'''
group_id = get_feed_group_name(username, tag)
feed_group = FeedGroup(group_id=group_id, creator=username, tag=tag)
feed_group.save()
def get_feed_group_na... | [
"feed.models.FeedGroup",
"time.time"
] | [((219, 274), 'feed.models.FeedGroup', 'FeedGroup', ([], {'group_id': 'group_id', 'creator': 'username', 'tag': 'tag'}), '(group_id=group_id, creator=username, tag=tag)\n', (228, 274), False, 'from feed.models import FeedGroup\n'), ((463, 474), 'time.time', 'time.time', ([], {}), '()\n', (472, 474), False, 'import time... |
from setuptools import setup
with open("README.md") as f:
long_description = f.read()
setup(
name="prefixdate",
version="0.4.0",
description="Formatting utility for international postal addresses",
long_description=long_description,
long_description_content_type="text/markdown",
url="http... | [
"setuptools.setup"
] | [((93, 1032), 'setuptools.setup', 'setup', ([], {'name': '"""prefixdate"""', 'version': '"""0.4.0"""', 'description': '"""Formatting utility for international postal addresses"""', 'long_description': 'long_description', 'long_description_content_type': '"""text/markdown"""', 'url': '"""https://github.com/pudo/prefixda... |
from fabric.api import local, task
@task
def bower(command, args='', option=''):
"""
usage: fab bower:<command>, <args>, <option>
Execute bower commands.
See 'fab bower:help' for more information
"""
local('cd {{ project_name }} && bower {0} {1} {2}'.format(
command,
args,
... | [
"fabric.api.local"
] | [((1041, 1085), 'fabric.api.local', 'local', (['"""cd {{ project_name }} && yo newsapp"""'], {}), "('cd {{ project_name }} && yo newsapp')\n", (1046, 1085), False, 'from fabric.api import local, task\n')] |
import numpy as np
import pandas as pd
def sra(real, synth):
"""
SRA can be thought of as the (empirical) probability of a
comparison on the synthetic data being ”correct” (i.e. the same as
the comparison would be on the real data).
From "Measuring the quality of Synthetic data for use in competit... | [
"numpy.sum",
"numpy.array"
] | [((1060, 1093), 'numpy.sum', 'np.sum', (['(1 / (k * (k - 1)) * sum_I)'], {}), '(1 / (k * (k - 1)) * sum_I)\n', (1066, 1093), True, 'import numpy as np\n'), ((935, 949), 'numpy.array', 'np.array', (['None'], {}), '(None)\n', (943, 949), True, 'import numpy as np\n'), ((970, 984), 'numpy.array', 'np.array', (['None'], {}... |
"""catalog URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/2.0/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based... | [
"catalog.api.utils.status_code_view.get_status_code_view",
"django.conf.urls.include",
"catalog.api.views.health_views.HealthCheck.as_view",
"django.views.generic.RedirectView.as_view",
"rest_framework.routers.SimpleRouter",
"catalog.api.views.oauth2_views.CheckRates.as_view",
"django.urls.path"
] | [((2369, 2383), 'rest_framework.routers.SimpleRouter', 'SimpleRouter', ([], {}), '()\n', (2381, 2383), False, 'from rest_framework.routers import SimpleRouter\n'), ((2608, 2639), 'django.urls.path', 'path', (['"""admin/"""', 'admin.site.urls'], {}), "('admin/', admin.site.urls)\n", (2612, 2639), False, 'from django.url... |
# Generated by Django 3.1.10 on 2021-05-11 23:51
from django.conf import settings
import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
... | [
"django.db.migrations.swappable_dependency",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((258, 315), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (289, 315), False, 'from django.db import migrations, models\n'), ((492, 585), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)... |
# This contribution was made by: <NAME>
# Date: 12/15/2020
import logging
import re
import aiohttp
import discord
import discord.ext.commands as commands
import bot.bot_secrets as bot_secrets
import bot.extensions as ext
from bot.consts import Colors
from bot.messaging.events import Events
log = logging.getLogger(_... | [
"logging.getLogger",
"bot.extensions.command",
"bot.extensions.long_help",
"bot.extensions.example",
"bot.extensions.short_help",
"re.sub",
"discord.Embed",
"aiohttp.request"
] | [((301, 328), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (318, 328), False, 'import logging\n'), ((3055, 3068), 'bot.extensions.command', 'ext.command', ([], {}), '()\n', (3066, 3068), True, 'import bot.extensions as ext\n'), ((3074, 3138), 'bot.extensions.long_help', 'ext.long_help',... |
from pathlib import Path
import sys
import toml
from pdm.project import Project
from tox_pdm import (
tox_testenv_install_deps,
tox_testenv_create,
tox_runtest_pre,
tox_runenvreport,
)
def test_tox_install_deps(venv, action):
result = tox_testenv_install_deps(venv, action)
assert result is T... | [
"tox_pdm.tox_runenvreport",
"tox_pdm.tox_testenv_install_deps",
"tox_pdm.tox_runtest_pre",
"tox_pdm.tox_testenv_create",
"pdm.project.Project"
] | [((259, 297), 'tox_pdm.tox_testenv_install_deps', 'tox_testenv_install_deps', (['venv', 'action'], {}), '(venv, action)\n', (283, 297), False, 'from tox_pdm import tox_testenv_install_deps, tox_testenv_create, tox_runtest_pre, tox_runenvreport\n'), ((852, 890), 'tox_pdm.tox_testenv_install_deps', 'tox_testenv_install_d... |
"""
Script to test a model **on every epoch** that is serialised in the serialised
models' folder.
Usage:
test_several_seeds.py [--algos=ALGO]... [options]
Options:
-h --help Show this screen.
--has-GRU Does the processor utilise GRU unit? [default: False]
--poo... | [
"schema.Use",
"schema.validate",
"os.system",
"docopt.docopt",
"schema.And"
] | [((1846, 1861), 'docopt.docopt', 'docopt', (['__doc__'], {}), '(__doc__)\n', (1852, 1861), False, 'from docopt import docopt\n'), ((2741, 2762), 'schema.validate', 'schema.validate', (['args'], {}), '(args)\n', (2756, 2762), False, 'import schema\n'), ((3605, 3638), 'os.system', 'os.system', (['"""chmod +x runseeds.sh"... |
# coding: utf-8
import smtplib
from vilya.config import SMTP_SERVER
def send_mail(msg):
fromaddr = msg["From"]
toaddrs = []
if msg['To']:
toaddrs += [addr.strip() for addr in msg["To"].split(',')]
if msg["Cc"]:
toaddrs += [addr.strip() for addr in msg["Cc"].split(',')]
smtp = smt... | [
"smtplib.SMTP"
] | [((317, 342), 'smtplib.SMTP', 'smtplib.SMTP', (['SMTP_SERVER'], {}), '(SMTP_SERVER)\n', (329, 342), False, 'import smtplib\n')] |
from flask import Flask, jsonify, request
from flask.views import MethodView
app = Flask(__name__)
languages = [{'name' : 'JavaScript'}, {'name' : 'Python'}, {'name' : 'Ruby'}]
def get_language(name):
return [language for language in languages if language['name'] == name][0]
class Language(MethodView)... | [
"flask.jsonify",
"flask.Flask"
] | [((87, 102), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (92, 102), False, 'from flask import Flask, jsonify, request\n'), ((491, 524), 'flask.jsonify', 'jsonify', (["{'languages': languages}"], {}), "({'languages': languages})\n", (498, 524), False, 'from flask import Flask, jsonify, request\n')] |
#
# This file is part of the Ingram Micro CloudBlue Connect EaaS Extension Runner.
#
# Copyright (c) 2021 Ingram Micro. All Rights Reserved.
#
import json
import pkg_resources
from connect.eaas.dataclasses import ResultType
class _Response:
def __init__(self, status):
self.status = status
class Proces... | [
"pkg_resources.resource_stream"
] | [((2993, 3056), 'pkg_resources.resource_stream', 'pkg_resources.resource_stream', (['cls.__module__', '"""extension.json"""'], {}), "(cls.__module__, 'extension.json')\n", (3022, 3056), False, 'import pkg_resources\n')] |
""" Code for fitting circles, ellipses, planes, etc.
"""
import numpy as np
from numpy.linalg import eig, inv
from stentseg.utils.new_pointset import PointSet
def fit_circle(pp, warnIfIllDefined=True):
""" Fit a circle on the given 2D points
Returns a tuple (x, y, r).
In case the three points... | [
"numpy.sqrt",
"visvis.xlabel",
"stentseg.utils.new_pointset.PointSet",
"numpy.hstack",
"visvis.ylabel",
"visvis.plot",
"numpy.array",
"numpy.linalg.norm",
"numpy.sin",
"visvis.title",
"visvis.clf",
"numpy.dot",
"numpy.linspace",
"numpy.arctan",
"numpy.random.normal",
"visvis.subplot",
... | [((1926, 1942), 'stentseg.utils.new_pointset.PointSet', 'PointSet', (['[x, y]'], {}), '([x, y])\n', (1934, 1942), False, 'from stentseg.utils.new_pointset import PointSet\n'), ((3000, 3014), 'numpy.dot', 'np.dot', (['D.T', 'D'], {}), '(D.T, D)\n', (3006, 3014), True, 'import numpy as np\n'), ((3022, 3038), 'numpy.zeros... |
import xbmcaddon
__settings__ = xbmcaddon.Addon(id='plugin.video.veetle')
__language__ = __settings__.getLocalizedString
class VeetleCategory:
def __init__(self, id, title):
self.id = id
self.title = title
class VeetleChannel:
def __init__(self):
self.channelId = 0
... | [
"xbmcaddon.Addon"
] | [((33, 74), 'xbmcaddon.Addon', 'xbmcaddon.Addon', ([], {'id': '"""plugin.video.veetle"""'}), "(id='plugin.video.veetle')\n", (48, 74), False, 'import xbmcaddon\n')] |
from django.core.management.base import BaseCommand
import logging
from openpds.questions.tasks import howAreYouFeelingTodayAllUsers
class Command(BaseCommand):
def handle(self, *args, **kwargs):
howAreYouFeelingTodayAllUsers.delay()
| [
"openpds.questions.tasks.howAreYouFeelingTodayAllUsers.delay"
] | [((209, 246), 'openpds.questions.tasks.howAreYouFeelingTodayAllUsers.delay', 'howAreYouFeelingTodayAllUsers.delay', ([], {}), '()\n', (244, 246), False, 'from openpds.questions.tasks import howAreYouFeelingTodayAllUsers\n')] |
import cPickle as pkl
import gzip
import os
import re
import sys
import numpy
import math
import random
from binary_tree import BinaryTree
def convert_ptb_to_tree(line):
index = 0
tree = None
line = line.rstrip()
stack = []
parts = line.split()
for p_i, p in enumerate(parts):
# openin... | [
"random.shuffle",
"cPickle.load",
"binary_tree.BinaryTree",
"gzip.open"
] | [((1533, 1558), 'gzip.open', 'gzip.open', (['filename', 'mode'], {}), '(filename, mode)\n', (1542, 1558), False, 'import gzip\n'), ((2019, 2030), 'cPickle.load', 'pkl.load', (['f'], {}), '(f)\n', (2027, 2030), True, 'import cPickle as pkl\n'), ((458, 475), 'binary_tree.BinaryTree', 'BinaryTree', (['index'], {}), '(inde... |
from typing import List, Dict, Any, Tuple, Callable, Union, Optional, Type
from hstest.check_result import CheckResult
from hstest.dynamic.stdin import DynamicInputFunction, InputFunction
from hstest.exceptions import UnexpectedError
SimpleStepikTest = str
AdvancedStepikTest = Tuple[str, Any]
StepikTest = Union[Simple... | [
"hstest.check_result.CheckResult",
"hstest.dynamic.stdin.DynamicInputFunction",
"hstest.exceptions.UnexpectedError"
] | [((4168, 4206), 'hstest.check_result.CheckResult', 'CheckResult', (['is_correct', 'self.feedback'], {}), '(is_correct, self.feedback)\n', (4179, 4206), False, 'from hstest.check_result import CheckResult\n'), ((1604, 1677), 'hstest.exceptions.UnexpectedError', 'UnexpectedError', (['"""Attach is not None but copying fro... |
#!/bin/python3
"""
SWTK - AWS SESSION TOKEN SWITCHER -
"""
import argparse
import boto_wp
import os
def main(profile="default", *, token=None, duration=900):
credentials = boto_wp.get_session_token(profile=profile, token=token, duration=int(duration))
# valid credential is there
if credentials is None:
... | [
"boto_wp.add_tmp_profile",
"argparse.ArgumentParser"
] | [((370, 416), 'boto_wp.add_tmp_profile', 'boto_wp.add_tmp_profile', (['tmp_prof', 'credentials'], {}), '(tmp_prof, credentials)\n', (393, 416), False, 'import boto_wp\n'), ((469, 537), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""SWTK - AWS SESSION TOKEN SWITCHER -"""'}), "(prog='SWTK - AWS ... |
'''Vote type specifications and vote validators.
Vote types vary from system to system and are only loosely tied to the method
of evaluation (usually, the richer vote types can be reduced to use simple
evaluators but not vice versa). The following vote types are recognized by
Votelib:
- **Simple** votes - a voter v... | [
"collections.defaultdict"
] | [((12316, 12362), 'collections.defaultdict', 'collections.defaultdict', (['(lambda : rank_checker)'], {}), '(lambda : rank_checker)\n', (12339, 12362), False, 'import collections\n'), ((14697, 14736), 'collections.defaultdict', 'collections.defaultdict', (['(lambda : no_sc)'], {}), '(lambda : no_sc)\n', (14720, 14736),... |
import numpy as np
from keras.utils import to_categorical
import copy
from common.utils import default_config, make_env, eligibility_traces, discount_rewards
from common.ppo_independant import PPOPolicyNetwork, ValueNetwork
render = False
normalize_inputs = True
config = default_config()
env = make_env(config, normal... | [
"numpy.mean",
"copy.deepcopy",
"numpy.std",
"keras.utils.to_categorical",
"numpy.array",
"common.ppo_independant.ValueNetwork",
"common.utils.discount_rewards",
"common.ppo_independant.PPOPolicyNetwork",
"common.utils.default_config",
"common.utils.make_env"
] | [((274, 290), 'common.utils.default_config', 'default_config', ([], {}), '()\n', (288, 290), False, 'from common.utils import default_config, make_env, eligibility_traces, discount_rewards\n'), ((297, 331), 'common.utils.make_env', 'make_env', (['config', 'normalize_inputs'], {}), '(config, normalize_inputs)\n', (305, ... |