code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import csv
import copy
import os
import random
from algorithms import domain_impl
def to_int_tuple(input_str):
if input_str is not None:
num_str = input_str.strip()
if num_str.isnumeric() or num_str.isdigit():
int_num = int(num_str)
return True, int_num
# only if ... | [
"os.path.exists",
"csv.reader"
] | [((1396, 1422), 'os.path.exists', 'os.path.exists', (['input_path'], {}), '(input_path)\n', (1410, 1422), False, 'import os\n'), ((1574, 1593), 'csv.reader', 'csv.reader', (['csvFile'], {}), '(csvFile)\n', (1584, 1593), False, 'import csv\n')] |
from django.db import models
class Post(models.Model):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=255)
image = models.FileField(null=True,blank=True,upload_to='')
slug = models.SlugField()
intro = models.TextField()
body = models.TextField()
date_added = mod... | [
"django.db.models.EmailField",
"django.db.models.TextField",
"django.db.models.FileField",
"django.db.models.SlugField",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((65, 99), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (81, 99), False, 'from django.db import models\n'), ((112, 144), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (128, 144), False, 'from django.d... |
# -*- coding: utf-8 -*-
# Copyright 2019 celadari. All rights reserved. MIT license.
import argparse
import json
import os
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('path_json')
parser.add_argument('api_version')
parser.add_argument('--scala-versions', dest='sc... | [
"argparse.ArgumentParser",
"os.path.isfile",
"os.path.dirname",
"json.load",
"json.dump"
] | [((166, 191), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (189, 191), False, 'import argparse\n'), ((385, 415), 'os.path.isfile', 'os.path.isfile', (['args.path_json'], {}), '(args.path_json)\n', (399, 415), False, 'import os\n'), ((1050, 1081), 'os.path.dirname', 'os.path.dirname', (['args.... |
import pygame
import time
pygame.init()
pygame.mixer.init()
sounda= pygame.mixer.Sound("European_Dragon_Roaring_and_breathe_fire-daniel-simon_wav.wav")
wonka= pygame.mixer.Sound("SCOTT_JOPLIN_The_Entertainer_wav.wav")
pygame.mixer.Channel(1).play(wonka)
time.sleep(3)
pygame.mixer.Channel(0).play(sounda)
for i in range(... | [
"pygame.mixer.Channel",
"pygame.init",
"time.sleep",
"pygame.mixer.Sound",
"pygame.mixer.init"
] | [((26, 39), 'pygame.init', 'pygame.init', ([], {}), '()\n', (37, 39), False, 'import pygame\n'), ((40, 59), 'pygame.mixer.init', 'pygame.mixer.init', ([], {}), '()\n', (57, 59), False, 'import pygame\n'), ((68, 156), 'pygame.mixer.Sound', 'pygame.mixer.Sound', (['"""European_Dragon_Roaring_and_breathe_fire-daniel-simon... |
from sciunit.models.backends import Backend
import os
class storage(Backend):
name = 'storage'
def init_backend(self, *args, **kwargs):
"""Initialize the backend."""
self.model.attrs = {}
self.use_memory_cache = kwargs.get('use_memory_cache', True)
if self.use_memory_cache:
... | [
"os.path.exists"
] | [((606, 642), 'os.path.exists', 'os.path.exists', (['self.model.file_path'], {}), '(self.model.file_path)\n', (620, 642), False, 'import os\n')] |
import os
import sys
from shutil import copy
from random import shuffle, choice
NUM_TRAIN = 7
NUM_VAL = 1
NUM_TEST = 2
chaser = [0] * NUM_TRAIN + [1] * NUM_VAL + [2] * NUM_TEST
#Directory that contains target files
source = 'source'
person = sys.argv[1]
#Destination directories
train = 'train'
validation = 'valid... | [
"os.listdir",
"os.path.join",
"shutil.copy",
"random.choice"
] | [((749, 777), 'os.path.join', 'os.path.join', (['source', 'person'], {}), '(source, person)\n', (761, 777), False, 'import os\n'), ((794, 812), 'os.listdir', 'os.listdir', (['source'], {}), '(source)\n', (804, 812), False, 'import os\n'), ((371, 398), 'os.path.join', 'os.path.join', (['train', 'person'], {}), '(train, ... |
import logging
import flask
from ib1.openenergy.support import AccessTokenValidator, nginx_cert_parser
LOG = logging.getLogger('example.energydata.org.uk')
logging.basicConfig(level=logging.INFO)
validator = AccessTokenValidator(client_id='olQh4BLV0mQUaM3OZbpXy',
certificate='/home... | [
"logging.getLogger",
"logging.basicConfig",
"flask.send_from_directory",
"flask.Flask",
"ib1.openenergy.support.AccessTokenValidator"
] | [((112, 158), 'logging.getLogger', 'logging.getLogger', (['"""example.energydata.org.uk"""'], {}), "('example.energydata.org.uk')\n", (129, 158), False, 'import logging\n'), ((160, 199), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (179, 199), False, 'import l... |
#
# (C) 2014-2017 <NAME>
# Licensed under the MIT License (MIT)
# http://opensource.org/licenses/MIT
#
from concurrent import futures as cf
import threading
from tornado import gen, process
from tornado.queues import Queue
PROCESSES = process.cpu_count()
class Worker(object):
"""General-purpose multiprocess wo... | [
"tornado.queues.Queue",
"concurrent.futures.ThreadPoolExecutor",
"threading.Lock",
"concurrent.futures.ProcessPoolExecutor",
"tornado.process.cpu_count"
] | [((238, 257), 'tornado.process.cpu_count', 'process.cpu_count', ([], {}), '()\n', (255, 257), False, 'from tornado import gen, process\n'), ((558, 578), 'tornado.queues.Queue', 'Queue', (['(PROCESSES * 2)'], {}), '(PROCESSES * 2)\n', (563, 578), False, 'from tornado.queues import Queue\n'), ((1779, 1786), 'tornado.queu... |
"""
A module for handling custom model layers.
"""
import tensorflow as tf
from tensorflow.python.keras.engine.base_layer import Layer
import tensorflow.keras.backend as K
from hungarian_loss import hungarian_loss
class KLDivergence(Layer):
def __init__(self, code_size, beta=1.0, **kwargs):
self._beta =... | [
"tensorflow.keras.backend.shape",
"tensorflow.keras.backend.mean",
"tensorflow.keras.backend.in_train_phase",
"hungarian_loss.hungarian_loss",
"tensorflow.keras.backend.random_normal",
"tensorflow.keras.backend.exp",
"tensorflow.where",
"tensorflow.gather_nd",
"tensorflow.keras.backend.square",
"t... | [((955, 996), 'tensorflow.keras.backend.sum', 'K.sum', (['latent_loss'], {'axis': '(1)', 'keepdims': '(True)'}), '(latent_loss, axis=1, keepdims=True)\n', (960, 996), True, 'import tensorflow.keras.backend as K\n'), ((1019, 1046), 'tensorflow.keras.backend.mean', 'K.mean', (['latent_loss'], {'axis': '(0)'}), '(latent_l... |
import numpy as np
import sys
import linefinder.config as p_config
import linefinder.linefinder as linefinder
import linefinder.utils.file_management as file_management
import linefinder.utils.trove_management as trove_management
########################################################################
sim_names = [
... | [
"linefinder.utils.trove_management.LinefinderTroveManager",
"linefinder.linefinder.run_linefinder"
] | [((983, 1055), 'linefinder.utils.trove_management.LinefinderTroveManager', 'trove_management.LinefinderTroveManager', (['file_format', 'sim_names', 'galdefs'], {}), '(file_format, sim_names, galdefs)\n', (1022, 1055), True, 'import linefinder.utils.trove_management as trove_management\n'), ((1600, 1792), 'linefinder.li... |
import numpy as np
import tensorflow as tf
from plot_util import show_loss, show_accuracy
def execute():
(train_data, train_labels), (test_data, test_labels) = tf.keras.datasets.reuters.load_data(num_words=10000)
x_train = vectorize_sequences(train_data)
x_test = vectorize_sequences(test_data)
one_... | [
"tensorflow.keras.utils.to_categorical",
"plot_util.show_accuracy",
"plot_util.show_loss",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.datasets.reuters.load_data"
] | [((167, 219), 'tensorflow.keras.datasets.reuters.load_data', 'tf.keras.datasets.reuters.load_data', ([], {'num_words': '(10000)'}), '(num_words=10000)\n', (202, 219), True, 'import tensorflow as tf\n'), ((339, 382), 'tensorflow.keras.utils.to_categorical', 'tf.keras.utils.to_categorical', (['train_labels'], {}), '(trai... |
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
"""Nipype translation of ANTs' workflows."""
import numpy as np
# general purpose
from pkg_resources import resource_filename as pkgr_fn
# nipype
from nipype.pipeline import engine as pe
from nipype.interf... | [
"niworkflows.interfaces.fixes.FixHeaderApplyTransforms",
"nibabel.load",
"numpy.array",
"nipype.interfaces.utility.IdentityInterface",
"niworkflows.interfaces.nibabel.Binarize",
"nipype.pipeline.engine.Workflow",
"nipype.interfaces.utility.Select",
"nipype.interfaces.ants.N4BiasFieldCorrection",
"te... | [((2147, 2209), 'templateflow.api.get', 'get_template', (['in_template'], {'suffix': 'mri_scheme'}), '(in_template, suffix=mri_scheme, **template_specs)\n', (2159, 2209), True, 'from templateflow.api import get as get_template\n'), ((2642, 2714), 'templateflow.api.get', 'get_template', (['in_template'], {'desc': '"""br... |
import tensorflow as tf
def complex_to_real(tensor):
"""Returns tensor converted from a complex dtype with shape
(...,) to a real dtype with shape (..., 2), where last index
marks real [0] and imag [1] parts of a complex valued tensor.
Args:
tensor: complex valued tensor of shape (...,).
... | [
"tensorflow.math.real",
"tensorflow.math.imag",
"tensorflow.complex"
] | [((896, 938), 'tensorflow.complex', 'tf.complex', (['tensor[..., 0]', 'tensor[..., 1]'], {}), '(tensor[..., 0], tensor[..., 1])\n', (906, 938), True, 'import tensorflow as tf\n'), ((401, 421), 'tensorflow.math.real', 'tf.math.real', (['tensor'], {}), '(tensor)\n', (413, 421), True, 'import tensorflow as tf\n'), ((462, ... |
import requests
import re
from urllib import parse
headers = {
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.116 Safari/537.36",
"referer": "https://tb.alicdn.com/snapshot/index.html",
'cookie': 't=884491259d4aed9aac3cd83e5798c433; cna=UU81F... | [
"urllib.parse.quote",
"requests.get",
"re.compile"
] | [((1087, 1121), 'requests.get', 'requests.get', (['url'], {'headers': 'headers'}), '(url, headers=headers)\n', (1099, 1121), False, 'import requests\n'), ((1342, 1388), 're.compile', 're.compile', (['""""raw_title":"(.*?)\\""""', '(re.I | re.S)'], {}), '(\'"raw_title":"(.*?)"\', re.I | re.S)\n', (1352, 1388), False, 'i... |
import unittest
import rpy3.robjects as robjects
rinterface = robjects.rinterface
import array
class REnvironmentTestCase(unittest.TestCase):
def testNew(self):
env = robjects.REnvironment()
self.assertEquals(rinterface.ENVSXP, env.typeof)
def testNewValueError(self):
self.assertRaises... | [
"unittest.main",
"rpy3.robjects.REnvironment",
"unittest.TestLoader"
] | [((628, 643), 'unittest.main', 'unittest.main', ([], {}), '()\n', (641, 643), False, 'import unittest\n'), ((180, 203), 'rpy3.robjects.REnvironment', 'robjects.REnvironment', ([], {}), '()\n', (201, 203), True, 'import rpy3.robjects as robjects\n'), ((403, 426), 'rpy3.robjects.REnvironment', 'robjects.REnvironment', ([... |
import pytesseract
import cv2
def ocr_processing(image, lang):
tessdata_dir_config = '--psm 1 -c preserve_interword_spaces=1 --tessdata-dir "./Packages/Tesseract-OCR/tessdata"'
pytesseract.pytesseract.tesseract_cmd = r'.\Packages\Tesseract-OCR\tesseract'
src = pytesseract.image_to_string(image, lang=lang,... | [
"cv2.imshow",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.cvtColor",
"pytesseract.image_to_string",
"cv2.GaussianBlur",
"cv2.imread"
] | [((275, 348), 'pytesseract.image_to_string', 'pytesseract.image_to_string', (['image'], {'lang': 'lang', 'config': 'tessdata_dir_config'}), '(image, lang=lang, config=tessdata_dir_config)\n', (302, 348), False, 'import pytesseract\n'), ((422, 439), 'cv2.imread', 'cv2.imread', (['image'], {}), '(image)\n', (432, 439), F... |
#There's so many way to improve these code, but for learning sake. This is good enough. I will revisit these code again in a month or two. to improve it by making it shorter, easier to read
import random
print("Hey! It's time to duel! Let's go!\n ROCK... \n PAPER... \n SCISSOR!!")
round = ''
your_score = 0
computer_... | [
"random.choice"
] | [((463, 506), 'random.choice', 'random.choice', (["['rock', 'paper', 'scissor']"], {}), "(['rock', 'paper', 'scissor'])\n", (476, 506), False, 'import random\n')] |
# Generated by Django 2.1.2 on 2018-12-06 20:48
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('mrp_system', '0016_auto_20181206_1258'),
]
operations = [
migrations.AddField(
model_name='part',
name='char3',
... | [
"django.db.models.CharField"
] | [((334, 377), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'max_length': '(30)'}), '(blank=True, max_length=30)\n', (350, 377), False, 'from django.db import migrations, models\n'), ((494, 537), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'max_length': '(30)'... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import unittest
import hypothesis.strategies as st
from hypothesis import given
import numpy as np
from caffe2.python import core, workspace
import caffe2.pytho... | [
"numpy.random.rand",
"hypothesis.strategies.integers",
"unittest.skipIf",
"numpy.random.randint",
"hypothesis.strategies.booleans",
"caffe2.python.core.CreateOperator",
"unittest.main"
] | [((399, 464), 'unittest.skipIf', 'unittest.skipIf', (['(not workspace.C.use_mkldnn)', '"""No MKLDNN support."""'], {}), "(not workspace.C.use_mkldnn, 'No MKLDNN support.')\n", (414, 464), False, 'import unittest\n'), ((1104, 1119), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1117, 1119), False, 'import unittes... |
from __future__ import print_function
path = '/network/aopp/cirrus/pred/kloewer/swm_bf_cntrl/data/'
dpath = '/network/aopp/cirrus/pred/kloewer/swm_back_ronew/'
outpath = '/network/home/aopp/kloewer/swm/paperplot/'
import os; os.chdir(path) # change working directory
import numpy as np
from scipy import sparse
import ... | [
"matplotlib.pyplot.text",
"matplotlib.pyplot.savefig",
"os.chdir",
"numpy.array",
"numpy.linspace",
"matplotlib.pyplot.close",
"numpy.sign",
"matplotlib.pyplot.tight_layout",
"numpy.load",
"matplotlib.pyplot.subplots",
"numpy.round"
] | [((227, 241), 'os.chdir', 'os.chdir', (['path'], {}), '(path)\n', (235, 241), False, 'import os\n'), ((2573, 2635), 'matplotlib.pyplot.subplots', 'plt.subplots', (['(3)', '(3)'], {'figsize': '(8.8, 9)', 'sharex': '(True)', 'sharey': '(True)'}), '(3, 3, figsize=(8.8, 9), sharex=True, sharey=True)\n', (2585, 2635), True,... |
"""Easy context-based interface for generating a sheet and cells.
Comparable to matplotlib pylab interface, this interface keeps track of the current
sheet. Using the ``cell`` function, ``Cell`` widgets are added to the current sheet.
"""
__all__ = ['sheet', 'current', 'cell', 'calculation', 'row', 'column', 'cell_ran... | [
"pscript.py2js"
] | [((14797, 14843), 'pscript.py2js', 'py2js', (['code'], {'new_name': '"""the_renderer"""', 'indent': '(4)'}), "(code, new_name='the_renderer', indent=4)\n", (14802, 14843), False, 'from pscript import py2js\n')] |
from django.test import TestCase
from accelerator.tests.utils import login_as_new_user, login_as_user
from accelerator_abstract.models.base_startup_role import (
BaseStartupRole
)
from accelerator_abstract.models.base_user_role import (
BaseUserRole
)
from accelerator.tests.contexts import (
StartupTeamMem... | [
"accelerator.tests.utils.login_as_new_user",
"accelerator_abstract.models.base_permission_checks._see_employee_pages",
"accelerator_abstract.models.base_permission_checks._see_finalist_pages",
"accelerator.tests.contexts.StartupTeamMemberContext",
"accelerator.tests.test_core_profile.expert",
"accelerator... | [((818, 873), 'accelerator.tests.utils.login_as_new_user', 'login_as_new_user', (['self', 'UserFactory'], {'is_superuser': '(True)'}), '(self, UserFactory, is_superuser=True)\n', (835, 873), False, 'from accelerator.tests.utils import login_as_new_user, login_as_user\n'), ((1110, 1165), 'accelerator.tests.utils.login_a... |
import torch
import torch.nn as nn
from torch.autograd import Variable
import math
import torch.nn.functional as F
class GMMLogLoss(nn.Module):
''' compute the GMM loss between model output and the groundtruth data.
Args:
ncenter: numbers of gaussian distribution
ndim: dimension of ... | [
"torch.nn.functional.mse_loss",
"torch.log",
"torch.multinomial",
"torchvision.models.vgg19",
"torch.nn.Sequential",
"torch.nn.L1Loss",
"torch.exp",
"torch.min",
"math.log",
"torch.nn.MSELoss",
"torch.nn.BCELoss",
"torch.autograd.Variable",
"torch.empty",
"torch.nn.functional.softmax",
"... | [((4483, 4562), 'torch.nn.functional.softmax', 'nn.functional.softmax', (['(gmm_params_cpu[:, :ncenter] * (1 + weight_smooth))'], {'dim': '(1)'}), '(gmm_params_cpu[:, :ncenter] * (1 + weight_smooth), dim=1)\n', (4504, 4562), True, 'import torch.nn as nn\n'), ((4651, 4707), 'torch.multinomial', 'torch.multinomial', (['p... |
# -*- coding: utf-8 -*-
import ustruct as struct
class ValueType:
STRING = "string"
CHAR = "char"
DOUBLE = "double"
FLOAT = "float"
INT = "int"
UINT = "uint"
SHORT = "short"
BOOLEAN = "boolean"
def fill_bytes(byte_array, start, end, value, value_type):
if value_type == ValueType.... | [
"ustruct.pack"
] | [((400, 423), 'ustruct.pack', 'struct.pack', (['"""s"""', 'value'], {}), "('s', value)\n", (411, 423), True, 'import ustruct as struct\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*- #
from __future__ import unicode_literals
# This file is only used if you use `make publish` or
# explicitly specify it as your config file.
import os
import sys
sys.path.append(os.curdir)
from pelicanconf import *
SITEURL = 'https://ankursinha.in'
FEED_DOMAIN = SITEURL... | [
"sys.path.append"
] | [((210, 236), 'sys.path.append', 'sys.path.append', (['os.curdir'], {}), '(os.curdir)\n', (225, 236), False, 'import sys\n')] |
# Generated by Django 3.0.1 on 2020-02-16 06:07
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('favorApp', '0002_auto_20200216_0511'),
]
operations = [
migrations.AlterField(
model_name='favor',
name='date',
... | [
"django.db.models.DateTimeField"
] | [((334, 356), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {}), '()\n', (354, 356), False, 'from django.db import migrations, models\n')] |
#
# -------------------------------------------------------------------------
# Copyright (c) 2015-2017 AT&T Intellectual Property
#
# 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
#
# ... | [
"conductor.i18n._LE"
] | [((1974, 2000), 'conductor.i18n._LE', '_LE', (['"""Can\'t set attribute"""'], {}), '("Can\'t set attribute")\n', (1977, 2000), False, 'from conductor.i18n import _LE\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
# @Author: dbirman
# @Date: 2017-06-14 16:51:24
import sys
import csv
import random
import webbrowser
import os
import numpy as np
# other functions
def n... | [
"random.shuffle",
"csv.writer",
"webbrowser.open",
"os.getcwd",
"os.path.isfile",
"numpy.sum",
"sys.exit",
"csv.reader",
"numpy.divide"
] | [((559, 578), 'csv.reader', 'csv.reader', (['csvfile'], {}), '(csvfile)\n', (569, 578), False, 'import csv\n'), ((1304, 1325), 'random.shuffle', 'random.shuffle', (['order'], {}), '(order)\n', (1318, 1325), False, 'import random\n'), ((2391, 2410), 'csv.writer', 'csv.writer', (['outfile'], {}), '(outfile)\n', (2401, 24... |
import datetime
from datetime import date
import pandas as pd
import numpy as np
import boto3
import smtplib
import matplotlib.pyplot as plt
import os
try:
os.mkdir('output_files')
except:
pass
data = pd.read_json('https://raw.githubusercontent.com/pomber/covid19/master/docs/timeseries.json')
s3 = boto3.reso... | [
"pandas.Series",
"matplotlib.pyplot.savefig",
"boto3.resource",
"os.mkdir",
"datetime.datetime.today",
"pandas.np.empty",
"pandas.read_json"
] | [((211, 313), 'pandas.read_json', 'pd.read_json', (['"""https://raw.githubusercontent.com/pomber/covid19/master/docs/timeseries.json"""'], {}), "(\n 'https://raw.githubusercontent.com/pomber/covid19/master/docs/timeseries.json'\n )\n", (223, 313), True, 'import pandas as pd\n'), ((310, 330), 'boto3.resource', 'bo... |
# -*- coding: utf-8 -*-
# encoding: utf-8
from __future__ import unicode_literals
import frappe
from frappe import _
from frappe.utils import today, add_days, get_url, date_diff, getdate
from frappe.model.document import Document
from frappe.utils import cstr, cint, get_fullname
from frappe.utils import today, add_days... | [
"dateutil.relativedelta.relativedelta",
"frappe.db.get_value",
"frappe.db.get_single_value",
"frappe.whitelist",
"frappe.sendmail",
"frappe.model.mapper.get_mapped_doc",
"frappe.db.set_value",
"frappe.get_doc",
"frappe.utils.today.replace",
"frappe.utils.date_diff",
"datetime.date.today",
"fra... | [((2492, 2510), 'frappe.whitelist', 'frappe.whitelist', ([], {}), '()\n', (2508, 2510), False, 'import frappe\n'), ((3137, 3155), 'frappe.whitelist', 'frappe.whitelist', ([], {}), '()\n', (3153, 3155), False, 'import frappe\n'), ((3786, 3804), 'frappe.whitelist', 'frappe.whitelist', ([], {}), '()\n', (3802, 3804), Fals... |
from setuptools import setup, find_packages
import afh_dl
long_desc = ""
try:
import pypandoc
long_desc = pypandoc.convert('README.md', 'rst', extra_args = ('--eol', 'lf'))
except(IOError, ImportError):
long_desc = open('README.md').read()
setup(
name = "afh-dl",
version = "1.0.3",
descriptio... | [
"pypandoc.convert",
"setuptools.find_packages"
] | [((116, 180), 'pypandoc.convert', 'pypandoc.convert', (['"""README.md"""', '"""rst"""'], {'extra_args': "('--eol', 'lf')"}), "('README.md', 'rst', extra_args=('--eol', 'lf'))\n", (132, 180), False, 'import pypandoc\n'), ((1428, 1443), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1441, 1443), False, '... |
from flask import Blueprint, jsonify
from app.models.item import ItemModel
from app.schemas.item import CreateItemSchema, GetItemSchema
from app.schemas.pagination import PaginationSchema, ItemPaginationSchema
from app.utils.loader import load_category_by_id, load_item_by_id, dump_schema_decorator
from app.utils.secur... | [
"app.utils.validation.load_and_validate_data",
"app.utils.loader.dump_schema_decorator",
"app.models.item.ItemModel.get_total_items_number",
"app.models.item.ItemModel.get_latest_items",
"app.models.item.ItemModel.get_category_items_number",
"app.models.item.ItemModel",
"flask.Blueprint",
"app.models.... | [((480, 577), 'flask.Blueprint', 'Blueprint', (['"""category_item_blueprint"""', '__name__'], {'url_prefix': '"""/categories/<category_id>/items"""'}), "('category_item_blueprint', __name__, url_prefix=\n '/categories/<category_id>/items')\n", (489, 577), False, 'from flask import Blueprint, jsonify\n'), ((594, 656)... |
import os
import re
import sys
from setuptools import find_packages, setup
from setuptools.command.test import test as TestCommand
class PyTest(TestCommand):
user_options = [("pytest-args=", "a", "Arguments to pass to py.test")]
def initialize_options(self):
TestCommand.initialize_options(self)
... | [
"setuptools.find_packages",
"setuptools.command.test.test.finalize_options",
"pytest.main",
"setuptools.command.test.test.initialize_options",
"os.path.dirname",
"sys.exit"
] | [((279, 315), 'setuptools.command.test.test.initialize_options', 'TestCommand.initialize_options', (['self'], {}), '(self)\n', (309, 315), True, 'from setuptools.command.test import test as TestCommand\n'), ((387, 421), 'setuptools.command.test.test.finalize_options', 'TestCommand.finalize_options', (['self'], {}), '(s... |
"""
File System Reader
"""
from typing import Iterator, Tuple, Optional, List
import datetime
from ...utils import paths
import lzma
from ...utils import common
from .internals import BaseReader
import glob
from os.path import isfile, exists
class FileReader(BaseReader):
def __init__(self, **kwarg... | [
"os.path.isfile",
"os.path.exists",
"glob.iglob",
"lzma.open"
] | [((1364, 1389), 'lzma.open', 'lzma.open', (['file_name', '"""r"""'], {}), "(file_name, 'r')\n", (1373, 1389), False, 'import lzma\n'), ((1824, 1842), 'os.path.exists', 'exists', (['cycle_path'], {}), '(cycle_path)\n', (1830, 1842), False, 'from os.path import isfile, exists\n'), ((1898, 1943), 'glob.iglob', 'glob.iglob... |
###############################################################################
# copyright 2012, <NAME> (<EMAIL>) #
# Institut Mines-Telecom - TELECOM & Management SudParis #
# Licensed under the Apache License, Version 2.0 (the "License"); #
# you may not use this file exce... | [
"client.OCCIclient",
"sys.path.append"
] | [((1358, 1387), 'sys.path.append', 'sys.path.append', (['srcdirectory'], {}), '(srcdirectory)\n', (1373, 1387), False, 'import sys\n'), ((2279, 2325), 'client.OCCIclient', 'OCCIclient', (['""""""', '""""""', '"""CO-PROCCI"""', '""""""', 'attribute'], {}), "('', '', 'CO-PROCCI', '', attribute)\n", (2289, 2325), False, '... |
import logging
import os
import ray
import time
from enum import Enum
from ray.actor import ActorHandle
from ray.streaming.generated import remote_call_pb2
from ray.streaming.runtime.command\
import WorkerCommitReport, WorkerRollbackRequest
logger = logging.getLogger(__name__)
class CallResult:
"""
Call... | [
"logging.getLogger",
"ray.streaming.generated.remote_call_pb2.WorkerRollbackRequest",
"ray.get",
"ray.streaming.generated.remote_call_pb2.WorkerCommitReport",
"ray.streaming.generated.remote_call_pb2.BoolResult",
"ray.streaming.generated.remote_call_pb2.BaseWorkerCmd",
"os.getpid",
"time.time",
"os.... | [((256, 283), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (273, 283), False, 'import logging\n'), ((1453, 1484), 'ray.streaming.generated.remote_call_pb2.BaseWorkerCmd', 'remote_call_pb2.BaseWorkerCmd', ([], {}), '()\n', (1482, 1484), False, 'from ray.streaming.generated import remote_... |
from SimpleXMLRPCServer import SimpleXMLRPCServer
class Funcs:
def add(self, x, y):
return x + y
def sub(self, x, y):
return x - y
server = SimpleXMLRPCServer(("localhost", 8000))
server.register_instance(Funcs())
server.serve_forever()
| [
"SimpleXMLRPCServer.SimpleXMLRPCServer"
] | [((191, 230), 'SimpleXMLRPCServer.SimpleXMLRPCServer', 'SimpleXMLRPCServer', (["('localhost', 8000)"], {}), "(('localhost', 8000))\n", (209, 230), False, 'from SimpleXMLRPCServer import SimpleXMLRPCServer\n')] |
from setuptools import find_packages, setup
try:
import pypandoc
long_description = pypandoc.convert('README.md', 'rst')
except ImportError:
long_description = open('README.md').read()
setup(
use_scm_version=True,
setup_requires=['setuptools_scm'],
name='django-super-deduper',
description=... | [
"pypandoc.convert",
"setuptools.find_packages"
] | [((93, 129), 'pypandoc.convert', 'pypandoc.convert', (['"""README.md"""', '"""rst"""'], {}), "('README.md', 'rst')\n", (109, 129), False, 'import pypandoc\n'), ((651, 683), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "['tests']"}), "(exclude=['tests'])\n", (664, 683), False, 'from setuptools import fi... |
"""
Logic for wavefunction evaluation.
"""
import logging
import time
import jax
import functools
import numpy as np
from jax import numpy as jnp
from deeperwin.configuration import EvaluationConfig
from deeperwin.hamiltonian import get_local_energy, calculate_forces
from deeperwin.loggers import DataLogger
from dee... | [
"logging.getLogger",
"deeperwin.hamiltonian.get_local_energy",
"numpy.linalg.solve",
"numpy.reshape",
"jax.numpy.array",
"functools.partial",
"jax.jit",
"jax.numpy.nanmean",
"deeperwin.mcmc.calculate_metrics",
"deeperwin.hamiltonian.calculate_forces",
"time.time",
"numpy.arange"
] | [((408, 432), 'logging.getLogger', 'logging.getLogger', (['"""dpe"""'], {}), "('dpe')\n", (425, 432), False, 'import logging\n'), ((436, 485), 'functools.partial', 'functools.partial', (['jax.jit'], {'static_argnums': '(0, 1)'}), '(jax.jit, static_argnums=(0, 1))\n', (453, 485), False, 'import functools\n'), ((646, 712... |
"""
Leetcode #958
"""
from collections import deque
# Definition for a binary tree node.
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
class Solution:
def isCompleteTree(self, root: TreeNode) -> bool:
... | [
"collections.deque"
] | [((374, 387), 'collections.deque', 'deque', (['[root]'], {}), '([root])\n', (379, 387), False, 'from collections import deque\n')] |
from time import sleep
from pupil import PupilCore, LightStamper, PupilGrabber, new_trigger
# set up pupil
pupil = PupilCore()
# make trigger
trigger = new_trigger('LIGHT_ON')
# start LightStamper
lst = LightStamper(pupil, trigger, threshold=15, wait_time=10.)
pgr = PupilGrabber(pupil, topic='pupil.1.3d', secs=10.)... | [
"pupil.PupilGrabber",
"pupil.PupilCore",
"pupil.new_trigger",
"time.sleep",
"pupil.LightStamper"
] | [((117, 128), 'pupil.PupilCore', 'PupilCore', ([], {}), '()\n', (126, 128), False, 'from pupil import PupilCore, LightStamper, PupilGrabber, new_trigger\n'), ((155, 178), 'pupil.new_trigger', 'new_trigger', (['"""LIGHT_ON"""'], {}), "('LIGHT_ON')\n", (166, 178), False, 'from pupil import PupilCore, LightStamper, PupilG... |
#!/usr/bin/python
import spidev
import time
import os
import sys
import argparse
parser = argparse.ArgumentParser(prog='myprogram')
parser.add_argument('--input', help='input port')
args = parser.parse_args()
#print("input : {} ".format(args.input))
# Open SPI bus
spi = spidev.SpiDev()
spi.open(0,0)
spi.max_speed_h... | [
"spidev.SpiDev",
"argparse.ArgumentParser"
] | [((92, 133), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""myprogram"""'}), "(prog='myprogram')\n", (115, 133), False, 'import argparse\n'), ((275, 290), 'spidev.SpiDev', 'spidev.SpiDev', ([], {}), '()\n', (288, 290), False, 'import spidev\n')] |
#!/usr/bin/env python
"""
CloudGenix Python SDK - WebSocket Functions
**Author:** CloudGenix
**Copyright:** (c) 2017-2021 CloudGenix, Inc
**License:** MIT
"""
import logging
__author__ = "CloudGenix Developer Support <<EMAIL>>"
__email__ = "<EMAIL>"
__copyright__ = "Copyright (c) 2017-2021, 2019 CloudGenix, Inc"
__... | [
"logging.getLogger"
] | [((1530, 1557), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1547, 1557), False, 'import logging\n')] |
# -*- coding: utf-8 -*-
from rpc4django import rpcmethod
from .othermodule import intro, getrequest
from .secretmodule import * # imports protected method
@rpcmethod(name='rpc4django.mytestmethod',signature=['int', 'int', 'int', 'int'])
def mytestmethod(a, b, c):
'''
Adds the three parameters together and ret... | [
"rpc4django.rpcmethod"
] | [((158, 243), 'rpc4django.rpcmethod', 'rpcmethod', ([], {'name': '"""rpc4django.mytestmethod"""', 'signature': "['int', 'int', 'int', 'int']"}), "(name='rpc4django.mytestmethod', signature=['int', 'int', 'int',\n 'int'])\n", (167, 243), False, 'from rpc4django import rpcmethod\n')] |
import numpy as np
import matplotlib.pyplot as plt
import barnes as bn
def gr_to_bv(g, r):
"""
From https://www.sdss3.org/dr8/algorithms/sdssUBVRITransform.php
Returns the B-V value and the RMS error.
"""
return .62*(g - r) + .15, .07
def random_stars(fname, N):
"""
Randomly draw stellar... | [
"matplotlib.pyplot.hist",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.clf",
"barnes.period",
"numpy.genfromtxt"
] | [((1313, 1332), 'barnes.period', 'bn.period', (['age', 'bvs'], {}), '(age, bvs)\n', (1322, 1332), True, 'import barnes as bn\n'), ((1338, 1347), 'matplotlib.pyplot.clf', 'plt.clf', ([], {}), '()\n', (1345, 1347), True, 'import matplotlib.pyplot as plt\n'), ((1352, 1364), 'matplotlib.pyplot.hist', 'plt.hist', (['ps'], {... |
from subprocess import STDOUT
import sys
from tf.transformations import rotation_matrix
sys.path.insert(0, './yolov5')
from yolov5.utils.datasets import LoadImages, LoadStreams,LoadWebcam,LoadRealsense
from yolov5.utils.general import check_img_size, non_max_suppression, scale_coords
from yolov5.utils.torch_utils impo... | [
"cv2.rectangle",
"sys.path.insert",
"visualization_msgs.msg.Marker",
"APF_BASE_utils.BASE_TOOLS_for_car.Vis_and_deside",
"visualization_msgs.msg.MarkerArray",
"rospy.init_node",
"torch.from_numpy",
"cv2.imshow",
"numpy.array",
"rospy.Rate",
"tf.TransformListener",
"yolov5.utils.general.check_i... | [((88, 118), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""./yolov5"""'], {}), "(0, './yolov5')\n", (103, 118), False, 'import sys\n'), ((16647, 16672), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (16670, 16672), False, 'import argparse\n'), ((18469, 18498), 'yolov5.utils.general.check_... |
# 封装 根据django项目配置的 secret_key 加解密
from django.conf import settings
# 使用 TimedJSONWebSignatureSerializer 对象 可以设置有效期
from itsdangerous import TimedJSONWebSignatureSerializer as Serializer
class SecretOauth(object):
# 加密
def dumps(self, content_dict):
# 1.根据 签名(secret_key) 创建序列化对象
serializer = Se... | [
"itsdangerous.TimedJSONWebSignatureSerializer"
] | [((318, 385), 'itsdangerous.TimedJSONWebSignatureSerializer', 'Serializer', ([], {'secret_key': 'settings.SECRET_KEY', 'expires_in': '(24 * 15 * 60)'}), '(secret_key=settings.SECRET_KEY, expires_in=24 * 15 * 60)\n', (328, 385), True, 'from itsdangerous import TimedJSONWebSignatureSerializer as Serializer\n'), ((633, 70... |
from __future__ import absolute_import
from celery.task import group, task
from django.conf import settings
from tmdbsimple import TMDB
from movies.models import Movie
from lists.models import List
@task(ignore_result=True)
def add_movie_to_list(title, list_id):
tmdb = TMDB(settings.TMDB_API_KEY)
search = tmdb... | [
"movies.models.Movie.objects.get_or_create",
"celery.task.task",
"tmdbsimple.TMDB",
"lists.models.List.objects.get"
] | [((205, 229), 'celery.task.task', 'task', ([], {'ignore_result': '(True)'}), '(ignore_result=True)\n', (209, 229), False, 'from celery.task import group, task\n'), ((810, 834), 'celery.task.task', 'task', ([], {'ignore_result': '(True)'}), '(ignore_result=True)\n', (814, 834), False, 'from celery.task import group, tas... |
# -*- coding: utf-8 -*-
from typing import Any, Type, TypeVar, Generic
from uiclasses import Model
from uiclasses.typing import Property
from humanfriendly.tables import format_robust_table, format_pretty_table
from .helpers import AlmostDict
T = TypeVar("T")
class Config(Model):
data: Any
type: Type
... | [
"humanfriendly.tables.format_pretty_table",
"humanfriendly.tables.format_robust_table",
"typing.TypeVar"
] | [((251, 263), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (258, 263), False, 'from typing import Any, Type, TypeVar, Generic\n'), ((4705, 4790), 'humanfriendly.tables.format_pretty_table', 'format_pretty_table', (["[[1, 'chucknorris', '<EMAIL>']]", "['id', 'username', 'email']"], {}), "([[1, 'chucknorris... |
# coding: utf-8
import tensorflow as tf
import numpy as np
from networks.base import TensorflowTrainable
class RNN(TensorflowTrainable):
def __init__(self, cell, num_units, embedding_dim, projecter, keep_prob, **kwargs):
super(RNN, self).__init__()
# private
self._projecter = projecter
... | [
"tensorflow.unstack",
"tensorflow.nn.conv2d",
"tensorflow.equal",
"tensorflow.transpose",
"tensorflow.to_int32",
"tensorflow.argmax",
"tensorflow.name_scope",
"tensorflow.matmul",
"tensorflow.nn.dropout",
"tensorflow.summary.scalar",
"tensorflow.cast"
] | [((661, 733), 'tensorflow.nn.dropout', 'tf.nn.dropout', ([], {'x': 'sequence', 'keep_prob': 'self.keep_prob', 'name': '"""noisy_inputs"""'}), "(x=sequence, keep_prob=self.keep_prob, name='noisy_inputs')\n", (674, 733), True, 'import tensorflow as tf\n'), ((1012, 1042), 'tensorflow.unstack', 'tf.unstack', (['projected_s... |
from django.contrib import admin
from .models import Story
admin.site.register(Story)
| [
"django.contrib.admin.site.register"
] | [((61, 87), 'django.contrib.admin.site.register', 'admin.site.register', (['Story'], {}), '(Story)\n', (80, 87), False, 'from django.contrib import admin\n')] |
import sys
import storage
import json
import texttable as tt
protocol = "https"
nbmaster = ""
username = ""
password = ""
domainname = ""
domaintype = ""
port = 1556
def print_usage():
print("Example:")
print(
"python -W ignore get_storage_server_by_id.py -nbmaster <master_server> -username <usernam... | [
"storage.perform_login",
"storage.get_storage_server_by_id"
] | [((1627, 1702), 'storage.perform_login', 'storage.perform_login', (['username', 'password', 'base_url', 'domainname', 'domaintype'], {}), '(username, password, base_url, domainname, domaintype)\n', (1648, 1702), False, 'import storage\n'), ((1711, 1765), 'storage.get_storage_server_by_id', 'storage.get_storage_server_b... |
# (C) Datadog, Inc. 2018
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
import click
from .config import config
from .dep import dep
from .manifest import manifest
from .metadata import metadata
from .service_checks import service_checks
from .py3 import py3
from ..console import CON... | [
"click.group"
] | [((434, 534), 'click.group', 'click.group', ([], {'context_settings': 'CONTEXT_SETTINGS', 'short_help': '"""Verify certain aspects of the repo"""'}), "(context_settings=CONTEXT_SETTINGS, short_help=\n 'Verify certain aspects of the repo')\n", (445, 534), False, 'import click\n')] |
from navigation import StateModule
import energenie
OUTLETS = {
1: {
"name": "Laptop",
"instance": energenie.Devices.ENER002(1),
},
2: {
"name": "Monitor 1",
"instance": energenie.Devices.ENER002(2),
},
3: {
"name": "Monitor 2",
"instance": energenie.... | [
"energenie.init",
"energenie.Devices.ENER002"
] | [((120, 148), 'energenie.Devices.ENER002', 'energenie.Devices.ENER002', (['(1)'], {}), '(1)\n', (145, 148), False, 'import energenie\n'), ((215, 243), 'energenie.Devices.ENER002', 'energenie.Devices.ENER002', (['(2)'], {}), '(2)\n', (240, 243), False, 'import energenie\n'), ((310, 338), 'energenie.Devices.ENER002', 'en... |
from __future__ import print_function
import os
import sys
import tweepy
import json
import subprocess
def write_creds(creds):
with open(creds_file, 'w') as outfile:
json.dump(creds, outfile)
creds_file = 'credentials.json'
credentials = {}
if os.path.isfile(creds_file):
with open(creds_file) as inf... | [
"os.path.isfile",
"sys.exit",
"json.load",
"json.dump",
"tweepy.OAuthHandler"
] | [((260, 286), 'os.path.isfile', 'os.path.isfile', (['creds_file'], {}), '(creds_file)\n', (274, 286), False, 'import os\n'), ((738, 816), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (["credentials['ConsumerKey']", "credentials['ConsumerSecret']"], {}), "(credentials['ConsumerKey'], credentials['ConsumerSecret'])\n", ... |
#! /usr/bin/env python
"""
This node publishes the joint states to make a square trajectory with the SCARA's end-effector
@author: <NAME> (<EMAIL>)
"""
import rospy
import rospkg
rospack = rospkg.RosPack()
import sys
sys.path.insert(0, rospack.get_path('first_assignment')+"/scripts")
from sensor_msgs.msg imp... | [
"rospy.is_shutdown",
"rospy.init_node",
"rospy.get_param",
"sensor_msgs.msg.JointState",
"numpy.absolute",
"IK_function.scara_IK",
"numpy.array",
"rospkg.RosPack",
"rospy.Rate",
"geometry_msgs.msg.Pose",
"rospy.Publisher",
"geometry_msgs.msg.PoseArray"
] | [((200, 216), 'rospkg.RosPack', 'rospkg.RosPack', ([], {}), '()\n', (214, 216), False, 'import rospkg\n'), ((3964, 4003), 'rospy.init_node', 'rospy.init_node', (['"""trajectory_publisher"""'], {}), "('trajectory_publisher')\n", (3979, 4003), False, 'import rospy\n'), ((4021, 4077), 'rospy.get_param', 'rospy.get_param',... |
from django.shortcuts import render, get_object_or_404, redirect
from django.http import Http404, JsonResponse
from django.urls import reverse
from django.core import serializers
from django.core.paginator import Paginator
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import ... | [
"django.shortcuts.render",
"django.http.JsonResponse",
"usermgmt.models.Profile.objects.filter",
"django.shortcuts.get_object_or_404",
"django.contrib.auth.models.User.objects.filter",
"django.shortcuts.redirect",
"usermgmt.models.Notification.objects.create",
"django.urls.reverse",
"django.core.ser... | [((2120, 2151), 'django.core.paginator.Paginator', 'Paginator', (['ideas', 'IDEA_PER_PAGE'], {}), '(ideas, IDEA_PER_PAGE)\n', (2129, 2151), False, 'from django.core.paginator import Paginator\n'), ((3058, 3093), 'django.shortcuts.render', 'render', (['request', 'template_file', 'ctx'], {}), '(request, template_file, ct... |
import unittest
import threading
class Tests(unittest.TestCase):
def test_service_info(self):
from multiprocessing import Pipe
from FreeTAKServer.model.ServiceObjects.FTS import FTS
pipe1, pipe2 = Pipe(True)
from FreeTAKServer.controllers.services.API import RestAPI
RestAPI.... | [
"FreeTAKServer.model.ServiceObjects.FTS.FTS",
"json.dumps",
"FreeTAKServer.controllers.services.RestAPI.changeStatus",
"FreeTAKServer.controllers.services.RestAPI.show_service_info",
"multiprocessing.Pipe",
"FreeTAKServer.controllers.services.RestAPI.systemUsers"
] | [((226, 236), 'multiprocessing.Pipe', 'Pipe', (['(True)'], {}), '(True)\n', (230, 236), False, 'from multiprocessing import Pipe\n'), ((374, 401), 'FreeTAKServer.controllers.services.RestAPI.show_service_info', 'RestAPI.show_service_info', ([], {}), '()\n', (399, 401), False, 'from FreeTAKServer.controllers.services im... |
import torch
import torch.nn as nn
import torch.nn.functional as F
def parameter(*size: int) -> nn.Parameter:
return nn.Parameter(torch.zeros(*size), requires_grad=True)
def positive(tensor: torch.Tensor) -> torch.Tensor:
return F.softplus(tensor) # ReLU + eps とかだとうまくいかない (おそらく勾配消失のせい)
| [
"torch.nn.functional.softplus",
"torch.zeros"
] | [((241, 259), 'torch.nn.functional.softplus', 'F.softplus', (['tensor'], {}), '(tensor)\n', (251, 259), True, 'import torch.nn.functional as F\n'), ((136, 154), 'torch.zeros', 'torch.zeros', (['*size'], {}), '(*size)\n', (147, 154), False, 'import torch\n')] |
from coldtype import *
from coldtype.pens.datpen import DPR
from functools import partial
Style.RegisterShorthandPrefix("≈", "~/Type/fonts/fonts")
sinaloa_ufo = raw_ufo("fonts/sinaloa.ufo")
BLOCK = 350
class sinaloa(glyph):
def __init__(self, glyphName, **kwargs):
self.ufo_glyph = sinaloa_ufo[glyphName]... | [
"coldtype.pens.datpen.DPR"
] | [((609, 622), 'coldtype.pens.datpen.DPR', 'DPR', (['self.box'], {}), '(self.box)\n', (612, 622), False, 'from coldtype.pens.datpen import DPR\n'), ((2457, 2463), 'coldtype.pens.datpen.DPR', 'DPR', (['r'], {}), '(r)\n', (2460, 2463), False, 'from coldtype.pens.datpen import DPR\n'), ((2333, 2339), 'coldtype.pens.datpen.... |
#!/usr/bin/env python
from butter.clone import unshare, setns
import pytest
@pytest.mark.clone
def test_setns(mock):
m = mock.patch('butter.clone._lib')
m = mock.patch('butter.clone._lib.setns')
m.return_value = 0
setns(fd=5)
| [
"butter.clone.setns"
] | [((241, 252), 'butter.clone.setns', 'setns', ([], {'fd': '(5)'}), '(fd=5)\n', (246, 252), False, 'from butter.clone import unshare, setns\n')] |
from setuptools import setup
from setuptools import find_packages
setup(name='SparseGAMsWithInteractions',
version='1.0',
description='Generalized Additive Models with Interactions under L0 sparsity with/without Strong Hierarchy',
author='<NAME>',
author_email='<EMAIL>',
# url='',
do... | [
"setuptools.find_packages"
] | [((1421, 1436), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1434, 1436), False, 'from setuptools import find_packages\n')] |
import numpy
from PyQt5 import QtWidgets
from PyQt5.QtWidgets import QMessageBox, QApplication
from PyQt5.QtCore import QRect
from PyQt5.QtGui import QTextCursor
from orangewidget import gui
from orangewidget.settings import Setting
from oasys.widgets import gui as oasysgui
from oasys.widgets.widget import Automatic... | [
"oasys.widgets.gui.widgetBox",
"numpy.abs",
"orangecontrib.wofry.widgets.gui.python_script.PythonScript",
"oasys.widgets.gui.plotWindow",
"orangewidget.gui.comboBox",
"oasys.widgets.gui.createTabPage",
"orangewidget.gui.widgetBox",
"orangewidget.settings.Setting",
"numpy.array",
"oasys.widgets.gui... | [((787, 797), 'orangewidget.settings.Setting', 'Setting', (['(1)'], {}), '(1)\n', (794, 797), False, 'from orangewidget.settings import Setting\n'), ((1462, 1495), 'oasys.widgets.gui.tabWidget', 'oasysgui.tabWidget', (['self.mainArea'], {}), '(self.mainArea)\n', (1480, 1495), True, 'from oasys.widgets import gui as oas... |
# -*- coding: utf-8 -*-
"""tests for api.validators"""
from mock import MagicMock
from tests.unit import UnitTestCase
from app.api.validators import DummyForm, DummyField, Base, password
class DummyFormTestCase(UnitTestCase):
def test_class(self):
self.assertTrue(issubclass(DummyForm, dict))
class Du... | [
"app.api.validators.Base",
"app.api.validators.MacAddress",
"app.api.validators.AnyOf",
"app.api.validators.Length",
"app.api.validators.DummyField",
"app.api.validators.password",
"app.api.validators.IPAddress",
"app.api.validators.NoneOf",
"app.api.validators.NumberRange",
"mock.MagicMock",
"a... | [((400, 416), 'app.api.validators.DummyField', 'DummyField', (['None'], {}), '(None)\n', (410, 416), False, 'from app.api.validators import DummyForm, DummyField, Base, password\n'), ((591, 636), 'app.api.validators.DummyField', 'DummyField', (['"""a"""', "('something wrong',)", '"""a """'], {}), "('a', ('something w... |
import os
import random
import streamlit as st
def show():
st.write(
"""
## 🐾 Data Labelling
This is one for all machine learning fans: Label some images and all of your
annotations are preserved in `st.session_state`!
"""
)
script_path = os.path.dirnam... | [
"os.listdir",
"random.choice",
"streamlit.button",
"streamlit.write",
"streamlit.session_state.files.remove",
"os.path.dirname",
"streamlit.columns"
] | [((66, 281), 'streamlit.write', 'st.write', (['"""\n ## 🐾 Data Labelling\n \n This is one for all machine learning fans: Label some images and all of your \n annotations are preserved in `st.session_state`!\n """'], {}), '(\n """\n ## 🐾 Data Labelling\n \n Th... |
#!/usr/bin/env python3
#author : <NAME> <EMAIL>
#name : terminal.py
#purpose : Foundation for terminal commands and possible GUI linkage
#date : 2018.02.02
#version: 1.0.2
#version notes (latest): Optimized for python2/3
import os
import sys
from multiprocessing import Process
#For multiprocessing docs: https://do... | [
"os.path.isfile",
"sys.exit"
] | [((481, 508), 'os.path.isfile', 'os.path.isfile', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (495, 508), False, 'import os\n'), ((586, 596), 'sys.exit', 'sys.exit', ([], {}), '()\n', (594, 596), False, 'import sys\n'), ((1183, 1193), 'sys.exit', 'sys.exit', ([], {}), '()\n', (1191, 1193), False, 'import sys\n')] |
from typing import Callable, Any, Dict, List
import bakkesmod
from bakkesmod import cvarManager, gameWrapper
__all__ = ['HookEvent', 'HookEventWithCaller', 'UnhookEvent', 'HookEventPost', 'HookEventWithCallerPost', 'UnhookEventPost',
'SetTimeout', 'Execute', 'RegisterDrawable', 'RegisterNotifier']
_hooks_... | [
"bakkesmod.cvarManager.registerNotifier",
"bakkesmod.gameWrapper.HookEventWithCallerPost",
"bakkesmod.gameWrapper.HookEventPost",
"bakkesmod.gameWrapper.HookEventWithCaller",
"bakkesmod.gameWrapper.Execute",
"bakkesmod.gameWrapper.RegisterDrawable",
"bakkesmod.gameWrapper.SetTimeout",
"bakkesmod.gameW... | [((4729, 4768), 'bakkesmod.gameWrapper.SetTimeout', 'gameWrapper.SetTimeout', (['theLambda', 'time'], {}), '(theLambda, time)\n', (4751, 4768), False, 'from bakkesmod import cvarManager, gameWrapper\n'), ((4862, 4892), 'bakkesmod.gameWrapper.Execute', 'gameWrapper.Execute', (['theLambda'], {}), '(theLambda)\n', (4881, ... |
import logging
from ecl import connection
from eclcli.common import utils
LOG = logging.getLogger(__name__)
DEFAULT_API_VERSION = '2.0'
API_VERSION_OPTION = 'os_network_api_version'
API_NAME = "network"
API_VERSIONS = {
"2.0": "openstack.connection.Connection",
"2": "openstack.connection.Connection",
}
d... | [
"logging.getLogger",
"networkclient.v2.client.Client"
] | [((84, 111), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (101, 111), False, 'import logging\n'), ((412, 459), 'networkclient.v2.client.Client', 'network_client.Client', ([], {'session': 'instance.session'}), '(session=instance.session)\n', (433, 459), True, 'from networkclient.v2 impor... |
import numpy
from scipy.ndimage.filters import gaussian_filter as gf
from scipy.special import expit
import sys
import os
import matplotlib.pyplot as plt
import imageio.core
#config
rootDir = 'd:/projects/astronomy/tgas/'
#code
number_of_bins = 2
w = 800//number_of_bins
argv = sys.argv
hotSlice... | [
"scipy.ndimage.filters.gaussian_filter",
"scipy.special.expit",
"numpy.dsplit",
"numpy.zeros",
"os.path.isdir",
"os.mkdir"
] | [((568, 608), 'numpy.zeros', 'numpy.zeros', ([], {'shape': '(w * 2, w * 2, w * 2)'}), '(shape=(w * 2, w * 2, w * 2))\n', (579, 608), False, 'import numpy\n'), ((1273, 1303), 'scipy.ndimage.filters.gaussian_filter', 'gf', (['a'], {'sigma': 'sigma', 'truncate': '(3)'}), '(a, sigma=sigma, truncate=3)\n', (1275, 1303), Tru... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# SOURCE: https://github.com/s0md3v/Photon/wiki/Photon-Library
# pip install photon
import photon
photon.crawl('https://github.com/s0md3v/Photon/wiki/Photon-Library')
result = photon.result()
print(result)
with open('result.json', 'w', encoding=... | [
"photon.result",
"photon.crawl",
"json.dump"
] | [((172, 240), 'photon.crawl', 'photon.crawl', (['"""https://github.com/s0md3v/Photon/wiki/Photon-Library"""'], {}), "('https://github.com/s0md3v/Photon/wiki/Photon-Library')\n", (184, 240), False, 'import photon\n'), ((250, 265), 'photon.result', 'photon.result', ([], {}), '()\n', (263, 265), False, 'import photon\n'),... |
# Import modules
from win32api import EnumDisplayDevices, EnumDisplaySettings, ChangeDisplaySettingsEx
from win32con import ENUM_CURRENT_SETTINGS, DMDO_DEFAULT, DMDO_90, DMDO_180, DMDO_270
# Variables
Rotations = {
'0': DMDO_DEFAULT,
'90': DMDO_90,
'180': DMDO_180,
'270': DMDO_270
}
# Monitor posi... | [
"win32api.ChangeDisplaySettingsEx",
"win32api.EnumDisplayDevices",
"win32api.EnumDisplaySettings"
] | [((468, 495), 'win32api.EnumDisplayDevices', 'EnumDisplayDevices', (['None', '(0)'], {}), '(None, 0)\n', (486, 495), False, 'from win32api import EnumDisplayDevices, EnumDisplaySettings, ChangeDisplaySettingsEx\n'), ((502, 563), 'win32api.EnumDisplaySettings', 'EnumDisplaySettings', (['Device.DeviceName', 'ENUM_CURRENT... |
import gym
import pytest
from atari_wrappers import wrap_deepmind
from models import DQN
from agents import DQAgent
@pytest.fixture
def agent():
env = wrap_deepmind(gym.make('Pong-v0'), frame_stack=True)
q_network = DQN(env.action_space.n).cuda()
return DQAgent(q_network, env)
def test_epsilon_decay(ag... | [
"models.DQN",
"agents.DQAgent",
"gym.make"
] | [((269, 292), 'agents.DQAgent', 'DQAgent', (['q_network', 'env'], {}), '(q_network, env)\n', (276, 292), False, 'from agents import DQAgent\n'), ((172, 191), 'gym.make', 'gym.make', (['"""Pong-v0"""'], {}), "('Pong-v0')\n", (180, 191), False, 'import gym\n'), ((227, 250), 'models.DQN', 'DQN', (['env.action_space.n'], {... |
import sys
import argparse
from time import time
import random
from se_scraper import query, get_links
from csvsaver import SaveToCSV
def get_parser():
parser = argparse.ArgumentParser(
description='Search engine scraping via the command line')
parser.add_argument('query', metavar='QUERY', type=str... | [
"se_scraper.query",
"csvsaver.SaveToCSV",
"argparse.ArgumentParser"
] | [((170, 257), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Search engine scraping via the command line"""'}), "(description=\n 'Search engine scraping via the command line')\n", (193, 257), False, 'import argparse\n'), ((1648, 1677), 'csvsaver.SaveToCSV', 'SaveToCSV', (['output_file... |
from functools import reduce
from operator import mul
from quantecon import cartesian
import numpy as np
from numpy import zeros
def prod(l): return reduce(mul, l, 1.0)
from dolo.numeric.misc import mlinspace
class Grid:
def nodes(self):
return self.__nodes__
def n_nodes(self):
return self... | [
"functools.reduce",
"dolo.numeric.misc.mlinspace",
"interpolation.smolyak.SmolyakGrid",
"numpy.array",
"numpy.zeros",
"numpy.concatenate",
"quantecon.cartesian"
] | [((151, 170), 'functools.reduce', 'reduce', (['mul', 'l', '(1.0)'], {}), '(mul, l, 1.0)\n', (157, 170), False, 'from functools import reduce\n'), ((665, 680), 'numpy.array', 'np.array', (['point'], {}), '(point)\n', (673, 680), True, 'import numpy as np\n'), ((912, 940), 'numpy.array', 'np.array', (['nodes'], {'dtype':... |
#Password Generator Project
import random
letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
numbers... | [
"random.choice",
"random.shuffle"
] | [((2318, 2342), 'random.shuffle', 'random.shuffle', (['password'], {}), '(password)\n', (2332, 2342), False, 'import random\n'), ((2226, 2248), 'random.choice', 'random.choice', (['symbols'], {}), '(symbols)\n', (2239, 2248), False, 'import random\n'), ((2294, 2316), 'random.choice', 'random.choice', (['numbers'], {}),... |
import fcntl
import os
import select
import shlex
import signal
import threading
import time
from subprocess import Popen, PIPE
from performance.driver.core.events import Event, LogLineEvent, ParameterUpdateEvent, TeardownEvent, StartEvent
from performance.driver.core.template import TemplateString, TemplateDict
from... | [
"select.select",
"os.getpgid",
"shlex.split",
"subprocess.Popen",
"performance.driver.core.reflection.subscribesToHint",
"time.sleep",
"performance.driver.core.events.LogLineEvent",
"threading.Thread",
"performance.driver.core.reflection.publishesHint",
"time.time",
"performance.driver.core.even... | [((4016, 4081), 'performance.driver.core.reflection.subscribesToHint', 'subscribesToHint', (['ParameterUpdateEvent', 'TeardownEvent', 'StartEvent'], {}), '(ParameterUpdateEvent, TeardownEvent, StartEvent)\n', (4032, 4081), False, 'from performance.driver.core.reflection import subscribesToHint, publishesHint\n'), ((514... |
import os
import pwd
import unittest
from carbonate import config
class ConfigTest(unittest.TestCase):
simple_config = "tests/conf/simple.conf"
real_config = "tests/conf/realistic.conf"
def test_config_replication_factor(self):
c = config.Config(self.simple_config)
self.assertEqual(c.r... | [
"os.getuid",
"carbonate.config.Config"
] | [((257, 290), 'carbonate.config.Config', 'config.Config', (['self.simple_config'], {}), '(self.simple_config)\n', (270, 290), False, 'from carbonate import config\n'), ((397, 430), 'carbonate.config.Config', 'config.Config', (['self.simple_config'], {}), '(self.simple_config)\n', (410, 430), False, 'from carbonate impo... |
import numpy as np
from gym import utils, spaces
from gym.envs.mujoco import mujoco_env
from gym.envs.robotics.rotations import quat2euler, euler2quat, mat2euler
import os
# import random
from random import uniform, randint, randrange
from mjremote import mjremote
import time
from doorenv2.envs.doorenv import DoorEnv
... | [
"random.uniform",
"numpy.array",
"numpy.zeros",
"gym.utils.EzPickle.__init__",
"numpy.random.randint",
"numpy.concatenate",
"numpy.random.uniform"
] | [((845, 874), 'gym.utils.EzPickle.__init__', 'utils.EzPickle.__init__', (['self'], {}), '(self)\n', (868, 874), False, 'from gym import utils, spaces\n'), ((947, 987), 'numpy.array', 'np.array', (['[a[-1], -a[-1], a[-1], -a[-1]]'], {}), '([a[-1], -a[-1], a[-1], -a[-1]])\n', (955, 987), True, 'import numpy as np\n'), ((... |
import re
def cleanWordlist(file):
words = open(file,'r', -1,'utf-8')
write = open(file,'w', -1,'utf-8')
for line in words:
word = line.strip()
word = re.sub('[^\u0980-\u09FF]+', '', word)
write.write(m + "\n")
words.close(file,)
write.close()
input = '..\\F... | [
"re.sub"
] | [((191, 223), 're.sub', 're.sub', (['"""[^ঀ-\u09ff]+"""', '""""""', 'word'], {}), "('[^ঀ-\\u09ff]+', '', word)\n", (197, 223), False, 'import re\n')] |
from unittest import TestCase
from guet.commands.scriptcommands.postcommit.postcommit_factory import PostCommitFactory
from guet.commands.scriptcommands.postcommit.postcommit_strategy import PostCommitStrategy
from guet.settings.settings import Settings
class TestPostCommitFactory(TestCase):
def test_returns_po... | [
"guet.commands.scriptcommands.postcommit.postcommit_factory.PostCommitFactory"
] | [((364, 383), 'guet.commands.scriptcommands.postcommit.postcommit_factory.PostCommitFactory', 'PostCommitFactory', ([], {}), '()\n', (381, 383), False, 'from guet.commands.scriptcommands.postcommit.postcommit_factory import PostCommitFactory\n')] |
from base64 import b64encode
import cloudpickle
import requests
from requests.compat import urljoin
class API:
send_task_endpoint = 'user/submit_tasks'
get_answer_endpoint = 'user/request_answers'
get_stream_endpoint = 'user/request_from_stream'
estimate_time_left_endpoint = 'user/estimate_time_lef... | [
"cloudpickle.dumps",
"requests.compat.urljoin"
] | [((1079, 1114), 'requests.compat.urljoin', 'urljoin', (['self.server_addr', 'endpoint'], {}), '(self.server_addr, endpoint)\n', (1086, 1114), False, 'from requests.compat import urljoin\n'), ((1338, 1373), 'requests.compat.urljoin', 'urljoin', (['self.server_addr', 'endpoint'], {}), '(self.server_addr, endpoint)\n', (1... |
# coding=utf-8
# Copyright 2021 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 ... | [
"absl.testing.parameterized.parameters",
"absl.testing.absltest.main",
"learned_optimization.tasks.test_utils.smoketest_task"
] | [((1206, 1237), 'absl.testing.parameterized.parameters', 'parameterized.parameters', (['tasks'], {}), '(tasks)\n', (1230, 1237), False, 'from absl.testing import parameterized\n'), ((1383, 1398), 'absl.testing.absltest.main', 'absltest.main', ([], {}), '()\n', (1396, 1398), False, 'from absl.testing import absltest\n')... |
import numpy as np
from BDMesh.Mesh1D import Mesh1D
MyMesh = Mesh1D(0.0, 10.0, 0.0, 0.0)
print(MyMesh)
print(MyMesh.physical_boundary_1)
MyMesh.physical_boundary_1 = 2
print(MyMesh.physical_boundary_1)
MyMesh2 = Mesh1D(2.0, 10.0, 0.0, 0.0)
print(MyMesh)
print(MyMesh2)
print(MyMesh == MyMesh2)
print(MyMesh == 2)
... | [
"BDMesh.Mesh1D.Mesh1D",
"numpy.linspace"
] | [((63, 90), 'BDMesh.Mesh1D.Mesh1D', 'Mesh1D', (['(0.0)', '(10.0)', '(0.0)', '(0.0)'], {}), '(0.0, 10.0, 0.0, 0.0)\n', (69, 90), False, 'from BDMesh.Mesh1D import Mesh1D\n'), ((217, 244), 'BDMesh.Mesh1D.Mesh1D', 'Mesh1D', (['(2.0)', '(10.0)', '(0.0)', '(0.0)'], {}), '(2.0, 10.0, 0.0, 0.0)\n', (223, 244), False, 'from BD... |
from decimal import Decimal
from typing import Iterable, Optional, TypeVar
from stock_indicators._cslib import CsIndicator
from stock_indicators._cstypes import List as CsList
from stock_indicators._cstypes import Decimal as CsDecimal
from stock_indicators._cstypes import to_pydecimal
from stock_indicators.indicators.... | [
"stock_indicators._cstypes.Decimal",
"stock_indicators._cstypes.to_pydecimal",
"stock_indicators._cstypes.List",
"typing.TypeVar"
] | [((2006, 2036), 'typing.TypeVar', 'TypeVar', (['"""_T"""'], {'bound': 'FCBResult'}), "('_T', bound=FCBResult)\n", (2013, 2036), False, 'from typing import Iterable, Optional, TypeVar\n'), ((1356, 1377), 'stock_indicators._cstypes.List', 'CsList', (['Quote', 'quotes'], {}), '(Quote, quotes)\n', (1362, 1377), True, 'from... |
import discord
from discord.ext import commands
#rewrite_compatible
class logs:
def __init__(self, bot):
self.bot = bot
async def on_command(self, ctx):
if ctx.message.guild == self.bot.get_guild(325842626601549827):
embed=discord.Embed(title=" ", color=0xffff00)
embed... | [
"discord.Embed"
] | [((262, 302), 'discord.Embed', 'discord.Embed', ([], {'title': '""" """', 'color': '(16776960)'}), "(title=' ', color=16776960)\n", (275, 302), False, 'import discord\n')] |
# Copyright 2019 <NAME>
#
# 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, ... | [
"tensorflow.variable_scope",
"tensorflow.layers.flatten",
"tensorflow.nn.relu",
"tensorflow.contrib.layers.variance_scaling_initializer",
"tensorflow.layers.batch_normalization",
"tensorflow.zeros_initializer",
"tensorflow.layers.dense"
] | [((708, 800), 'tensorflow.contrib.layers.variance_scaling_initializer', 'tf.contrib.layers.variance_scaling_initializer', ([], {'factor': '(2.0)', 'mode': '"""FAN_IN"""', 'uniform': '(False)'}), "(factor=2.0, mode='FAN_IN',\n uniform=False)\n", (754, 800), True, 'import tensorflow as tf\n'), ((806, 828), 'tensorflow... |
import os
import sys
import warnings
import glob
import cv2
import numpy as np
from io_utils import PostprocessUtils
from io_utils import LabelFilter
class AnnotationWriter():
def __init__(self, cfg):
self.base_path = cfg.BASE_PATH
self.data_def = cfg.DATA_DEF[0]
self.batch_glob = cfg.... | [
"numpy.unique",
"numpy.where",
"os.path.join",
"cv2.imread",
"glob.glob"
] | [((449, 491), 'os.path.join', 'os.path.join', (['self.base_path', 'cfg.OUT_FILE'], {}), '(self.base_path, cfg.OUT_FILE)\n', (461, 491), False, 'import os\n'), ((1370, 1415), 'os.path.join', 'os.path.join', (['self.base_path', 'self.batch_glob'], {}), '(self.base_path, self.batch_glob)\n', (1382, 1415), False, 'import o... |
from PyQt4 import QtGui
from blocks.Block import Block
from blocks.FactoryRenderableBlock import FactoryRenderableBlock
import re
class PageDrawerLoadingUtils():
def __init__(self):
pass
def loadBlockDrawerSets(block_drawersets, manager):
import json
if(block_drawersets == ''): return
... | [
"json.load",
"PyQt4.QtGui.QColor",
"blocks.Block.Block.createBlock",
"re.match"
] | [((365, 377), 'json.load', 'json.load', (['f'], {}), '(f)\n', (374, 377), False, 'import json\n'), ((1539, 1566), 're.match', 're.match', (['pattern', 'opt_item'], {}), '(pattern, opt_item)\n', (1547, 1566), False, 'import re\n'), ((736, 766), 'PyQt4.QtGui.QColor', 'QtGui.QColor', (['(100)', '(100)', '(100)', '(0)'], {... |
# -*- coding: utf-8 -*-
import pandas as pd
from zoo.calculator import ZooCalculator
import unittest
class CalculateTestSuite(unittest.TestCase):
def setUp(self):
"""
populate test dataframes
:return:
"""
animals_d = {'animal': ["tiger", "leopard", "pelican"],
... | [
"unittest.main",
"zoo.calculator.ZooCalculator",
"pandas.DataFrame"
] | [((2305, 2320), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2318, 2320), False, 'import unittest\n'), ((665, 693), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': 'animals_d'}), '(data=animals_d)\n', (677, 693), True, 'import pandas as pd\n'), ((813, 838), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': 'f... |
import sys
import time
import pygame
from gen_new_updated_file import gen_file, format_prog
registers = [0] * 128
main_reg = 0
where_in_regs = 0
should_replace = False
replace_with = None
with open('data.py', 'r') as f:
commands_dict = eval(f.read())
pygame.init()
screen = pygame.display.set_mode((512, 512))
w... | [
"pygame.init",
"gen_new_updated_file.format_prog",
"pygame.display.set_mode",
"pygame.display.flip",
"pygame.gfxdraw.pixel",
"time.sleep",
"sys.exit"
] | [((259, 272), 'pygame.init', 'pygame.init', ([], {}), '()\n', (270, 272), False, 'import pygame\n'), ((282, 317), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(512, 512)'], {}), '((512, 512))\n', (305, 317), False, 'import pygame\n'), ((4366, 4382), 'gen_new_updated_file.format_prog', 'format_prog', (['exe'... |
#==============================================================================
# Copyright 2011 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.
# You may obtain a copy of the ... | [
"logging.warn"
] | [((869, 937), 'logging.warn', 'logging.warn', (["('Unsupported OS for setting owner/group: %s' % os.name)"], {}), "('Unsupported OS for setting owner/group: %s' % os.name)\n", (881, 937), False, 'import logging\n'), ((1016, 1079), 'logging.warn', 'logging.warn', (['"""Unsupported OS for user operations: %s"""', 'os.nam... |
# coding:utf-8
from LxGui.qt import qtCore, guiQtMdlAbs
class QtButtonTabbarModel(guiQtMdlAbs.Abs_GuiQtTabbarWgtModel):
def __init__(self, widget):
self._initTabBarModelBasic(widget)
# Tab Bar
class QtShelfTabbarModel(guiQtMdlAbs.Abs_GuiQtTabbarWgtModel):
def __init__(self, widget):
self._in... | [
"LxGui.qt.qtCore.QPainterPath_",
"LxGui.qt.qtCore.CLS_timer"
] | [((1451, 1473), 'LxGui.qt.qtCore.QPainterPath_', 'qtCore.QPainterPath_', ([], {}), '()\n', (1471, 1473), False, 'from LxGui.qt import qtCore, guiQtMdlAbs\n'), ((4010, 4032), 'LxGui.qt.qtCore.QPainterPath_', 'qtCore.QPainterPath_', ([], {}), '()\n', (4030, 4032), False, 'from LxGui.qt import qtCore, guiQtMdlAbs\n'), ((1... |
from __future__ import print_function
import re
from fabric.api import hide
from six.moves.urllib.request import urlopen
from burlap.constants import *
from burlap import ContainerSatchel
from burlap.decorators import task
def _to_int(val):
try:
return int(val)
except ValueError:
return val... | [
"re.compile",
"re.match",
"six.moves.urllib.request.urlopen",
"fabric.api.hide",
"burlap.system.get_arch",
"burlap.decorators.task",
"burlap.system.distrib_family"
] | [((346, 411), 're.compile', 're.compile', (['"""http[s]{0,1}://[^/]+/vagrant/[0-9\\\\.]+/vagrant[^"]+"""'], {}), '(\'http[s]{0,1}://[^/]+/vagrant/[0-9\\\\.]+/vagrant[^"]+\')\n', (356, 411), False, 'import re\n'), ((9251, 9288), 'burlap.decorators.task', 'task', ([], {'precursors': "['packager', 'user']"}), "(precursors... |
# -*- coding: utf-8 -*-
#
# Copyright (C) 2008-2011 Edgewall Software
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution. The terms
# are also available at http://babel.edgewall.org/wiki/License.
#
# This software consists... | [
"babel.Locale",
"babel.messages.plurals.get_plural"
] | [((1320, 1344), 'babel.messages.plurals.get_plural', 'plurals.get_plural', (['"""ja"""'], {}), "('ja')\n", (1338, 1344), False, 'from babel.messages import plurals\n'), ((993, 1019), 'babel.messages.plurals.get_plural', 'plurals.get_plural', (['locale'], {}), '(locale)\n', (1011, 1019), False, 'from babel.messages impo... |
"""this module returns information from the
config.json file"""
import json
import logging
logging.basicConfig(filename='pysys.log',level=logging.INFO, format='%(asctime)s %(levelname)-8s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
def get_key(k_type) -> str:
"""this function returns the API key for the ... | [
"logging.basicConfig",
"json.load",
"logging.info"
] | [((99, 244), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""pysys.log"""', 'level': 'logging.INFO', 'format': '"""%(asctime)s %(levelname)-8s %(message)s"""', 'datefmt': '"""%Y-%m-%d %H:%M:%S"""'}), "(filename='pysys.log', level=logging.INFO, format=\n '%(asctime)s %(levelname)-8s %(message)s', ... |
#!/usr/bin/env python
import argparse
import cv2
import time
import numpy as np
BLUE = 'blue'
GREEN = 'green'
RED = 'red'
ORANGE = 'orange'
YELLOW = 'yellow'
BGR = 'bgr'
HSV = 'hsv'
HSV_MIN = 'hsv_min'
HSV_MAX = 'hsv_max'
COLOUR_MAP = {
BLUE : {
HSV_MIN : (110, 50, 50),
HSV_MAX : (130, 255, 25... | [
"argparse.ArgumentParser",
"cv2.inRange",
"cv2.erode",
"numpy.fliplr",
"cv2.imshow",
"cv2.destroyAllWindows",
"cv2.VideoCapture",
"cv2.cvtColor",
"cv2.moments",
"cv2.waitKey",
"cv2.namedWindow"
] | [((935, 960), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (958, 960), False, 'import argparse\n'), ((1733, 1757), 'cv2.namedWindow', 'cv2.namedWindow', (['"""Input"""'], {}), "('Input')\n", (1748, 1757), False, 'import cv2\n'), ((1762, 1784), 'cv2.namedWindow', 'cv2.namedWindow', (['"""HSV""... |
import datetime
import os
import flask
from flask_login import login_required
from app.api import api
@api.route("/config/<name>", methods=["GET"])
@login_required
def get_config(name: str):
"""
Reads the file with the corresponding name that was passed.
:param name: Configuration file name
:type n... | [
"flask.render_template",
"os.path.exists",
"os.listdir",
"os.path.join",
"os.path.getmtime",
"os.symlink",
"os.path.isfile",
"os.remove",
"flask.request.get_json",
"flask.make_response",
"app.api.api.route",
"flask.jsonify"
] | [((107, 151), 'app.api.api.route', 'api.route', (['"""/config/<name>"""'], {'methods': "['GET']"}), "('/config/<name>', methods=['GET'])\n", (116, 151), False, 'from app.api import api\n'), ((647, 692), 'app.api.api.route', 'api.route', (['"""/config/<name>"""'], {'methods': "['POST']"}), "('/config/<name>', methods=['... |
def isBlank(myString:str):
return not (myString and myString.strip())
def isNotBlank(myString:str):
return bool(myString and myString.strip())
def trim(myString:str):
result = myString.strip() if myString != None else None
return result
def replace(myString:str, search:str, replace:str):
if m... | [
"uuid.uuid4"
] | [((676, 688), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (686, 688), False, 'import uuid\n')] |
from allennlp.common.util import JsonDict
from allennlp.data import DatasetReader
from allennlp.data.tokenizers import WordTokenizer
from allennlp.models import Model
from allennlp.service.predictors.predictor import Predictor
from overrides import overrides
from allennlp.data.tokenizers.word_splitter import SpacyWordS... | [
"allennlp.data.tokenizers.word_splitter.SpacyWordSplitter",
"allennlp.service.predictors.predictor.Predictor.register",
"propara.trainer_decoder.action_scorer.ActionScorerDummy"
] | [((455, 497), 'allennlp.service.predictors.predictor.Predictor.register', 'Predictor.register', (['"""prostruct_prediction"""'], {}), "('prostruct_prediction')\n", (473, 497), False, 'from allennlp.service.predictors.predictor import Predictor\n'), ((1173, 1205), 'allennlp.data.tokenizers.word_splitter.SpacyWordSplitte... |
import hindkit as kit
data = kit.constants.get_glyph_list("itfgl.txt", with_u_scalar=True)
with open("temp/itfgl.md", "w") as f:
f.write("# ITF Glyph List\n\n")
f.write("| | glyph name | scalar value and character name |\n")
f.write("| :---: | :--- | :--- |\n")
for glyph_name, (u_scalar, u_name) in li... | [
"hindkit.constants.get_glyph_list"
] | [((30, 91), 'hindkit.constants.get_glyph_list', 'kit.constants.get_glyph_list', (['"""itfgl.txt"""'], {'with_u_scalar': '(True)'}), "('itfgl.txt', with_u_scalar=True)\n", (58, 91), True, 'import hindkit as kit\n')] |