code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# -*- coding: utf-8 -*-
import os
import rpyc
from webs.api.exceptions.customs import InvalidAPIRequest, RecordNotFound
from webs.api.models.db_proxy import task_model_proxy, url_model_proxy, task_url_model_proxy, subtask_model_proxy, \
result_model_proxy, apscheduler_model_proxy, schedule_task_proxy
class TaskB... | [
"webs.api.models.db_proxy.schedule_task_proxy.db_session.query",
"webs.api.models.db_proxy.subtask_model_proxy.model.schedule_task_id.in_",
"webs.api.models.db_proxy.task_model_proxy.set_attr",
"webs.api.exceptions.customs.RecordNotFound",
"webs.api.models.db_proxy.task_model_proxy.find",
"webs.api.models... | [((947, 980), 'webs.api.models.db_proxy.task_model_proxy.create', 'task_model_proxy.create', ([], {}), '(**kwargs)\n', (970, 980), False, 'from webs.api.models.db_proxy import task_model_proxy, url_model_proxy, task_url_model_proxy, subtask_model_proxy, result_model_proxy, apscheduler_model_proxy, schedule_task_proxy\n... |
'''10.WAP to output a random number between 1 and 6'''
import random
x=random.randint(1,6)
print(x) | [
"random.randint"
] | [((71, 91), 'random.randint', 'random.randint', (['(1)', '(6)'], {}), '(1, 6)\n', (85, 91), False, 'import random\n')] |
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(0, 2 * np.pi, 50)
y = np.sin(x)
# plt.plot(x, y)
# plt.show()
# plt.plot(x, y)
# plt.plot(x, y * 2)
# plt.title("sin(x) & 2sin(x)")
# plt.show()
plt.plot(x, y, label="sin(x)")
plt.plot(x, y * 2, label="2sin(x)")
# plt.legend()
plt.legend(loc='best b... | [
"matplotlib.pyplot.plot",
"numpy.linspace",
"numpy.sin",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((57, 86), 'numpy.linspace', 'np.linspace', (['(0)', '(2 * np.pi)', '(50)'], {}), '(0, 2 * np.pi, 50)\n', (68, 86), True, 'import numpy as np\n'), ((91, 100), 'numpy.sin', 'np.sin', (['x'], {}), '(x)\n', (97, 100), True, 'import numpy as np\n'), ((216, 246), 'matplotlib.pyplot.plot', 'plt.plot', (['x', 'y'], {'label':... |
#!/usr/bin/python
# Get a list of error terms from the Vale rules and generate a correspoding asiidoc reference.
import glob
import os
import re
import shutil
import wget, zipfile
import git
import yaml
import json
import sys
def main():
try:
#initialize some variables
git_repo = git.Repo(os.pa... | [
"os.path.exists",
"wget.download",
"os.makedirs",
"shutil.move",
"zipfile.ZipFile",
"json.dumps",
"os.getcwd",
"os.chdir",
"sys.exc_info",
"os.path.split",
"yaml.safe_load",
"shutil.rmtree",
"re.sub",
"re.findall",
"glob.glob",
"os.remove"
] | [((1725, 1749), 'os.path.exists', 'os.path.exists', (['temp_dir'], {}), '(temp_dir)\n', (1739, 1749), False, 'import os\n'), ((1827, 1853), 'glob.glob', 'glob.glob', (["(temp_dir + '/*')"], {}), "(temp_dir + '/*')\n", (1836, 1853), False, 'import glob\n'), ((2025, 2043), 'os.chdir', 'os.chdir', (['temp_dir'], {}), '(te... |
"""Building a relational graph for proteins with MongoDB backend."""
import argparse
import matplotlib.pyplot as plt
from ipcrg.interfaces.mongo import MongoDBInterface
from ipcrg.entities.protein import Protein
from ipcrg.relations.ppi import PPI
parser = argparse.ArgumentParser()
parser.add_argument(
'-f', '--fi... | [
"ipcrg.interfaces.mongo.MongoDBInterface",
"argparse.ArgumentParser",
"matplotlib.pyplot.show"
] | [((258, 283), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (281, 283), False, 'import argparse\n'), ((854, 918), 'ipcrg.interfaces.mongo.MongoDBInterface', 'MongoDBInterface', ([], {'uri': 'args.uri', 'database_name': 'args.database_name'}), '(uri=args.uri, database_name=args.database_name)\n... |
import pytest
from munch import DefaultMunch
from market_maker.orders_manager import OrdersManager
from market_maker.gateways import gateway_interface
from market_maker.definitions import (
ApiResult,
OrderRequest,
OrderType,
OrderSide,
)
class bittest_storage():
def __init__(self):
self... | [
"munch.DefaultMunch",
"market_maker.definitions.ApiResult",
"market_maker.orders_manager.OrdersManager",
"market_maker.definitions.OrderRequest"
] | [((2347, 2369), 'market_maker.orders_manager.OrdersManager', 'OrdersManager', (['adapter'], {}), '(adapter)\n', (2360, 2369), False, 'from market_maker.orders_manager import OrdersManager\n'), ((2387, 2401), 'market_maker.definitions.OrderRequest', 'OrderRequest', ([], {}), '()\n', (2399, 2401), False, 'from market_mak... |
"""
Date August 1, 2018
Author <NAME>
mincut takes in a graph object, and attempts to find a mincut
"""
from graph import DictGraph
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
"""
We repeat the following step: pick and edge uniformly at random
and merge the two vertices at its endpoint... | [
"networkx.MultiGraph",
"networkx.is_connected",
"networkx.contracted_edge"
] | [((1599, 1614), 'networkx.MultiGraph', 'nx.MultiGraph', ([], {}), '()\n', (1612, 1614), True, 'import networkx as nx\n'), ((990, 1008), 'networkx.is_connected', 'nx.is_connected', (['g'], {}), '(g)\n', (1005, 1008), True, 'import networkx as nx\n'), ((1375, 1427), 'networkx.contracted_edge', 'nx.contracted_edge', (['g'... |
from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.autograd import Variable
from numpy.random import normal
from math import sqrt
import numpy as np
import math
import os.path as osp
from utils import *
import t... | [
"torch.nn.init.kaiming_normal",
"torch.nn.ReLU",
"torch.nn.Linear",
"torch.nn.Conv2d"
] | [((482, 534), 'torch.nn.Conv2d', 'nn.Conv2d', (['(1)', '(16)'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)'}), '(1, 16, kernel_size=3, stride=1, padding=1)\n', (491, 534), True, 'import torch.nn as nn\n'), ((571, 592), 'torch.nn.ReLU', 'nn.ReLU', ([], {'inplace': '(True)'}), '(inplace=True)\n', (578, 592),... |
#!/usr/bin/env python3
# ---------------------------------------------------------------------------
# Copyright 2016-2021 <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... | [
"logging.getLogger",
"logging.StreamHandler",
"logging.Formatter",
"logging.handlers.RotatingFileHandler",
"platform.system",
"logging.FileHandler"
] | [((907, 940), 'logging.getLogger', 'logging.getLogger', (['"""ar3_mailrepo"""'], {}), "('ar3_mailrepo')\n", (924, 940), False, 'import logging\n'), ((1369, 1471), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s [%(levelname)s:%(name)s] %(message)s"""'], {'datefmt': '"""%Y-%m-%d %H:%M:%S"""'}), "('%(asctime)... |
import haiku as hk
import jax
import jax.numpy as jnp
LRELU_SLOPE = 0.1
def get_padding(kernel_size, dilation=1):
p = int((kernel_size * dilation - dilation) / 2)
return ((p, p), )
class ResBlock1(hk.Module):
def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5), name="resblock1"):
super().__... | [
"jax.numpy.tanh",
"haiku.Conv1DTranspose",
"jax.nn.leaky_relu",
"haiku.Conv1D"
] | [((1619, 1681), 'haiku.Conv1D', 'hk.Conv1D', (['h.upsample_initial_channel', '(7)', '(1)'], {'padding': '((3, 3),)'}), '(h.upsample_initial_channel, 7, 1, padding=((3, 3),))\n', (1628, 1681), True, 'import haiku as hk\n'), ((2349, 2386), 'haiku.Conv1D', 'hk.Conv1D', (['(1)', '(7)', '(1)'], {'padding': '((3, 3),)'}), '(... |
import networkx as nx
import matplotlib.pyplot as plt
toy_network = nx.barbell_graph(10, 14)
node_options = {
'node_color': 'royalblue',
'node_size': 50,
'edgecolors': 'white',
}
edge_options = {
'line_color': 'grey',
'alpha': 0.7,
}
pos = nx.circular_layout(toy_network)
nx.draw_networkx_nodes... | [
"networkx.circular_layout",
"networkx.draw_networkx_nodes",
"matplotlib.pyplot.axes",
"matplotlib.pyplot.axis",
"networkx.draw_networkx_edges",
"networkx.barbell_graph"
] | [((70, 94), 'networkx.barbell_graph', 'nx.barbell_graph', (['(10)', '(14)'], {}), '(10, 14)\n', (86, 94), True, 'import networkx as nx\n'), ((266, 297), 'networkx.circular_layout', 'nx.circular_layout', (['toy_network'], {}), '(toy_network)\n', (284, 297), True, 'import networkx as nx\n'), ((298, 354), 'networkx.draw_n... |
# implement test cases for the Product router
import pytest
import json
@pytest.fixture(autouse=True, scope="function")
def run_around_tests():
setup()
yield
teardown()
def setup():
pass
def teardown():
pass
def test_get_all_products(test_app):
response = test_app.get("/products")
as... | [
"pytest.fixture"
] | [((75, 121), 'pytest.fixture', 'pytest.fixture', ([], {'autouse': '(True)', 'scope': '"""function"""'}), "(autouse=True, scope='function')\n", (89, 121), False, 'import pytest\n')] |
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivat... | [
"qiskit.circuit.QuantumCircuit",
"qiskit.quantum_info.operators.Operator",
"qiskit.converters.circuit_to_dag",
"qiskit.transpiler.passes.UnitarySynthesis",
"ddt.data",
"unittest.main"
] | [((1242, 1369), 'ddt.data', 'data', (["['u3', 'cx']", "['u1', 'u2', 'u3', 'cx']", "['rx', 'ry', 'rxx']", "['rx', 'rz', 'iswap']", "['u3', 'rx', 'rz', 'cz', 'iswap']"], {}), "(['u3', 'cx'], ['u1', 'u2', 'u3', 'cx'], ['rx', 'ry', 'rxx'], ['rx',\n 'rz', 'iswap'], ['u3', 'rx', 'rz', 'cz', 'iswap'])\n", (1246, 1369), Fal... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# sync_read_write.py
#
# Created on: 2016. 6. 16.
# Author: <NAME> (Leon)
#
#
# ********* Sync Read and Sync Write Example *********
#
#
# Available Dynamixel model on this example : All models using Protocol 2.0
# This example is designed for using two D... | [
"dynamixel_functions.setBaudRate",
"dynamixel_functions.closePort",
"dynamixel_functions.getLastTxRxResult",
"time.sleep",
"dynamixel_functions.write2ByteTxRx",
"dynamixel_functions.groupSyncReadTxRxPacket",
"sys.stdin.read",
"dynamixel_functions.groupSyncReadGetData",
"sys.stdin.fileno",
"os.sys.... | [((1047, 1094), 'os.sys.path.append', 'os.sys.path.append', (['"""../dynamixel_functions_py"""'], {}), "('../dynamixel_functions_py')\n", (1065, 1094), False, 'import os, ctypes, time\n'), ((3324, 3357), 'dynamixel_functions.portHandler', 'dynamixel.portHandler', (['DEVICENAME'], {}), '(DEVICENAME)\n', (3345, 3357), Tr... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Author : <NAME>
# @Email : <EMAIL>
# @Time : 19-9-3 上午7:19
# @Version : 1.0
# @File : api_urls
# @Software : PyCharm
from certs import api
from rest_framework_bulk.routes import BulkRouter
app_name = 'certs'
router = ... | [
"rest_framework_bulk.routes.BulkRouter"
] | [((320, 332), 'rest_framework_bulk.routes.BulkRouter', 'BulkRouter', ([], {}), '()\n', (330, 332), False, 'from rest_framework_bulk.routes import BulkRouter\n')] |
import numpy as np
import time
import torch
import torch.nn as nn
import os
from tqdm import tqdm as tqdm
import sys;
import math
import skimage.io as io
import cv2
from skimage import filters
from skimage.measure import label, moments
import glob
from model_arch import UnetVggMultihead
from my_dataloader_w_kfunc impo... | [
"torch.nn.L1Loss",
"numpy.array",
"torch.nn.Sigmoid",
"os.path.exists",
"numpy.where",
"os.mkdir",
"skimage.measure.moments",
"sys.stdout.flush",
"my_dataloader.CellsDataset",
"my_dataloader_w_kfunc.CellsDataset",
"cv2.moments",
"time.time",
"model_arch.UnetVggMultihead",
"torch.device",
... | [((1393, 1452), 'os.path.join', 'os.path.join', (['checkpoints_root_dir', 'checkpoints_folder_name'], {}), '(checkpoints_root_dir, checkpoints_folder_name)\n', (1405, 1452), False, 'import os\n'), ((1483, 1547), 'os.path.join', 'os.path.join', (['clustering_pseudo_gt_root', 'checkpoints_folder_name'], {}), '(clustering... |
from django.contrib import admin
from django.contrib.auth import get_user_model
from iam.contrib.users.admin import IAMUserAdmin
User = get_user_model()
admin.site.register(User, IAMUserAdmin)
| [
"django.contrib.auth.get_user_model",
"django.contrib.admin.site.register"
] | [((138, 154), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (152, 154), False, 'from django.contrib.auth import get_user_model\n'), ((156, 195), 'django.contrib.admin.site.register', 'admin.site.register', (['User', 'IAMUserAdmin'], {}), '(User, IAMUserAdmin)\n', (175, 195), False, 'from dja... |
from camera.camera_object_detection_data import CameraObjectDetectionData
import numpy
import dataclasses
import datetime
import json
from utils.dict import remove_null_keys
import uuid
from io import BytesIO
from typing import List, Callable, Optional
from camera.camera_recording import CameraRecording
from loggers i... | [
"json.JSONEncoder.default",
"dataclasses.asdict",
"utils.dict.remove_null_keys",
"json.dumps",
"uuid.uuid4",
"datetime.datetime.now",
"loggers.LOGGER.info",
"utils.time.is_time_lapsed"
] | [((1205, 1240), 'json.JSONEncoder.default', 'json.JSONEncoder.default', (['self', 'obj'], {}), '(self, obj)\n', (1229, 1240), False, 'import json\n'), ((2490, 2513), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (2511, 2513), False, 'import datetime\n'), ((3381, 3408), 'dataclasses.asdict', 'datac... |
import datetime
from django.db import migrations, models
def copy_duration_from_days_to_expire_to_time_to_expire(apps, schema_editor):
JobPost = apps.get_model('job_board', 'JobPost')
for job_post in JobPost.objects.all():
job_post.time_to_expire = datetime.timedelta(days=job_post.days_to_expire)
... | [
"datetime.timedelta",
"django.db.migrations.RunPython"
] | [((267, 315), 'datetime.timedelta', 'datetime.timedelta', ([], {'days': 'job_post.days_to_expire'}), '(days=job_post.days_to_expire)\n', (285, 315), False, 'import datetime\n'), ((488, 561), 'django.db.migrations.RunPython', 'migrations.RunPython', (['copy_duration_from_days_to_expire_to_time_to_expire'], {}), '(copy_d... |
import discord
import os
import random
import re
regex = re.compile(
'.[Mm][Ee][Mm][Ee]( |$)')
async def run(escaped_prefix, message, db, credentials):
c = db.cursor()
# Check whether it is enabled for this channel
c.execute(
'''
select c_meme, meme_filter from servers where s_id ... | [
"os.listdir",
"random.choice",
"re.compile",
"os.path.join",
"re.findall",
"discord.File"
] | [((58, 94), 're.compile', 're.compile', (['""".[Mm][Ee][Mm][Ee]( |$)"""'], {}), "('.[Mm][Ee][Mm][Ee]( |$)')\n", (68, 94), False, 'import re\n'), ((824, 901), 're.findall', 're.findall', (['"""^.....( *)((?:[Ss][Uu][Bb][Mm][Ii][Tt]$)?)(.*)"""', 'message.content'], {}), "('^.....( *)((?:[Ss][Uu][Bb][Mm][Ii][Tt]$)?)(.*)',... |
import pytest
from django.contrib.auth import get_user_model
from django.contrib.auth.hashers import make_password
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APIClient
from core.models import Tag, User
from recipe.serializers import TagSerializer
TAGS_URLS = r... | [
"django.contrib.auth.get_user_model",
"django.contrib.auth.hashers.make_password",
"core.models.Tag.objects.create",
"rest_framework.test.APIClient",
"recipe.serializers.TagSerializer",
"django.urls.reverse",
"pytest.fixture",
"core.models.Tag.objects.all"
] | [((319, 345), 'django.urls.reverse', 'reverse', (['"""recipe:tag-list"""'], {}), "('recipe:tag-list')\n", (326, 345), False, 'from django.urls import reverse\n'), ((490, 506), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (504, 506), False, 'import pytest\n'), ((553, 569), 'pytest.fixture', 'pytest.fixture', ([... |
#!/usr/bin/python
import time
import json
import okapi
import sys
okapi = okapi.Okapi()
# later: space_monitor = space_monitor.SpaceMonitor()
response = okapi.init(YOUR_LOGIN_AS_STRING, YOUR_PASSWORD_AS_STRING)
print("Initialization result status: " + str(response["status"]))
if response["status"]["type"] == "FATA... | [
"okapi.tdms.add",
"okapi.tdms.get",
"okapi.Okapi",
"sys.exit",
"okapi.init"
] | [((78, 91), 'okapi.Okapi', 'okapi.Okapi', ([], {}), '()\n', (89, 91), False, 'import okapi\n'), ((157, 214), 'okapi.init', 'okapi.init', (['YOUR_LOGIN_AS_STRING', 'YOUR_PASSWORD_AS_STRING'], {}), '(YOUR_LOGIN_AS_STRING, YOUR_PASSWORD_AS_STRING)\n', (167, 214), False, 'import okapi\n'), ((350, 366), 'okapi.tdms.get', 'o... |
import pytest
from password_meter import Password
from constants import ALL, USE_LETTERS, USE_DIGITS, USE_PUNCTATIONS
# set up fixture
@pytest.fixture(scope='module')
def password():
pswd = Password(':<PASSWORD>#')
yield pswd
def test_attributes(password):
assert isinstance(password, Password)
asse... | [
"pytest.fixture",
"password_meter.Password"
] | [((139, 169), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (153, 169), False, 'import pytest\n'), ((197, 221), 'password_meter.Password', 'Password', (['""":<PASSWORD>#"""'], {}), "(':<PASSWORD>#')\n", (205, 221), False, 'from password_meter import Password\n'), ((1744, 175... |
# Copyright 2020 Curtin University
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writi... | [
"click.Choice",
"click.confirm",
"os.path.exists",
"observatory.platform.utils.config_utils.terraform_credentials_path",
"click.group",
"click.option",
"observatory.platform.cli.terraform_command.TerraformCommand",
"observatory.platform.cli.click_utils.indent",
"observatory.platform.cli.generate_com... | [((1791, 1804), 'click.group', 'click.group', ([], {}), '()\n', (1802, 1804), False, 'import click\n'), ((3791, 3970), 'click.option', 'click.option', (['"""--host-uid"""'], {'type': 'click.INT', 'default': 'HOST_UID', 'help': '"""The user id of the host system. Used to set the user id in the Docker containers."""', 's... |
"""
Denoising of colored images
Denoising of an image refers to the process of reconstruction of a signal from
noisy images. Denoising is done to remove unwanted noise from image to
analyze it in better form. It refers to one of the major pre-processing steps.
"""
# importing libraries
import cv2
impo... | [
"matplotlib.pyplot.imshow",
"cv2.fastNlMeansDenoisingColored",
"cv2.imread",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((392, 423), 'cv2.imread', 'cv2.imread', (['"""../images/taj.jpg"""'], {}), "('../images/taj.jpg')\n", (402, 423), False, 'import cv2\n'), ((477, 534), 'cv2.fastNlMeansDenoisingColored', 'cv2.fastNlMeansDenoisingColored', (['img', 'None', '(10)', '(10)', '(7)', '(15)'], {}), '(img, None, 10, 10, 7, 15)\n', (508, 534),... |
"""
Collects vppctl "show runtime max" command and parses it
"""
from prometheus_client import REGISTRY
from prometheus_client.metrics_core import GaugeMetricFamily
from collector.abstract_command_collector import AbstractCommandCollector
from collector.utils import add_gauge_metrics
from device import AbstractDevice... | [
"prometheus_client.metrics_core.GaugeMetricFamily"
] | [((1266, 1369), 'prometheus_client.metrics_core.GaugeMetricFamily', 'GaugeMetricFamily', (['"""epc_vppctl_runtime_max_node_clocks"""', '"""max node clocks by thread"""'], {'labels': 'labels'}), "('epc_vppctl_runtime_max_node_clocks',\n 'max node clocks by thread', labels=labels)\n", (1283, 1369), False, 'from promet... |
from flask import Flask, flash, request, session
from flask.templating import render_template
from werkzeug.utils import redirect, secure_filename
import bcrypt
from functions.users import check_existing_user, add_new_user, check_user_credentials
from functions.scheduler import add_medicine, fetch_user_schedule, card, ... | [
"flask.Flask",
"functions.scheduler.no_data_check",
"functions.medicines.get_all_medicines",
"functions.medscraper.get_medicines",
"werkzeug.utils.secure_filename",
"functions.scheduler.add_medicine",
"flask.session.clear",
"datetime.timedelta",
"functions.dashboard.tomorrow_card",
"os.remove",
... | [((744, 759), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (749, 759), False, 'from flask import Flask, flash, request, session\n'), ((1112, 1154), 'flask.templating.render_template', 'render_template', (['"""index.html"""'], {'login': 'login'}), "('index.html', login=login)\n", (1127, 1154), False, 'fro... |
from pytpp.attributes._helper import IterableMeta, Attribute
from pytpp.attributes.log_channel import LogChannelAttributes
class LogFilterAttributes(LogChannelAttributes, metaclass=IterableMeta):
__config_class__ = "Log Filter"
filter_ids = Attribute('Filter IDs')
filter_severity = Attribute('Filter Severity')
lo... | [
"pytpp.attributes._helper.Attribute"
] | [((245, 268), 'pytpp.attributes._helper.Attribute', 'Attribute', (['"""Filter IDs"""'], {}), "('Filter IDs')\n", (254, 268), False, 'from pytpp.attributes._helper import IterableMeta, Attribute\n'), ((288, 316), 'pytpp.attributes._helper.Attribute', 'Attribute', (['"""Filter Severity"""'], {}), "('Filter Severity')\n",... |
import setuptools
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="asyncnostic",
version="0.1.0",
author="<NAME>",
author_email="<EMAIL>",
description="simple way of using pytest with async unit tests",
long_description=long_description,
long_desc... | [
"setuptools.find_packages"
] | [((424, 450), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (448, 450), False, 'import setuptools\n')] |
import sys
import warnings
from copy import deepcopy
import itertools
import numpy as np
from scipy.stats import entropy, multivariate_normal
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
from sklearn.mixture.gaussian_mixture import _compute_precision_cholesky,\
_check_precision_mat... | [
"numpy.linalg.matrix_rank",
"numpy.linalg.pinv",
"numpy.random.rand",
"numpy.log",
"numpy.array",
"copy.deepcopy",
"numpy.linalg.norm",
"numpy.cov",
"numpy.save",
"sklearn.mixture.gaussian_mixture._check_precision_matrix",
"numpy.delete",
"pandas.DataFrame",
"numpy.identity",
"sklearn.mixt... | [((932, 952), 'numpy.zeros', 'np.zeros', (['covs.shape'], {}), '(covs.shape)\n', (940, 952), True, 'import numpy as np\n'), ((1411, 1559), 'sklearn.mixture.GaussianMixture', 'GaussianMixture', ([], {'n_components': 'k', 'weights_init': 'weights', 'means_init': 'means', 'reg_covar': '(0.01)', 'precisions_init': 'precisi... |
# -*- coding: utf-8 -*-
# pylint: disable=no-member,invalid-name,duplicate-code
import importlib
import logging
from collections import namedtuple
from django.test import TestCase
class TestLoadOpsData(TestCase):
"""
Execute specified operational scripts to validate that they work
"""
ScriptDefinitio... | [
"logging.getLogger",
"collections.namedtuple",
"importlib.import_module"
] | [((324, 402), 'collections.namedtuple', 'namedtuple', (['"""ScriptDefinition"""', "('file', 'args', 'skip')"], {'defaults': "('', False)"}), "('ScriptDefinition', ('file', 'args', 'skip'), defaults=('', False))\n", (334, 402), False, 'from collections import namedtuple\n'), ((1269, 1299), 'logging.getLogger', 'logging.... |
"""add origin-protocol-policy
Revision ID: d2e8578fe341
Revises: <KEY>
Create Date: 2020-06-30 00:46:53.784035
"""
from alembic import op
import sqlalchemy as sa
import sqlalchemy_utils
# revision identifiers, used by Alembic.
revision = "d2e8578fe341"
down_revision = "<KEY>"
branch_labels = None
depends_on = None
... | [
"sqlalchemy.String",
"alembic.op.drop_column"
] | [((653, 713), 'alembic.op.drop_column', 'op.drop_column', (['"""service_instance"""', '"""origin_protocol_policy"""'], {}), "('service_instance', 'origin_protocol_policy')\n", (667, 713), False, 'from alembic import op\n'), ((494, 505), 'sqlalchemy.String', 'sa.String', ([], {}), '()\n', (503, 505), True, 'import sqlal... |
#-*- coding:utf-8 -*-
import math
import numpy as np
#定义标准正态分布概率密度函数
class normalpdf():
def __init__(self):
self.u = 0
self.sigma = 1
def change_pram(self,u,sigma):
self.u = u
self.sigma = sigma
def Normal_pdf(self,x):
result = 1/(math.sqrt(2*mat... | [
"math.exp",
"math.sqrt"
] | [((338, 390), 'math.exp', 'math.exp', (['(-(x - self.u) ** 2 / (2 * self.sigma ** 2))'], {}), '(-(x - self.u) ** 2 / (2 * self.sigma ** 2))\n', (346, 390), False, 'import math\n'), ((305, 327), 'math.sqrt', 'math.sqrt', (['(2 * math.pi)'], {}), '(2 * math.pi)\n', (314, 327), False, 'import math\n')] |
import requests,json
from .models import Quote
# Getting the quote base url
base_url=None
def configure_request(app):
global base_url
base_url = app.config['BASE_URL']
def getQuotes():
# request.urlopen(base_url):
res = requests.get(base_url).json()
response = []
... | [
"requests.get"
] | [((257, 279), 'requests.get', 'requests.get', (['base_url'], {}), '(base_url)\n', (269, 279), False, 'import requests, json\n')] |
import json
class JsonHelper:
def indentJson(self, jsonStr):
jsonObject = json.loads(jsonStr)
return json.dumps(jsonObject, sort_keys=True, indent=4, separators=(',', ': '))
| [
"json.loads",
"json.dumps"
] | [((81, 100), 'json.loads', 'json.loads', (['jsonStr'], {}), '(jsonStr)\n', (91, 100), False, 'import json\n'), ((112, 184), 'json.dumps', 'json.dumps', (['jsonObject'], {'sort_keys': '(True)', 'indent': '(4)', 'separators': "(',', ': ')"}), "(jsonObject, sort_keys=True, indent=4, separators=(',', ': '))\n", (122, 184),... |
from typing import Tuple
import email
from unittest.mock import patch, Mock, MagicMock
import pytest
from faker import Faker
import doubleratchet.header
from xeddsa.implementations.xeddsa25519 import XEdDSA25519, XEdDSA
from src.tom import Endpoint
from src.tom._mailbox.packet import PlainPacket, SecurePacket
from src.... | [
"unittest.mock.Mock",
"src.tom._mailbox.packet.PlainPacket",
"src.tom._mailbox.packet.SecurePacket.from_message",
"unittest.mock.MagicMock",
"src.crypto.doubleratchet.KeyPair.generate",
"src.tom._mailbox.packet.SecurePacket",
"src.crypto.doubleratchet.DoubleRatchet",
"src.tom._mailbox.packet.SecurePac... | [((404, 420), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (418, 420), False, 'import pytest\n'), ((907, 923), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (921, 923), False, 'import pytest\n'), ((1324, 1340), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (1338, 1340), False, 'import pytest\n'... |
# write_Crosswalk_Census_AHS.py (scripts)
# !/usr/bin/env python3
# coding=utf-8
"""
Create a crosswalk linking the downloaded Census_AHS to NAICS_12. Created by selecting unique Activity Names and
manually assigning to NAICS
"""
from flowsa.common import datapath
from scripts.common_scripts import unique_activity_n... | [
"scripts.common_scripts.unique_activity_names",
"scripts.common_scripts.order_crosswalk"
] | [((1040, 1090), 'scripts.common_scripts.unique_activity_names', 'unique_activity_names', (['flowcass', 'years', 'datasource'], {}), '(flowcass, years, datasource)\n', (1061, 1090), False, 'from scripts.common_scripts import unique_activity_names, order_crosswalk\n'), ((1390, 1409), 'scripts.common_scripts.order_crosswa... |
from typing import Awaitable, Callable
import trio
from ..config import Config
from ..typing import ASGIFramework
from ..utils import invoke_asgi
async def _handle(
app: ASGIFramework, config: Config, scope: dict, receive: Callable, send: Callable
) -> None:
try:
await invoke_asgi(app, scope, receiv... | [
"trio.open_memory_channel"
] | [((1078, 1129), 'trio.open_memory_channel', 'trio.open_memory_channel', (['config.max_app_queue_size'], {}), '(config.max_app_queue_size)\n', (1102, 1129), False, 'import trio\n')] |
import requests
from urllib import request, parse
import io
import dnnlib
import dnnlib.tflib as tflib
import pickle
import numpy as np
from projector import Projector
from PIL import Image
import re
import base64
from io import BytesIO
import boto3
import uuid
img_res = 256
def find_nearest(arr, val):
"Element ... | [
"boto3.client",
"PIL.Image.new",
"urllib.request.Request",
"base64.b64encode",
"io.BytesIO",
"numpy.array",
"urllib.parse.urlencode",
"urllib.request.urlopen",
"numpy.abs",
"projector.Projector",
"dnnlib.util.open_url",
"boto3.Session",
"pickle.load",
"requests.get",
"dnnlib.tflib.init_t... | [((552, 569), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (564, 569), False, 'import requests\n'), ((640, 676), 'PIL.Image.new', 'Image.new', (['"""RGBA"""', 'img.size', '"""WHITE"""'], {}), "('RGBA', img.size, 'WHITE')\n", (649, 676), False, 'from PIL import Image\n'), ((960, 1008), 're.sub', 're.sub', (... |
import matplotlib.pyplot as plt
def load_tsne_coordinates_from(filename):
file = open(filename)
lines = file.readlines()
line_xy_dict = {}
line_to_xy_dict = {}
for line in lines:
row = line.split()
x = float(row[0])
y = float(row[1])
try:
line_id = row[2... | [
"matplotlib.pyplot.legend",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.annotate",
"matplotlib.pyplot.scatter"
] | [((631, 689), 'matplotlib.pyplot.scatter', 'plt.scatter', (['xs', 'ys'], {'marker': '"""."""', 'c': '"""r"""', 's': '(1.3)', 'linewidth': '(0)'}), "(xs, ys, marker='.', c='r', s=1.3, linewidth=0)\n", (642, 689), True, 'import matplotlib.pyplot as plt\n'), ((694, 716), 'matplotlib.pyplot.legend', 'plt.legend', ([], {'lo... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from solution import NumMatrix
matrix = [[3, 0, 1, 4, 2],
[5, 6, 3, 2, 1],
[1, 2, 0, 1, 5],
[4, 1, 0, 1, 7],
[1, 0, 3, 0, 5]]
numMatrix = NumMatrix(matrix)
print(numMatrix.sumRegion(2, 1, 4, 3))
print(numMatrix.sumRegion(1,... | [
"solution.NumMatrix"
] | [((235, 252), 'solution.NumMatrix', 'NumMatrix', (['matrix'], {}), '(matrix)\n', (244, 252), False, 'from solution import NumMatrix\n')] |
from distributions.distribution_factory import create_distribution
from objectives.objective_factory import create_objective
from samplers.sampler_factory import create_sampler
from algorithms.algo_factory import create_algorithm
import os
import argparse
import pprint as pp
import json
import tensorflow as tf
import ... | [
"samplers.sampler_factory.create_sampler",
"tensorflow.reset_default_graph",
"argparse.ArgumentParser",
"os.makedirs",
"tensorflow.Session",
"json.dump",
"os.path.join",
"algorithms.algo_factory.create_algorithm",
"tensorflow.global_variables_initializer",
"os.path.isdir",
"numpy.random.seed",
... | [((1139, 1159), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (1153, 1159), True, 'import numpy as np\n'), ((1164, 1188), 'tensorflow.reset_default_graph', 'tf.reset_default_graph', ([], {}), '()\n', (1186, 1188), True, 'import tensorflow as tf\n'), ((1193, 1217), 'tensorflow.set_random_seed', 'tf.... |
# This file is part of the clacks framework.
#
# http://clacks-project.org
#
# Copyright:
# (C) 2010-2012 GONICUS GmbH, Germany, http://www.gonicus.de
#
# License:
# GPL-2: http://www.gnu.org/licenses/gpl-2.0.html
#
# See the LICENSE file in the project's top-level directory for details.
__import__('pkg_resources')... | [
"clacks.common.error.ClacksErrorHandler.make_error",
"pkg_resources.iter_entry_points",
"clacks.common.utils.N_"
] | [((650, 700), 'pkg_resources.iter_entry_points', 'pkg_resources.iter_entry_points', (['"""object.operator"""'], {}), "('object.operator')\n", (681, 700), False, 'import pkg_resources\n'), ((814, 865), 'clacks.common.error.ClacksErrorHandler.make_error', 'C.make_error', (['"""OPERATOR_NO_INSTANCE"""'], {'operator': 'nam... |
import torch
import torch.backends.cudnn as cudnn
import numpy as np
import os
import argparse
import time
from tqdm import tqdm
from utils.setup import get_model,get_data_loader
parser = argparse.ArgumentParser()
parser.add_argument("--model_dir",default='checkpoints',type=str,help="directory of checkpoints")
pa... | [
"argparse.ArgumentParser",
"tqdm.tqdm",
"os.path.join",
"numpy.sum",
"utils.setup.get_model",
"utils.setup.get_data_loader",
"time.time",
"torch.argmax"
] | [((193, 218), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (216, 218), False, 'import argparse\n'), ((847, 880), 'os.path.join', 'os.path.join', (['"""."""', 'args.model_dir'], {}), "('.', args.model_dir)\n", (859, 880), False, 'import os\n'), ((889, 925), 'os.path.join', 'os.path.join', (['a... |
from random import randint
import requests
class CatFact:
def __init__(self, amount=10):
self.amount = amount
self.api_url = "https://cat-fact.herokuapp.com/"
self.api_url_2 = "https://catfact.ninja/"
def get_fact(self):
if randint(0, 1) == 1:
return self.get_fact... | [
"random.randint",
"requests.get"
] | [((708, 745), 'requests.get', 'requests.get', (['f"""{self.api_url_2}fact"""'], {}), "(f'{self.api_url_2}fact')\n", (720, 745), False, 'import requests\n'), ((268, 281), 'random.randint', 'randint', (['(0)', '(1)'], {}), '(0, 1)\n', (275, 281), False, 'from random import randint\n'), ((388, 452), 'requests.get', 'reque... |
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not us... | [
"urllib.quote",
"json.dumps",
"httplib2.Http",
"base64.encodestring"
] | [((954, 983), 'urllib.quote', 'urllib.quote', (['name', 'safeChars'], {}), '(name, safeChars)\n', (966, 983), False, 'import urllib\n'), ((1119, 1134), 'httplib2.Http', 'httplib2.Http', ([], {}), '()\n', (1132, 1134), False, 'import httplib2\n'), ((1532, 1550), 'json.dumps', 'json.dumps', (['result'], {}), '(result)\n'... |
'''
flask_miracle.functions
-----------------------
functions callable from within a Flask context
'''
from flask import current_app
def check_any(resource, permission, roles=None):
return current_app.miracle_acl_manager.check_any(resource, permission, roles=None)
def check_all(resource, permission, roles=None)... | [
"flask.current_app.miracle_acl_manager.set_current_roles",
"flask.current_app.miracle_acl_manager.check_any",
"flask.current_app.miracle_acl_manager.check_all"
] | [((196, 271), 'flask.current_app.miracle_acl_manager.check_any', 'current_app.miracle_acl_manager.check_any', (['resource', 'permission'], {'roles': 'None'}), '(resource, permission, roles=None)\n', (237, 271), False, 'from flask import current_app\n'), ((333, 408), 'flask.current_app.miracle_acl_manager.check_all', 'c... |
import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist
from keras.layers import BatchNormalization, Input, Dense, Reshape, Flatten
from keras.layers.advanced_activations import LeakyReLU
from keras.models import Sequential, Model
from keras.optimizers import Adam
def build_generator(laten... | [
"numpy.prod",
"keras.layers.Dense",
"matplotlib.pyplot.imshow",
"numpy.reshape",
"keras.datasets.mnist.load_data",
"keras.models.Model",
"keras.layers.advanced_activations.LeakyReLU",
"matplotlib.pyplot.axis",
"numpy.random.normal",
"keras.optimizers.Adam",
"numpy.ones",
"keras.layers.Flatten"... | [((939, 965), 'keras.layers.Input', 'Input', ([], {'shape': '(latent_dim,)'}), '(shape=(latent_dim,))\n', (944, 965), False, 'from keras.layers import BatchNormalization, Input, Dense, Reshape, Flatten\n'), ((1047, 1066), 'keras.models.Model', 'Model', (['z', 'generated'], {}), '(z, generated)\n', (1052, 1066), False, ... |
from matplotlib import pyplot as plt
import figlatex
import afterpulse_tile21
import textbox
for i, vov in enumerate(afterpulse_tile21.AfterPulseTile21.defaultparams):
fig = plt.figure(num=f'figbaseline2-{i}', clear=True, figsize=[6.4, 3])
ap21 = afterpulse_tile21.AfterPulseTile21(vov)
ap21... | [
"afterpulse_tile21.AfterPulseTile21",
"matplotlib.pyplot.figure",
"figlatex.save",
"textbox.textbox"
] | [((185, 250), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'num': 'f"""figbaseline2-{i}"""', 'clear': '(True)', 'figsize': '[6.4, 3]'}), "(num=f'figbaseline2-{i}', clear=True, figsize=[6.4, 3])\n", (195, 250), True, 'from matplotlib import pyplot as plt\n'), ((267, 306), 'afterpulse_tile21.AfterPulseTile21', 'afterp... |
from pyflowline.algorithms.auxiliary.check_head_water import check_head_water
def remove_small_river(aFlowline_in, dThreshold_in):
nFlowline = len(aFlowline_in)
aFlowline_out=list()
if nFlowline == 1:
aFlowline_out.append(aFlowline_in[0])
else:
lID = 0
for i in ra... | [
"pyflowline.algorithms.auxiliary.check_head_water.check_head_water"
] | [((768, 813), 'pyflowline.algorithms.auxiliary.check_head_water.check_head_water', 'check_head_water', (['aFlowline_in', 'pVertex_start'], {}), '(aFlowline_in, pVertex_start)\n', (784, 813), False, 'from pyflowline.algorithms.auxiliary.check_head_water import check_head_water\n')] |
import re
from audiobonsai import settings
from datetime import datetime, date
from datetime import timedelta
from urllib.request import urlopen
from django.contrib.auth.models import User
from django.http import HttpResponseRedirect
from pprint import pprint
from sausage_grinder.models import Release, Artist
from spot... | [
"spotify_helper.helpers.get_user_conn",
"re.compile",
"sausage_grinder.models.Artist.objects.all",
"sausage_grinder.models.Release.objects.bulk_create",
"sausage_grinder.models.Release.objects.get",
"sausage_grinder.models.Release.objects.filter",
"sausage_grinder.models.Artist.objects.get",
"datetime... | [((1237, 1276), 'sausage_grinder.models.Release.objects.filter', 'Release.objects.filter', ([], {'processed': '(False)'}), '(processed=False)\n', (1259, 1276), False, 'from sausage_grinder.models import Release, Artist\n'), ((2355, 2375), 'sausage_grinder.models.Artist.objects.all', 'Artist.objects.all', ([], {}), '()\... |
from os import path
import click
import contxt.schemas as schemas
from contxt.services.base_graph_service import BaseGraphService
from contxt.utils.contxt_environment import ContxtEnvironment
@click.command()
@click.option('--fresh-from-file', type=str, help='Overwrite/init from a specific environment file')
def ini... | [
"contxt.services.base_graph_service.BaseGraphService",
"click.option",
"contxt.utils.contxt_environment.ContxtEnvironment",
"os.path.dirname",
"click.command"
] | [((196, 211), 'click.command', 'click.command', ([], {}), '()\n', (209, 211), False, 'import click\n'), ((213, 317), 'click.option', 'click.option', (['"""--fresh-from-file"""'], {'type': 'str', 'help': '"""Overwrite/init from a specific environment file"""'}), "('--fresh-from-file', type=str, help=\n 'Overwrite/ini... |
"""Generate plots for the annotations of the blame verifier."""
import abc
import logging
import typing as tp
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick
import numpy as np
import pandas as pd
from matplotlib import style
from sklearn import preprocessing
import varats.paper_mgmt.paper_config as... | [
"logging.getLogger",
"numpy.unique",
"varats.data.databases.blame_verifier_report_database.BlameVerifierReportDatabase.get_data_for_project",
"matplotlib.ticker.PercentFormatter",
"matplotlib.pyplot.figure",
"matplotlib.style.use",
"varats.paper_mgmt.paper_config.get_paper_config",
"matplotlib.pyplot.... | [((717, 744), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (734, 744), False, 'import logging\n'), ((949, 977), 'varats.mapping.commit_map.get_commit_map', 'get_commit_map', (['project_name'], {}), '(project_name)\n', (963, 977), False, 'from varats.mapping.commit_map import get_commit_... |
from multiprocessing import Process, Queue, Lock
from Queue import Empty
from core.utilities import logging_handler_setup
class Device(object):
layout_type = "Layout"
def __init__(self):
# Output queue
self.out_queue = Queue()
# Input Queue
self.in_queue = Queue()
# M... | [
"multiprocessing.Lock",
"multiprocessing.Queue",
"core.utilities.logging_handler_setup",
"multiprocessing.Process"
] | [((245, 252), 'multiprocessing.Queue', 'Queue', ([], {}), '()\n', (250, 252), False, 'from multiprocessing import Process, Queue, Lock\n'), ((300, 307), 'multiprocessing.Queue', 'Queue', ([], {}), '()\n', (305, 307), False, 'from multiprocessing import Process, Queue, Lock\n'), ((367, 373), 'multiprocessing.Lock', 'Loc... |
#!/usr/bin/env python3
import sys
from pathlib import Path
import coverage
from . import generateGithubChecksAnnotations
from miniGHAPI.GHActionsEnv import getGHEnv, getRepo
from miniGHAPI.GitHubAPI import GHAPI
def main():
env = getGHEnv()
owner, repo = getRepo(env)
if len(sys.argv) > 1:
cov = coverage.Covera... | [
"pathlib.Path",
"coverage.Coverage",
"miniGHAPI.GitHubAPI.GHAPI",
"miniGHAPI.GHActionsEnv.getRepo",
"miniGHAPI.GHActionsEnv.getGHEnv"
] | [((234, 244), 'miniGHAPI.GHActionsEnv.getGHEnv', 'getGHEnv', ([], {}), '()\n', (242, 244), False, 'from miniGHAPI.GHActionsEnv import getGHEnv, getRepo\n'), ((260, 272), 'miniGHAPI.GHActionsEnv.getRepo', 'getRepo', (['env'], {}), '(env)\n', (267, 272), False, 'from miniGHAPI.GHActionsEnv import getGHEnv, getRepo\n'), (... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'mainwindow1.ui'
#
# Created by: PyQt5 UI code generator 5.13.2
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
Ma... | [
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtWidgets.QToolButton",
"PyQt5.QtWidgets.QMainWindow",
"PyQt5.QtGui.QIcon",
"PyQt5.QtGui.QFont",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QFrame",
"PyQt5.QtWidgets.QSplitter",
"PyQt5.QtCore.QRect",
"PyQt5.QtGui.QCursor",
"PyQt5.QtWidgets.Q... | [((9550, 9582), 'PyQt5.QtWidgets.QApplication', 'QtWidgets.QApplication', (['sys.argv'], {}), '(sys.argv)\n', (9572, 9582), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((9600, 9623), 'PyQt5.QtWidgets.QMainWindow', 'QtWidgets.QMainWindow', ([], {}), '()\n', (9621, 9623), False, 'from PyQt5 import QtCore, QtG... |
from django.contrib import admin
from .models import (
Node,
Column,
Week,
Activity,
Course,
Program,
NodeWeek,
NodeLink,
WeekWorkflow,
ColumnWorkflow,
Workflow,
Project,
WorkflowProject,
Outcome,
OutcomeNode,
OutcomeOutcome,
)
admin.site.register(N... | [
"django.contrib.admin.site.register"
] | [((299, 324), 'django.contrib.admin.site.register', 'admin.site.register', (['Node'], {}), '(Node)\n', (318, 324), False, 'from django.contrib import admin\n'), ((325, 352), 'django.contrib.admin.site.register', 'admin.site.register', (['Column'], {}), '(Column)\n', (344, 352), False, 'from django.contrib import admin\... |
# --------------
#Importing header files
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
data = pd.read_csv(path)
data['Rating'].hist()
data = data[data['Rating']<=5]
data['Rating'].hist()
#Code starts here
#Code ends here
# --------------
# code starts here
total_null = data.isn... | [
"sklearn.preprocessing.LabelEncoder",
"seaborn.regplot",
"matplotlib.pyplot.xticks",
"pandas.read_csv",
"seaborn.catplot",
"matplotlib.pyplot.title",
"pandas.concat",
"pandas.to_datetime"
] | [((124, 141), 'pandas.read_csv', 'pd.read_csv', (['path'], {}), '(path)\n', (135, 141), True, 'import pandas as pd\n'), ((399, 471), 'pandas.concat', 'pd.concat', (['(total_null, percent_null)'], {'axis': '(1)', 'keys': "['Total', 'Percent']"}), "((total_null, percent_null), axis=1, keys=['Total', 'Percent'])\n", (408,... |
from __future__ import unicode_literals
from itertools import chain
from django.core.urlresolvers import reverse
from django.test import TransactionTestCase
from mock_django import mock_signal_receiver
from rest_framework import status
from rest_framework import test
from nodeconductor.structure import signals
from ... | [
"nodeconductor.structure.tests.factories.ProjectFactory.create_batch",
"nodeconductor.structure.tests.factories.CustomerFactory",
"mock_django.mock_signal_receiver",
"itertools.product",
"nodeconductor.structure.models.ProjectGroup.objects.get",
"django.core.urlresolvers.reverse",
"nodeconductor.structu... | [((565, 596), 'nodeconductor.structure.tests.factories.ProjectGroupFactory', 'factories.ProjectGroupFactory', ([], {}), '()\n', (594, 596), False, 'from nodeconductor.structure.tests import factories\n'), ((617, 640), 'nodeconductor.structure.tests.factories.UserFactory', 'factories.UserFactory', ([], {}), '()\n', (638... |
"""
A fake backend for dummying during tests.
"""
import datetime
from django.db import models
from haystack.backends import BaseSearchBackend, BaseSearchQuery
from haystack.constants import FILTER_SEPARATOR
from haystack.models import SearchResult
class DummySearchResult(SearchResult):
dm = type('DummyModel', (o... | [
"haystack.constants.FILTER_SEPARATOR.join"
] | [((2038, 2103), 'haystack.constants.FILTER_SEPARATOR.join', 'FILTER_SEPARATOR.join', (['(the_filter.field, the_filter.filter_type)'], {}), '((the_filter.field, the_filter.filter_type))\n', (2059, 2103), False, 'from haystack.constants import FILTER_SEPARATOR\n')] |
import logging
from colorlog import ColoredFormatter
def setup_logging():
logger = logging.getLogger()
logger.setLevel(logging.INFO)
color_formatter = ColoredFormatter(
"%(log_color)s[%(asctime)s] [%(levelname)-4s]%(reset)s - %(message)s",
datefmt='%d-%m-%y %H:%M:%S',
r... | [
"logging.getLogger",
"logging.StreamHandler",
"logging.Formatter",
"logging.FileHandler",
"colorlog.ColoredFormatter"
] | [((1090, 1117), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1107, 1117), False, 'import logging\n'), ((89, 108), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (106, 108), False, 'import logging\n'), ((165, 464), 'colorlog.ColoredFormatter', 'ColoredFormatter', (['"""%(lo... |
# Python code transmits a byte to Arduino /Microcontroller
import serial
import time
SerialObj = serial.Serial('COM11') # COMxx format on Windows
#/dev/ttyUSBx format on Linux
#
#Eg /dev/ttyUSB0
... | [
"serial.Serial",
"time.sleep"
] | [((100, 122), 'serial.Serial', 'serial.Serial', (['"""COM11"""'], {}), "('COM11')\n", (113, 122), False, 'import serial\n'), ((507, 520), 'time.sleep', 'time.sleep', (['(3)'], {}), '(3)\n', (517, 520), False, 'import time\n')] |
from rest_framework import permissions
from rest_framework.exceptions import PermissionDenied
from comments.models import Comment
class IsCommentExists(permissions.BasePermission):
def has_permission(self, request, view):
comment_id = view.kwargs.get('comment_id')
try:
_ = Comment.obje... | [
"comments.models.Comment.objects.get",
"rest_framework.exceptions.PermissionDenied"
] | [((308, 342), 'comments.models.Comment.objects.get', 'Comment.objects.get', ([], {'id': 'comment_id'}), '(id=comment_id)\n', (327, 342), False, 'from comments.models import Comment\n'), ((398, 450), 'rest_framework.exceptions.PermissionDenied', 'PermissionDenied', (["{'message': 'There is no commnet'}"], {}), "({'messa... |
# -*- coding: utf-8 -*-
"""
Created on Wed Mar 01 10:00:09 2017
@author: <NAME>
Translation of NS's InterX for Matlab into Python.
Original Available at: https://www.mathworks.com/matlabcentral/fileexchange/22441-curve-intersections/content/InterX.m
Python translation (c) 2017, <NAME>
Original Matlab cod... | [
"numpy.mat",
"numpy.multiply",
"numpy.hstack",
"numpy.diff",
"numpy.vstack",
"pandas.DataFrame",
"numpy.divide"
] | [((4439, 4460), 'numpy.hstack', 'np.hstack', (['[L1x, L1y]'], {}), '([L1x, L1y])\n', (4448, 4460), True, 'import numpy as np\n'), ((4470, 4491), 'numpy.vstack', 'np.vstack', (['[L2x, L2y]'], {}), '([L2x, L2y])\n', (4479, 4491), True, 'import numpy as np\n'), ((4816, 4835), 'numpy.diff', 'np.diff', (['x1'], {'axis': '(0... |
import os
class Settings:
root = os.path.dirname(os.path.realpath(__file__))
# Train dataset settings
dataset_info = {
'291': {
'path': './',
'link': '1Rt3asDLuMgLuJvPA1YrhyjWhb97Ly742',
'is_gray': False,
'random_scale': False,
'crop_size... | [
"os.path.realpath",
"os.path.join"
] | [((768, 798), 'os.path.join', 'os.path.join', (['root', '"""datasets"""'], {}), "(root, 'datasets')\n", (780, 798), False, 'import os\n'), ((54, 80), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (70, 80), False, 'import os\n')] |
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
"""
Codes for various seismological computations
"""
from sys import version_info
if version_info >= (2,6,0):
... | [
"_Seismology.LocatorInterface_releaseDepth",
"_Seismology.LocatorInterface_name",
"_Seismology.TravelTimeTableInterface_setModel",
"_Seismology.new_LocSATErrorEllipsoid",
"_Seismology.LocSAT_setNewOriginID",
"_Seismology.TravelTimeList_isEmpty",
"_Seismology.ellipcorr",
"_Seismology.LocatorInterface_s... | [((8819, 8845), '_Seismology.Regions_load', '_Seismology.Regions_load', ([], {}), '()\n', (8843, 8845), False, 'import _Seismology\n'), ((8930, 8970), '_Seismology.Regions_getRegionName', '_Seismology.Regions_getRegionName', (['*args'], {}), '(*args)\n', (8963, 8970), False, 'import _Seismology\n'), ((9066, 9099), '_Se... |
#!/usr/bin/env python
# coding: utf8
""" Utility functions for creating estimator. """
from pathlib import Path
from os.path import join
from tempfile import gettempdir
# pylint: disable=import-error
import tensorflow as tf
from tensorflow.contrib import predictor
# pylint: enable=import-error
from ..model import ... | [
"tensorflow.compat.v1.ConfigProto",
"tensorflow.estimator.RunConfig",
"pathlib.Path",
"tensorflow.contrib.predictor.from_saved_model",
"tensorflow.estimator.Estimator",
"tempfile.gettempdir",
"tensorflow.estimator.export.ServingInputReceiver"
] | [((485, 497), 'tempfile.gettempdir', 'gettempdir', ([], {}), '()\n', (495, 497), False, 'from tempfile import gettempdir\n'), ((1173, 1199), 'tensorflow.compat.v1.ConfigProto', 'tf.compat.v1.ConfigProto', ([], {}), '()\n', (1197, 1199), True, 'import tensorflow as tf\n'), ((1282, 1335), 'tensorflow.estimator.RunConfig'... |
import os
import traceback
import adsk.core
app = adsk.core.Application.get()
ui = app.userInterface
# Attempt to read DEBUG flag from parent config.
try:
from ... import config
DEBUG = config.DEBUG
except:
DEBUG = False
def log(message: str, level: adsk.core.LogLevels = adsk.core.LogLevels.InfoLogLevel... | [
"traceback.format_exc"
] | [((1570, 1592), 'traceback.format_exc', 'traceback.format_exc', ([], {}), '()\n', (1590, 1592), False, 'import traceback\n'), ((1749, 1771), 'traceback.format_exc', 'traceback.format_exc', ([], {}), '()\n', (1769, 1771), False, 'import traceback\n')] |
#!/usr/bin/env python3
import argparse
import warnings
from utilities.alignment.run_star_and_htseq import reference_genomes, deprecated
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"--branch", default="master", help="branch of utilities repo to use"
)
parser.add_argu... | [
"warnings.warn",
"utilities.alignment.run_star_and_htseq.reference_genomes.keys",
"argparse.ArgumentParser"
] | [((165, 190), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (188, 190), False, 'import argparse\n'), ((811, 932), 'warnings.warn', 'warnings.warn', (['f"""The name \'{args.taxon}\' will be removed in the future, start using \'{deprecated[args.taxon]}\'"""'], {}), '(\n f"The name \'{args.tax... |
from django.shortcuts import render, redirect
from django.contrib.auth import logout as django_logout, login as django_login
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
import time
# Create your views here.
def signup(request):
if request.method == 'POST':
form = UserCreati... | [
"django.shortcuts.render",
"django.contrib.auth.login",
"time.sleep",
"django.contrib.auth.forms.AuthenticationForm",
"django.shortcuts.redirect",
"django.contrib.auth.forms.UserCreationForm",
"django.contrib.auth.logout"
] | [((689, 750), 'django.shortcuts.render', 'render', (['request', '"""users/register.html"""', "{'signup_form': form}"], {}), "(request, 'users/register.html', {'signup_form': form})\n", (695, 750), False, 'from django.shortcuts import render, redirect\n'), ((1089, 1146), 'django.shortcuts.render', 'render', (['request',... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from cdp_backend.infrastructure import CDPStack
from pulumi import export
###############################################################################
cdp_stack = CDPStack(
gcp_project_id="cdp-portland-d2bbda97",
municipality_name="Portland",
firestore_loc... | [
"pulumi.export",
"cdp_backend.infrastructure.CDPStack"
] | [((215, 515), 'cdp_backend.infrastructure.CDPStack', 'CDPStack', ([], {'gcp_project_id': '"""cdp-portland-d2bbda97"""', 'municipality_name': '"""Portland"""', 'firestore_location': '"""us-west1"""', 'hosting_github_url': '"""https://github.com/CouncilDataProject/portland"""', 'hosting_web_app_address': '"""https://coun... |
from datetime import datetime
from typing import Iterable, Union
from discord import Intents, Client, Message, Guild, Member, TextChannel, Reaction
from discord.abc import Messageable, User
from raconteur.commands import is_possible_command
from raconteur.models.base import get_session
from raconteur.plugin import Pl... | [
"raconteur.models.base.get_session",
"raconteur.queries.get_or_create_game",
"raconteur.commands.is_possible_command",
"discord.Intents.default"
] | [((2548, 2565), 'discord.Intents.default', 'Intents.default', ([], {}), '()\n', (2563, 2565), False, 'from discord import Intents, Client, Message, Guild, Member, TextChannel, Reaction\n'), ((2188, 2201), 'raconteur.models.base.get_session', 'get_session', ([], {}), '()\n', (2199, 2201), False, 'from raconteur.models.b... |
import requests
import json
from .helper import Helper
class Currencies(Helper):
def __init__(self, base_url, org_pk, teams_pk, access_token, _csrf_token, headers, pagination):
super().__init__(base_url, org_pk, teams_pk, access_token, _csrf_token, headers, pagination)
def get_currencies_list(self, ... | [
"json.dumps"
] | [((1084, 1100), 'json.dumps', 'json.dumps', (['data'], {}), '(data)\n', (1094, 1100), False, 'import json\n'), ((2087, 2103), 'json.dumps', 'json.dumps', (['data'], {}), '(data)\n', (2097, 2103), False, 'import json\n')] |
from collections import OrderedDict
from PIL import Image
import torch
from data import Cityscapes as dataset
from torch.autograd import Variable
from deeplab_multi import Encoder,Decoder
import torchvision.transforms as transforms
import transforms as ext_transforms
from args import get_arguments
import utils
from ... | [
"collections.OrderedDict",
"PIL.Image.open",
"torchvision.transforms.ToPILImage",
"deeplab_multi.Decoder",
"deeplab_multi.Encoder",
"torch.load",
"args.get_arguments",
"torch.max",
"data.utils.get_files",
"torchvision.transforms.Resize",
"torchvision.transforms.ToTensor",
"transforms.LongTenso... | [((356, 371), 'args.get_arguments', 'get_arguments', ([], {}), '()\n', (369, 371), False, 'from args import get_arguments\n'), ((381, 406), 'torch.device', 'torch.device', (['args.device'], {}), '(args.device)\n', (393, 406), False, 'import torch\n'), ((996, 1596), 'collections.OrderedDict', 'OrderedDict', (["[('unlabe... |
import logging
import xml.etree.ElementTree as ET
from datetime import date
from typing import Optional
import requests
from .configure_logging import setup_logger
from .exceptions import InvalidApiKey, UnsuccessfulRequest
from .kwargs_mapping import kwargs_mapping
logger = setup_logger(logging.getLogger("PyElexon")... | [
"logging.getLogger",
"xml.etree.ElementTree.fromstring",
"requests.get"
] | [((291, 320), 'logging.getLogger', 'logging.getLogger', (['"""PyElexon"""'], {}), "('PyElexon')\n", (308, 320), False, 'import logging\n'), ((2092, 2124), 'requests.get', 'requests.get', (['url'], {'params': 'params'}), '(url, params=params)\n', (2104, 2124), False, 'import requests\n'), ((4699, 4723), 'xml.etree.Eleme... |
# This module cannot import any other PyTorch/XLA module. Only Python core modules.
import argparse
import sys
def parse_common_options(datadir=None,
num_cores=None,
batch_size=128,
num_epochs=10,
num_workers=4,
... | [
"argparse.ArgumentParser"
] | [((475, 514), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'add_help': '(False)'}), '(add_help=False)\n', (498, 514), False, 'import argparse\n')] |
from interactions.constraints import Nowhere, Constraint, ANYWHERE
from sims4.geometry import CompoundPolygon, RestrictedPolygon
from sims4.tuning.tunable import HasTunableSingletonFactory, AutoFactoryInit, TunableVariant, TunableTuple
from singletons import DEFAULT
import services
import sims4.log
logger = sims4.log.L... | [
"services.current_zone_id",
"sims4.geometry.RestrictedPolygon",
"sims4.tuning.tunable.TunableTuple",
"interactions.constraints.Nowhere",
"sims4.geometry.CompoundPolygon",
"services.get_plex_service"
] | [((1468, 1495), 'services.get_plex_service', 'services.get_plex_service', ([], {}), '()\n', (1493, 1495), False, 'import services\n'), ((1514, 1540), 'services.current_zone_id', 'services.current_zone_id', ([], {}), '()\n', (1538, 1540), False, 'import services\n'), ((1889, 1914), 'sims4.geometry.CompoundPolygon', 'Com... |
# coding=utf-8
r"""
This code was generated by
\ / _ _ _| _ _
| (_)\/(_)(_|\/| |(/_ v1.0.0
/ /
"""
from tests import IntegrationTestCase
from tests.holodeck import Request
from twilio.base.exceptions import TwilioException
from twilio.http.response import Response
class ConnectionPolicyTargetTes... | [
"twilio.http.response.Response",
"tests.holodeck.Request"
] | [((411, 428), 'twilio.http.response.Response', 'Response', (['(500)', '""""""'], {}), "(500, '')\n", (419, 428), False, 'from twilio.http.response import Response\n'), ((747, 877), 'tests.holodeck.Request', 'Request', (['"""post"""', '"""https://voice.twilio.com/v1/ConnectionPolicies/NYXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX/... |
# Generated by Django 3.0.3 on 2020-05-12 13:21
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('slackbot', '0007_slackroulette_channel_id'),
]
operations = [
migrations.AlterField(
model_name='slackadminuser',
na... | [
"django.db.models.CharField"
] | [((358, 429), 'django.db.models.CharField', 'models.CharField', ([], {'default': '"""non-existent-id"""', 'max_length': '(20)', 'unique': '(True)'}), "(default='non-existent-id', max_length=20, unique=True)\n", (374, 429), False, 'from django.db import migrations, models\n')] |
from enum import Enum
from arjuna.configure.impl.container import ConfigContainer
from arjuna.tpi.enums import ArjunaOption, BrowserName
class _ConfigBuilder:
def __init__(self, test_session, config_map, conf_trace, code_mode):
self.__code_mode = code_mode
self.__test_session = test_session
... | [
"arjuna.tpi.Arjuna.get_ref_config",
"arjuna.configure.impl.container.ConfigContainer"
] | [((348, 365), 'arjuna.configure.impl.container.ConfigContainer', 'ConfigContainer', ([], {}), '()\n', (363, 365), False, 'from arjuna.configure.impl.container import ConfigContainer\n'), ((3963, 3986), 'arjuna.tpi.Arjuna.get_ref_config', 'Arjuna.get_ref_config', ([], {}), '()\n', (3984, 3986), False, 'from arjuna.tpi i... |
import tensorflow as tf
from tensorflow.keras.layers.experimental.preprocessing import (
CenterCrop,
Rescaling,
Resizing,
)
import tensorflow_io as tfio
from utils import get_frozen_params, get_params
MIN_RESIZE = {
112: 128,
128: 224,
224: 256,
256: 256,
}
class DataPreprocessor():
... | [
"tensorflow_io.experimental.ffmpeg.decode_video",
"tensorflow.random.Generator.from_seed",
"tensorflow.shape",
"tensorflow.TensorArray",
"tensorflow.ones",
"tensorflow.io.parse_single_example",
"utils.get_frozen_params",
"tensorflow.keras.layers.experimental.preprocessing.CenterCrop",
"tensorflow.io... | [((360, 384), 'utils.get_params', 'get_params', (['"""Preprocess"""'], {}), "('Preprocess')\n", (370, 384), False, 'from utils import get_frozen_params, get_params\n'), ((913, 999), 'tensorflow.cast', 'tf.cast', (["(self.params['batch_per_replica'] * self.params['num_replicas'])", 'tf.int64'], {}), "(self.params['batch... |
# -*- coding: utf-8 -*-
"""
locale test_services module.
"""
import pytest
import pyrin.globalization.locale.services as locale_services
import pyrin.configuration.services as config_services
from pyrin.globalization.locale.exceptions import InvalidLocaleSelectorTypeError, \
LocaleSelectorHasBeenAlreadySetError,... | [
"pyrin.globalization.locale.services.locale_exists",
"pyrin.globalization.locale.services.set_timezone_selector",
"pyrin.globalization.locale.services.set_locale_selector",
"pyrin.globalization.locale.services.get_current_timezone",
"pytest.raises",
"pyrin.globalization.locale.services.get_current_locale"... | [((1782, 1818), 'pyrin.globalization.locale.services.get_current_locale', 'locale_services.get_current_locale', ([], {}), '()\n', (1816, 1818), True, 'import pyrin.globalization.locale.services as locale_services\n'), ((1840, 1910), 'pyrin.configuration.services.get', 'config_services.get', (['"""globalization"""', '""... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import time, datetime, sys, os
sys.path.append('/home/ghz/wxlib')
import wxlib as wx
wx_dir = "/home/ghz/wx"
def gen_index(etemp, ehum, press, pitemp, edp, abs_hum, heat_i):
plate = wx_dir+"/wx_index.html.template"
plate_fd = open(plate, 'r')
plate_dat = plate_fd.read()... | [
"wxlib.dew_point_c",
"wxlib.bme680_read",
"wxlib.abs_hum_g_mmm",
"wxlib.write_out",
"wxlib.heat_index",
"wxlib.write_out_dat_stamp",
"time.time",
"sys.path.append",
"os.uname",
"wxlib.pi_temp_read"
] | [((76, 110), 'sys.path.append', 'sys.path.append', (['"""/home/ghz/wxlib"""'], {}), "('/home/ghz/wxlib')\n", (91, 110), False, 'import time, datetime, sys, os\n'), ((893, 948), 'wxlib.write_out', 'wx.write_out', (["(wx_dir + '/plots/wx.html')", 'plate_dat', '"""w"""'], {}), "(wx_dir + '/plots/wx.html', plate_dat, 'w')\... |
# -*- coding: utf-8 -*-
import sys
import time
import json
import base_64
import hashlib
import requests
import traceback
# ---------------------
PROTOCAL_MAPPING = {
"ICMP": "1",
"TCP": "6",
"UDP": "17",
}
def http_request(method, url, headers=None, params=None, data=None, timeout=10, verify=False,
... | [
"json.loads",
"hashlib.md5",
"base_64.encodestring",
"requests.request",
"traceback.print_exc",
"time.time"
] | [((1234, 1247), 'hashlib.md5', 'hashlib.md5', ([], {}), '()\n', (1245, 1247), False, 'import hashlib\n'), ((616, 724), 'requests.request', 'requests.request', (['method', 'url'], {'params': 'params', 'data': 'data', 'headers': 'headers', 'timeout': 'timeout', 'verify': 'verify'}), '(method, url, params=params, data=dat... |
import setuptools
from numpy.distutils.core import setup
from numpy.distutils.extension import Extension
from setuptools import find_packages
import versioneer
with open("README.rst") as readme_file:
readme = readme_file.read()
compile_opts = {
"extra_f90_compile_args": [
"-fopenmp",
"-ffree-... | [
"versioneer.get_version",
"versioneer.get_cmdclass",
"setuptools.find_packages",
"numpy.distutils.extension.Extension"
] | [((517, 667), 'numpy.distutils.extension.Extension', 'Extension', ([], {'name': '"""pspy.mcm_fortran.mcm_fortran"""', 'sources': "['pspy/mcm_fortran/mcm_fortran.f90', 'pspy/wigner3j/wigner3j_sub.f']"}), "(name='pspy.mcm_fortran.mcm_fortran', sources=[\n 'pspy/mcm_fortran/mcm_fortran.f90', 'pspy/wigner3j/wigner3j_sub... |
# Copyright 2017 Hewlett Packard Enterprise Development LP
#
# 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 applicabl... | [
"proliantutils.redfish.resources.account_service.account_service.HPEAccountService",
"proliantutils.redfish.resources.manager.manager.HPEManager",
"proliantutils.redfish.utils.get_subresource_path_by",
"proliantutils.redfish.resources.system.system.HPESystem",
"proliantutils.redfish.resources.update_service... | [((1209, 1255), 'proliantutils.redfish.utils.get_subresource_path_by', 'utils.get_subresource_path_by', (['self', '"""Systems"""'], {}), "(self, 'Systems')\n", (1238, 1255), False, 'from proliantutils.redfish import utils\n'), ((1474, 1550), 'proliantutils.redfish.resources.system.system.HPESystem', 'system.HPESystem',... |
import json
import os
import boto
from boto.s3.connection import OrdinaryCallingFormat
try:
from urllib.parse import urlparse, parse_qs
except ImportError:
from urlparse import urlparse, parse_qs
# request imported here so it can be mocked in tests
from flask import request, Response # noqa
from ... import co... | [
"urlparse.parse_qs",
"json.dumps",
"os.path.join",
"flask.Response",
"boto.s3.connection.OrdinaryCallingFormat",
"urlparse.urlparse"
] | [((2829, 2852), 'json.dumps', 'json.dumps', (['res_payload'], {}), '(res_payload)\n', (2839, 2852), False, 'import json\n'), ((4083, 4111), 'json.dumps', 'json.dumps', (['response_payload'], {}), '(response_payload)\n', (4093, 4111), False, 'import json\n'), ((1482, 1502), 'flask.Response', 'Response', ([], {'status': ... |
from noodle._formatter import formatted_options, formatted_arguments, formatted_commands
from noodle._parser import Parser
from noodle.core import _GLOBAL_OPTIONS
parser = Parser()
class TestCommand1:
"""command description"""
command_name = "test_command1"
class TestCommand2:
command_name = "test_com... | [
"noodle._formatter.formatted_options",
"noodle._formatter.formatted_arguments",
"noodle._parser.Parser",
"noodle._formatter.formatted_commands"
] | [((173, 181), 'noodle._parser.Parser', 'Parser', ([], {}), '()\n', (179, 181), False, 'from noodle._parser import Parser\n'), ((482, 526), 'noodle._formatter.formatted_options', 'formatted_options', (['parsed_options', '"""Options"""'], {}), "(parsed_options, 'Options')\n", (499, 526), False, 'from noodle._formatter im... |
# Time: O(n^2 * logn)
# Space: O(n)
import math
# angle sweep solution
# great explanation:
# https://leetcode.com/problems/maximum-number-of-darts-inside-of-a-circular-dartboard/discuss/636345/Python-O(n3)-and-O(n2logn)-solution-explained-in-detail-with-pictures
class Solution(object):
def numPoints(self, poin... | [
"math.sqrt",
"math.atan2",
"math.acos"
] | [((691, 719), 'math.sqrt', 'math.sqrt', (['(dx ** 2 + dy ** 2)'], {}), '(dx ** 2 + dy ** 2)\n', (700, 719), False, 'import math\n'), ((804, 826), 'math.acos', 'math.acos', (['(d / (2 * r))'], {}), '(d / (2 * r))\n', (813, 826), False, 'import math\n'), ((824, 842), 'math.atan2', 'math.atan2', (['dy', 'dx'], {}), '(dy, ... |
from typing import Optional
from pathlib import Path
import subprocess
from .constants import GIT_REPO_URI
def install_pipeline(
parent_dir: Optional[Path] = None
) -> None:
if parent_dir is None:
parent_dir = Path('.')
target_dir = parent_dir / 'mne-bids-pipeline'
if target_dir.exists():
... | [
"pathlib.Path"
] | [((229, 238), 'pathlib.Path', 'Path', (['"""."""'], {}), "('.')\n", (233, 238), False, 'from pathlib import Path\n')] |
from flask import Flask, url_for
app = Flask(__name__)
app.config['PROPAGATE_EXCEPTIONS'] = True
@app.route('/')
def index():
return f"""
<html>
<head>
<title>Hello world</title>
</head>
<body>
Hello world!
<a href="nowhere">Link to nowhere</a>
... | [
"flask.url_for",
"flask.Flask"
] | [((40, 55), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (45, 55), False, 'from flask import Flask, url_for\n'), ((350, 372), 'flask.url_for', 'url_for', (['"""value_error"""'], {}), "('value_error')\n", (357, 372), False, 'from flask import Flask, url_for\n'), ((406, 427), 'flask.url_for', 'url_for', ([... |
# A very simple Bottle Hello World app for you to get started with...
from bottle import default_app, route, run
@route('/')
def hello_world():
return 'Hello from Bottle!'
application = default_app()
run(server='wsgiref', host="0.0.0.0", port=8080)
| [
"bottle.run",
"bottle.default_app",
"bottle.route"
] | [((115, 125), 'bottle.route', 'route', (['"""/"""'], {}), "('/')\n", (120, 125), False, 'from bottle import default_app, route, run\n'), ((192, 205), 'bottle.default_app', 'default_app', ([], {}), '()\n', (203, 205), False, 'from bottle import default_app, route, run\n'), ((207, 255), 'bottle.run', 'run', ([], {'server... |
"""
Primer demo para pysud.
Demuestra uso de eventos locales creados por el usuario.
Demuestra uso de variables definidas por el usuario.
"""
import pysud_gm as gameMgr
import pysud_events as ev
import pysud
# EVENTOS DEFINIDOS POR UN USUARIO:
class EventBotiquin(ev.CommandEvent):
def on_success(self, game):
... | [
"pysud.Room",
"pysud.Game",
"pysud_events.ShowMessageEvent",
"pysud_gm.GameManager"
] | [((3587, 3613), 'pysud.Game', 'pysud.Game', (['NOMBRE_USUARIO'], {}), '(NOMBRE_USUARIO)\n', (3597, 3613), False, 'import pysud\n'), ((3647, 3872), 'pysud.Room', 'pysud.Room', (['"""Calle"""', '"""Estas en la puerta de tu viejo departamento. En la calle esta cayendo el sol y no ves personas por ningún lado, todo está en... |
from django.conf.urls import include, url
from django.contrib import admin
from django.conf import settings
urlpatterns = [
# Examples:
# url(r'^$', 'hackathon.views.home', name='home'),
# url(r'^blog/', include('blog.urls')),
url(r'^admin/', include(admin.site.urls)),
url(r'^', include('api.urls'... | [
"django.conf.urls.include",
"django.conf.urls.static.static"
] | [((586, 649), 'django.conf.urls.static.static', 'static', (['settings.STATIC_URL'], {'document_root': 'settings.STATIC_ROOT'}), '(settings.STATIC_URL, document_root=settings.STATIC_ROOT)\n', (592, 649), False, 'from django.conf.urls.static import static\n'), ((261, 285), 'django.conf.urls.include', 'include', (['admin.... |
from dataclasses import dataclass
# Mnemonic model which contains root label, target label, name of jump as mnemonic (e.g. jnp) and jump_type, which is
# the description of jump (e.g. Jump if not equal)
@dataclass(frozen=True)
class Mnemonic:
name: str
jump_type: str
target_label: str
r... | [
"dataclasses.dataclass"
] | [((205, 227), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (214, 227), False, 'from dataclasses import dataclass\n')] |
from ffield import FField
f = FField(p = 83, w = 19)
Xa = 15
Xb = 112
Ya = f.mod(Xa)
Yb = f.mod(Xb)
K = Ya ** Xb
print(f"{Ya = }, {Yb = }, {K = }")
# Ya = 76, Yb = 49, K = 48
| [
"ffield.FField"
] | [((33, 51), 'ffield.FField', 'FField', ([], {'p': '(83)', 'w': '(19)'}), '(p=83, w=19)\n', (39, 51), False, 'from ffield import FField\n')] |
import random
def numer_aleatorio():
return random.randint(1,100)
def decisi_aleatorio(num):
prim = int(input("Ingrese un número: "))
if prim==num:
print("Has ganado")
else:
if prim>num:
print("El número {} es mayor que {}".format(prim,num))
else:
... | [
"random.randint"
] | [((52, 74), 'random.randint', 'random.randint', (['(1)', '(100)'], {}), '(1, 100)\n', (66, 74), False, 'import random\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.10 on 2016-11-16 10:53
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0018_auto_20161116_0915'),
]
operations = [
migrations.AddField(
... | [
"django.db.models.BooleanField"
] | [((405, 439), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)'}), '(default=False)\n', (424, 439), False, 'from django.db import migrations, models\n')] |
#Neural net analysis of phyllosphere data
#Code adapted from https://machinelearningmastery.com/regression-tutorial-keras-deep-learning-library-python/
#Contents of code:
#Loading and examining data
#Feature selection
#Feature engineering: dummy variable creation, NA imputation, scaling/centering
#Model definition and... | [
"sklearn.impute.IterativeImputer",
"pandas.read_csv",
"pandas.get_dummies",
"sklearn.preprocessing.StandardScaler",
"pandas.DataFrame",
"pandas.concat"
] | [((814, 901), 'pandas.read_csv', 'pd.read_csv', (['"""../processedData/16smetadat_wrangled_for_post_modeling_analysis.csv"""'], {}), "(\n '../processedData/16smetadat_wrangled_for_post_modeling_analysis.csv')\n", (825, 901), True, 'import pandas as pd\n'), ((3787, 3827), 'sklearn.impute.IterativeImputer', 'Iterative... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# SOURCE: https://github.com/stchris/untangle
# pip install untangle
# OR:
# pip install git+https://github.com/stchris/untangle.git
import untangle
obj = untangle.parse('https://news.yandex.ru/games.rss')
channel = obj.rss.channel
print(chann... | [
"untangle.parse"
] | [((232, 282), 'untangle.parse', 'untangle.parse', (['"""https://news.yandex.ru/games.rss"""'], {}), "('https://news.yandex.ru/games.rss')\n", (246, 282), False, 'import untangle\n')] |