code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#################
# Import modules
#################
from __future__ import print_function, absolute_import, division
# get command line parameters
import sys
# walk directories
import glob
# access to OS functionality
import os
# (de)serialize config file
import json
# ... | [
"PyQt5.QtWidgets.QMessageBox.about",
"getpass.getuser",
"PyQt5.QtGui.QColor",
"cityscapesscripts.helpers.labels.name2label.keys",
"json.dumps",
"PyQt5.QtCore.QRectF",
"os.path.isfile",
"PyQt5.QtCore.QLineF",
"PyQt5.QtGui.QBrush",
"xml.etree.ElementTree.SubElement",
"PyQt5.QtWidgets.QApplication"... | [((110551, 110583), 'PyQt5.QtWidgets.QApplication', 'QtWidgets.QApplication', (['sys.argv'], {}), '(sys.argv)\n', (110573, 110583), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((2725, 2749), 'os.path.isfile', 'os.path.isfile', (['filename'], {}), '(filename)\n', (2739, 2749), False, 'import os\n'), ((6745, ... |
import csv
import json
import datetime
def processCSV(csv_file):
reader = list(csv.reader(csv_file))
result_list = []
header = reader[0]
for row in reader[1:]:
row_object = {}
for num,col in enumerate(row):
row_object[header[num]] = col
result_list.append(row_object... | [
"csv.reader",
"datetime.datetime.today",
"json.dumps"
] | [((84, 104), 'csv.reader', 'csv.reader', (['csv_file'], {}), '(csv_file)\n', (94, 104), False, 'import csv\n'), ((486, 529), 'json.dumps', 'json.dumps', (['data'], {'indent': '(3)', 'sort_keys': '(False)'}), '(data, indent=3, sort_keys=False)\n', (496, 529), False, 'import json\n'), ((369, 394), 'datetime.datetime.toda... |
# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"tensorflow.python.platform.test.main",
"tensorflow.python.ops.sparse_ops.sparse_to_dense",
"numpy.sum",
"tensorflow.python.data.experimental.ops.interleave_ops.parallel_interleave",
"tensorflow.python.framework.sparse_tensor.SparseTensorValue",
"tensorflow.python.data.ops.dataset_ops.Dataset.range",
"n... | [((3690, 3701), 'tensorflow.python.platform.test.main', 'test.main', ([], {}), '()\n', (3699, 3701), False, 'from tensorflow.python.platform import test\n'), ((1411, 1446), 'numpy.array', 'np.array', (['[4, 5, 6]'], {'dtype': 'np.int64'}), '([4, 5, 6], dtype=np.int64)\n', (1419, 1446), True, 'import numpy as np\n'), ((... |
# -*- coding: utf-8 -*-
import collections
import sympy
from abc import ABC, abstractmethod
from qibo import get_device, config
from qibo.config import raise_error
from collections.abc import Iterable
from typing import List, Sequence, Tuple
class Gate:
"""The base class for gate implementation.
All base gat... | [
"qibo.gates.I",
"qibo.get_device",
"qibo.config.raise_error"
] | [((12534, 12610), 'qibo.config.raise_error', 'raise_error', (['NotImplementedError', '"""Cannot use special gates on subroutines."""'], {}), "(NotImplementedError, 'Cannot use special gates on subroutines.')\n", (12545, 12610), False, 'from qibo.config import raise_error\n'), ((13464, 13496), 'qibo.config.raise_error',... |
import hashlib
import os
def generate_hash(param_set):
_salt_keys = ('mode',
'width',
'height',
'upscale',
'quality',
'direction',
'degree')
hash_string = param_set.path
for key in _salt_keys:
... | [
"os.path.splitext",
"os.path.basename"
] | [((622, 644), 'os.path.basename', 'os.path.basename', (['path'], {}), '(path)\n', (638, 644), False, 'import os\n'), ((688, 710), 'os.path.splitext', 'os.path.splitext', (['path'], {}), '(path)\n', (704, 710), False, 'import os\n'), ((756, 778), 'os.path.splitext', 'os.path.splitext', (['path'], {}), '(path)\n', (772, ... |
import tensorflow_quantum as tfq
import tensorflow as tf
import cirq
import sympy
import matplotlib.pyplot as plt
import numpy as np
def make_data(qubits):
train, train_label = [], []
# 0 XOR 0
cir = cirq.Circuit()
cir.append([cirq.I(qubits[0])])
cir.append([cirq.I(qubits[1])])
train.append(cir... | [
"matplotlib.pyplot.title",
"cirq.rx",
"cirq.ry",
"numpy.mean",
"cirq.CNOT",
"cirq.rz",
"cirq.I",
"tensorflow.keras.Input",
"tensorflow.cast",
"tensorflow.keras.optimizers.Adam",
"tensorflow.squeeze",
"cirq.Z",
"matplotlib.pyplot.show",
"tensorflow_quantum.differentiators.ParameterShift",
... | [((2587, 2635), 'tensorflow.keras.Input', 'tf.keras.Input', ([], {'shape': '()', 'dtype': 'tf.dtypes.string'}), '(shape=(), dtype=tf.dtypes.string)\n', (2601, 2635), True, 'import tensorflow as tf\n'), ((2852, 2904), 'tensorflow.keras.models.Model', 'tf.keras.models.Model', ([], {'inputs': 'inputs', 'outputs': 'layer1'... |
from django.conf.urls import patterns, url
from kitsune.wiki import api
# API urls
urlpatterns = patterns(
'',
url(r'^$', api.DocumentList.as_view(), name='document-list'),
url(r'^(?P<slug>[^/]+)$', api.DocumentDetail.as_view(), name='document-detail'),
)
| [
"kitsune.wiki.api.DocumentDetail.as_view",
"kitsune.wiki.api.DocumentList.as_view"
] | [((133, 159), 'kitsune.wiki.api.DocumentList.as_view', 'api.DocumentList.as_view', ([], {}), '()\n', (157, 159), False, 'from kitsune.wiki import api\n'), ((214, 242), 'kitsune.wiki.api.DocumentDetail.as_view', 'api.DocumentDetail.as_view', ([], {}), '()\n', (240, 242), False, 'from kitsune.wiki import api\n')] |
from rest_framework import viewsets
from ice_creams.models import Flavor
from ice_creams.models import IceCream
from ice_creams.models import IceCreamServing
from ice_creams.models import Topping
from .serializers import FlavorSerializer
from .serializers import IceCreamSerializer
from .serializers import IceCreamSer... | [
"ice_creams.models.Topping.objects.all",
"ice_creams.models.IceCreamServing.objects.all",
"ice_creams.models.Flavor.objects.all",
"ice_creams.models.IceCream.objects.all"
] | [((482, 503), 'ice_creams.models.Topping.objects.all', 'Topping.objects.all', ([], {}), '()\n', (501, 503), False, 'from ice_creams.models import Topping\n'), ((648, 668), 'ice_creams.models.Flavor.objects.all', 'Flavor.objects.all', ([], {}), '()\n', (666, 668), False, 'from ice_creams.models import Flavor\n'), ((821,... |
# Copyright Hybrid Logic Ltd. See LICENSE file for details.
"""
AWS provisioner.
"""
from textwrap import dedent
from time import time
from effect.retry import retry
from effect import Effect, Constant
from ._libcloud import LibcloudProvisioner
from ._install import (
provision,
task_install_ssh_key,
)
fr... | [
"textwrap.dedent",
"time.time",
"libcloud.compute.providers.get_driver"
] | [((3244, 3268), 'libcloud.compute.providers.get_driver', 'get_driver', (['Provider.EC2'], {}), '(Provider.EC2)\n', (3254, 3268), False, 'from libcloud.compute.providers import get_driver, Provider\n'), ((4077, 4205), 'textwrap.dedent', 'dedent', (['""" #!/bin/sh\n sed -i \'/Defaults *requi... |
from unittest import TestCase
import numpy as np
from hamcrest import assert_that, is_
from core.batch_generator import BatchGenerator
class DummyBatchGenerator(BatchGenerator):
def __init__(self, batch_items, batch_size):
super().__init__(batch_items, batch_size, 'en')
def shuffle_entries(self):
... | [
"numpy.random.rand",
"hamcrest.is_"
] | [((394, 415), 'numpy.random.rand', 'np.random.rand', (['i', '(26)'], {}), '(i, 26)\n', (408, 415), True, 'import numpy as np\n'), ((780, 786), 'hamcrest.is_', 'is_', (['(3)'], {}), '(3)\n', (783, 786), False, 'from hamcrest import assert_that, is_\n'), ((890, 905), 'hamcrest.is_', 'is_', (['batch_size'], {}), '(batch_s... |
from torch.utils.data import Dataset
from datasets.utils import FullDatasetBase
from torchvision.datasets import ImageFolder
from torchvision import transforms
class ImageNet(FullDatasetBase):
mean = (0.485, 0.456, 0.406)
std = (0.229, 0.224, 0.225)
img_shape = (3, 224, 224)
num_classes = 1000
na... | [
"torchvision.transforms.RandomHorizontalFlip",
"re.match",
"torchvision.datasets.ImageFolder",
"torchvision.transforms.CenterCrop",
"torchvision.transforms.RandomResizedCrop",
"torchvision.transforms.Resize"
] | [((1038, 1138), 'torchvision.datasets.ImageFolder', 'ImageFolder', ([], {'root': '"""/data/ImageNet/train"""', 'transform': 'transform', 'target_transform': 'target_transform'}), "(root='/data/ImageNet/train', transform=transform,\n target_transform=target_transform)\n", (1049, 1138), False, 'from torchvision.datase... |
# -*- coding: utf-8 -*-
"""
Seismic wavelets.
:copyright: 2015 Agile Geoscience
:license: Apache 2.0
"""
from collections import namedtuple
import numpy as np
from scipy.signal import hilbert
from scipy.signal import chirp
def sinc(duration, dt, f, return_t=False, taper='blackman'):
"""
sinc function center... | [
"numpy.asanyarray",
"numpy.sinc",
"numpy.amax",
"numpy.imag",
"scipy.signal.chirp",
"numpy.arange",
"collections.namedtuple",
"scipy.signal.hilbert",
"numpy.sin",
"numpy.squeeze",
"numpy.exp",
"numpy.correlate",
"numpy.real",
"numpy.cos"
] | [((1481, 1527), 'numpy.arange', 'np.arange', (['(-duration / 2.0)', '(duration / 2.0)', 'dt'], {}), '(-duration / 2.0, duration / 2.0, dt)\n', (1490, 1527), True, 'import numpy as np\n'), ((3024, 3066), 'numpy.arange', 'np.arange', (['(-duration / 2)', '(duration / 2)', 'dt'], {}), '(-duration / 2, duration / 2, dt)\n'... |
#! /usr/bin/python
# -*- coding: utf-8 -*-
import os
from tensorlayer import logging
from tensorlayer import visualize
from tensorlayer.files.utils import del_file
from tensorlayer.files.utils import folder_exists
from tensorlayer.files.utils import load_file_list
from tensorlayer.files.utils import maybe_download_a... | [
"tensorlayer.logging.info",
"tensorlayer.files.utils.maybe_download_and_extract",
"tensorlayer.visualize.read_images",
"tensorlayer.files.utils.load_file_list",
"os.path.join"
] | [((1596, 1627), 'os.path.join', 'os.path.join', (['path', '"""flickr25k"""'], {}), "(path, 'flickr25k')\n", (1608, 1627), False, 'import os\n'), ((2080, 2111), 'os.path.join', 'os.path.join', (['path', '"""mirflickr"""'], {}), "(path, 'mirflickr')\n", (2092, 2111), False, 'import os\n'), ((2128, 2192), 'tensorlayer.fil... |
#!/usr/bin/python3
from distutils.core import setup
setup(name='termpdf.py',
version='0.1.0',
description='Graphical pdf reader that works inside the kitty terminal',
author='<NAME>',
author_email='<EMAIL>',
url='https://github.com/dsanson/termpdf.py',
scripts=['termpdf.py'],
... | [
"distutils.core.setup"
] | [((54, 388), 'distutils.core.setup', 'setup', ([], {'name': '"""termpdf.py"""', 'version': '"""0.1.0"""', 'description': '"""Graphical pdf reader that works inside the kitty terminal"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/dsanson/termpdf.py"""', 'scripts': "['termp... |
# Copyright 2020 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"tensorflow.python.profiler.profiler_client.trace",
"tensorflow.compat.v1.app.run"
] | [((1107, 1157), 'tensorflow.python.profiler.profiler_client.trace', 'profiler_client.trace', (['server', 'logdir', 'duration_ms'], {}), '(server, logdir, duration_ms)\n', (1128, 1157), False, 'from tensorflow.python.profiler import profiler_client\n'), ((1189, 1211), 'tensorflow.compat.v1.app.run', 'tf.compat.v1.app.ru... |
#!/usr/bin/env python
# encoding: utf-8
"""Knowledge Management CLI."""
import sys
import os
import arrow
import logging
import sqlite3
from logging.handlers import TimedRotatingFileHandler
import click
from omegaconf import OmegaConf
from command import hourly, daily, robustify, summarize
from action import twitter, ... | [
"click.option",
"omegaconf.OmegaConf.set_readonly",
"logging.Formatter",
"source.hypothesis.register_source",
"action.obsidian.Obsidian",
"sys.stdin.isatty",
"logging.FileHandler",
"sys.stdout.fileno",
"source.pinboard.register_source",
"logging.handlers.TimedRotatingFileHandler",
"click.group",... | [((2083, 2152), 'click.group', 'click.group', ([], {'context_settings': "{'help_option_names': ['-h', '--help']}"}), "(context_settings={'help_option_names': ['-h', '--help']})\n", (2094, 2152), False, 'import click\n'), ((2154, 2193), 'click.option', 'click.option', (['"""--dry-run"""'], {'is_flag': '(True)'}), "('--d... |
# -*- coding: utf-8 -*-
"""
Interactive EDX background refitter
Created on Wed Oct 11 00:44:29 2017
@author: tkc
"""
import sys
import numpy as np
import tkinter as tk
import os
import tkinter.messagebox as tkmess
from tkinter import filedialog
import matplotlib as mpl # using path, figure, rcParams
from matplotlib.b... | [
"tkinter.StringVar",
"tkinter.BooleanVar",
"tkinter.Frame",
"tkinter.Label",
"sys.path.append",
"tkinter.Spinbox",
"tkinter.Checkbutton",
"EDX_data_classes.EDXdataset",
"tkinter.Button",
"matplotlib.rcParams.update",
"tkinter.Entry",
"matplotlib.widgets.Lasso",
"matplotlib.figure.Figure",
... | [((989, 1019), 'matplotlib.rcParams.update', 'mpl.rcParams.update', (['MPL_STYLE'], {}), '(MPL_STYLE)\n', (1008, 1019), True, 'import matplotlib as mpl\n'), ((561, 626), 'sys.path.append', 'sys.path.append', (['"""C:\\\\Users\\\\tkc\\\\Documents\\\\Python_Scripts\\\\EDX"""'], {}), "('C:\\\\Users\\\\tkc\\\\Documents\\\\... |
# Copyright 2021 Hathor Labs
#
# 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, s... | [
"hathor.p2p.manager.ConnectionsManager",
"random.shuffle",
"cProfile.Profile",
"hathor.p2p.factory.HathorClientFactory",
"hathor.pubsub.PubSubManager",
"hathor.checkpoint.Checkpoint",
"hathor.daa.calculate_next_weight",
"hathor.p2p.factory.HathorServerFactory",
"hathor.stratum.StratumFactory",
"ha... | [((1781, 1797), 'hathor.conf.HathorSettings', 'HathorSettings', ([], {}), '()\n', (1795, 1797), False, 'from hathor.conf import HathorSettings\n'), ((1807, 1819), 'structlog.get_logger', 'get_logger', ([], {}), '()\n', (1817, 1819), False, 'from structlog import get_logger\n'), ((1826, 1844), 'hathor.profiler.get_cpu_p... |
import torch
from ._unpooling import Unpooling, Unpooling1d, Unpooling2d
from ._dense import Dense, Dense1d, Dense2d
from typing import Union, List, Tuple
class Upsampling(torch.nn.Module):
"""
An upsampling layer is an 'UnpoolingNd' layer
followed by a 'DenseNd' layer.
"""
@classmethod
def f... | [
"torch.nn.Module.__init__",
"torch.cat",
"torch.nn.functional.pad"
] | [((396, 425), 'torch.nn.Module.__init__', 'torch.nn.Module.__init__', (['obj'], {}), '(obj)\n', (420, 425), False, 'import torch\n'), ((3702, 3728), 'torch.cat', 'torch.cat', (['[X1, X2]'], {'dim': '(1)'}), '([X1, X2], dim=1)\n', (3711, 3728), False, 'import torch\n'), ((3640, 3687), 'torch.nn.functional.pad', 'torch.n... |
#!/usr/bin/python3
import pytest
from brownie.convert import to_address
addr = "0x14b0Ed2a7C4cC60DD8F676AE44D0831d3c9b2a9E"
addr_encoded = b"\x14\xb0\xed*|L\xc6\r\xd8\xf6v\xaeD\xd0\x83\x1d<\x9b*\x9e"
def test_success():
assert to_address(addr) == addr
assert to_address(addr.lower()) == addr
assert to_a... | [
"pytest.raises",
"brownie.convert.to_address"
] | [((236, 252), 'brownie.convert.to_address', 'to_address', (['addr'], {}), '(addr)\n', (246, 252), False, 'from brownie.convert import to_address\n'), ((360, 380), 'brownie.convert.to_address', 'to_address', (['addr[2:]'], {}), '(addr[2:])\n', (370, 380), False, 'from brownie.convert import to_address\n'), ((428, 452), ... |
"""make scheduler_params a separate JSONB field
Revision ID: f5f55452fa58
Revises: <PASSWORD>
Create Date: 2021-09-28 16:48:42.834962
"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = 'f5f55452fa58'
down_revision = '<PASS... | [
"alembic.op.drop_column",
"sqlalchemy.Text"
] | [((685, 726), 'alembic.op.drop_column', 'op.drop_column', (['"""kpi"""', '"""scheduler_params"""'], {}), "('kpi', 'scheduler_params')\n", (699, 726), False, 'from alembic import op\n'), ((533, 542), 'sqlalchemy.Text', 'sa.Text', ([], {}), '()\n', (540, 542), True, 'import sqlalchemy as sa\n')] |
#!/usr/bin/env python3
import logging
import asyncio
import platform
from loguru import logger
from bleak import BleakClient
from config import BLE_CHARACTERISTIC_UUID, BLE_ADDR
from push import ble_packet_event
async def ble_service(loop: asyncio.AbstractEventLoop,
tx: asyncio.Queue,
... | [
"loguru.logger.info",
"bleak.BleakClient",
"asyncio.sleep",
"push.ble_packet_event.inc"
] | [((556, 589), 'loguru.logger.info', 'logger.info', (['"""scanning client..."""'], {}), "('scanning client...')\n", (567, 589), False, 'from loguru import logger\n'), ((604, 636), 'bleak.BleakClient', 'BleakClient', (['BLE_ADDR'], {'loop': 'loop'}), '(BLE_ADDR, loop=loop)\n', (615, 636), False, 'from bleak import BleakC... |
import ee
import numpy as np
import pandas as pd
import geopandas as gpd
from shapely.geometry import box
import rabpro
from rabpro.basin_stats import Dataset
# coords_file = gpd.read_file(r"tests/data/Big Blue River.geojson")
# total_bounds = coords_file.total_bounds
total_bounds = np.array([-85.91331249, 39.426098... | [
"pandas.DataFrame",
"rabpro.basin_stats.Dataset",
"rabpro.basin_stats.fetch_gee",
"numpy.array",
"shapely.geometry.box"
] | [((287, 351), 'numpy.array', 'np.array', (['[-85.91331249, 39.42609864, -85.88453019, 39.46429816]'], {}), '([-85.91331249, 39.42609864, -85.88453019, 39.46429816])\n', (295, 351), True, 'import numpy as np\n'), ((476, 522), 'pandas.DataFrame', 'pd.DataFrame', (["feature['properties']"], {'index': '[0]'}), "(feature['p... |
# graph.py
# Graph Class
# By: <NAME>
class Graph:
"""This class is used to represent a graph that is comprised
of named vertices that are joined via edges of different
weights.
"""
def __init__(self, vertices, directed = False):
"""Initiates the Graph Class
pre: vertice... | [
"tkinter.filedialog.askopenfilename"
] | [((4242, 4259), 'tkinter.filedialog.askopenfilename', 'askopenfilename', ([], {}), '()\n', (4257, 4259), False, 'from tkinter.filedialog import askopenfilename\n')] |
"""SSD1351 demo (fonts)."""
from time import sleep
from ssd1351 import Display, color565
from machine import Pin, SPI
from xglcd_font import XglcdFont
def test():
"""Test code."""
spi = SPI(2, baudrate=14500000, sck=Pin(18), mosi=Pin(23))
display = Display(spi, dc=Pin(17), cs=Pin(5), rst=Pin(16))
pri... | [
"xglcd_font.XglcdFont",
"machine.Pin",
"ssd1351.color565",
"time.sleep"
] | [((370, 411), 'xglcd_font.XglcdFont', 'XglcdFont', (['"""fonts/ArcadePix9x11.c"""', '(9)', '(11)'], {}), "('fonts/ArcadePix9x11.c', 9, 11)\n", (379, 411), False, 'from xglcd_font import XglcdFont\n'), ((424, 459), 'xglcd_font.XglcdFont', 'XglcdFont', (['"""fonts/Bally7x9.c"""', '(7)', '(9)'], {}), "('fonts/Bally7x9.c',... |
# -*- coding: utf-8 -*-
"""Loading Data.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1CXQRx9Jfj4tmXZmu_DFiUzpPJqF1sdf3
"""
import random
import numpy as np
import pandas as pd
from datasets import Dataset
"""#Loading Data"""
"""A module for ... | [
"pandas.DataFrame",
"logging.info"
] | [((3582, 3629), 'pandas.DataFrame', 'pd.DataFrame', (["{'Id': ids, 'Label': predictions}"], {}), "({'Id': ids, 'Label': predictions})\n", (3594, 3629), True, 'import pandas as pd\n'), ((3634, 3699), 'logging.info', 'logging.info', (['f"""--> Writing predictions to {path_to_predictions}"""'], {}), "(f'--> Writing predic... |
from beamline.web.Beamline import Beamline
from beamline.miners.DiscoveryMiner import DiscoveryMiner
Beamline.miners.append(DiscoveryMiner())
| [
"beamline.miners.DiscoveryMiner.DiscoveryMiner"
] | [((125, 141), 'beamline.miners.DiscoveryMiner.DiscoveryMiner', 'DiscoveryMiner', ([], {}), '()\n', (139, 141), False, 'from beamline.miners.DiscoveryMiner import DiscoveryMiner\n')] |
import argparse
from os import get_terminal_size
from sys import stderr
from .cli_base import CliBaseClass
class StdoutFormat:
BOLD = "\033[1m"
ENDC = "\033[0m"
GREEN = "\033[92m"
class DeviceCLI(CliBaseClass):
parser_help = "Get information about device and attached pi-top hardware"
cli_name =... | [
"os.get_terminal_size",
"pitop.system.pitop_peripherals",
"pitop.system.device_info",
"argparse.ArgumentParser"
] | [((3339, 3378), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'add_help': '(False)'}), '(add_help=False)\n', (3362, 3378), False, 'import argparse\n'), ((1574, 1587), 'pitop.system.device_info', 'device_info', ([], {}), '()\n', (1585, 1587), False, 'from pitop.system import device_info\n'), ((2317, 2336),... |
import pcon
def test_solid():
a = pcon.Counter(5)
a.deserialize("python_counter.pcon")
b = pcon.Solid.from_counter(a, 20)
assert b.get(108) == False
b.serialize("python_solid.pcon")
c = pcon.Solid.deserialize("python_solid.pcon")
assert c.get(108) == False
c.set(108, True)
as... | [
"pcon.Solid.from_counter",
"pcon.Counter",
"pcon.Solid.deserialize"
] | [((39, 54), 'pcon.Counter', 'pcon.Counter', (['(5)'], {}), '(5)\n', (51, 54), False, 'import pcon\n'), ((105, 135), 'pcon.Solid.from_counter', 'pcon.Solid.from_counter', (['a', '(20)'], {}), '(a, 20)\n', (128, 135), False, 'import pcon\n'), ((215, 258), 'pcon.Solid.deserialize', 'pcon.Solid.deserialize', (['"""python_s... |
import sys, os
sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
import math
from hypothesis import given, settings, strategies as st
from generators_2d.generators import generate_2d_line
@given(
st.integers(min_value=-10 ** 5, max_value=10 ** 5),
st.integers(min_value=-10 ** 5, max_value=10 ... | [
"hypothesis.strategies.integers",
"os.path.dirname",
"math.floor",
"generators_2d.generators.generate_2d_line"
] | [((219, 269), 'hypothesis.strategies.integers', 'st.integers', ([], {'min_value': '(-10 ** 5)', 'max_value': '(10 ** 5)'}), '(min_value=-10 ** 5, max_value=10 ** 5)\n', (230, 269), True, 'from hypothesis import given, settings, strategies as st\n'), ((275, 325), 'hypothesis.strategies.integers', 'st.integers', ([], {'m... |
# -*- coding: utf-8 -*-
# Copyright (C) 2018, <NAME>. All rights reserved.
#
# You should have received a copy of the MIT License along with this program.
# If not, see https://opensource.org/licenses/MIT.
#
# 2018-07-11 CNHume Added Command and FileManager classes
# 2018-07-09 CNHume Created File for Eric Peterson of... | [
"Player.Player",
"FileManager.FileManager",
"random.randrange",
"traceback.format_exc",
"Command.Command"
] | [((1044, 1090), 'Command.Command', 'Command', (['WORD_FILE', 'ART_FILE', 'FILE_EXT', 'TRIALS'], {}), '(WORD_FILE, ART_FILE, FILE_EXT, TRIALS)\n', (1051, 1090), False, 'from Command import Command\n'), ((1174, 1224), 'FileManager.FileManager', 'FileManager', (['SETUP_PATH', 'command.file_ext', 'verbose'], {}), '(SETUP_P... |
import math
from ezdxf.math.vector import Vector
def test_init_no_params():
v = Vector()
assert v == (0, 0, 0)
assert v == Vector()
def test_init_one_param():
v = Vector((2, 3))
assert v == (2, 3) # z is 0.
v = Vector((2, 3, 4))
assert v == (2, 3, 4)
def test_init_two_params():
v... | [
"ezdxf.math.vector.Vector.from_deg_angle",
"copy.deepcopy",
"math.radians",
"copy.copy",
"ezdxf.math.vector.Vector.from_angle",
"math.sin",
"ezdxf.math.vector.Vector",
"math.isclose",
"math.cos"
] | [((86, 94), 'ezdxf.math.vector.Vector', 'Vector', ([], {}), '()\n', (92, 94), False, 'from ezdxf.math.vector import Vector\n'), ((183, 197), 'ezdxf.math.vector.Vector', 'Vector', (['(2, 3)'], {}), '((2, 3))\n', (189, 197), False, 'from ezdxf.math.vector import Vector\n'), ((241, 258), 'ezdxf.math.vector.Vector', 'Vecto... |
"""
Slixmpp: The Slick XMPP Library
Implementation of xeps for Internet of Things
http://wiki.xmpp.org/web/Tech_pages/IoT_systems
Copyright (C) 2013 Sustainable Innovation, <EMAIL>, <EMAIL>
This file is part of Slixmpp.
See the file LICENSE for copying permission.
"""
from slixmpp import Iq, M... | [
"slixmpp.xmlstream.ElementBase.setup",
"slixmpp.xmlstream.register_stanza_plugin",
"slixmpp.xmlstream.ElementBase.__init__"
] | [((15156, 15194), 'slixmpp.xmlstream.register_stanza_plugin', 'register_stanza_plugin', (['Iq', 'ControlSet'], {}), '(Iq, ControlSet)\n', (15178, 15194), False, 'from slixmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID\n'), ((15195, 15238), 'slixmpp.xmlstream.register_stanza_plugin', 'register_stanza_... |
import sys
n = int(sys.stdin.readline())
total =0
for i in range(1,n+1):
while i%5 == 0:
i/=5
total +=1
print(total)
| [
"sys.stdin.readline"
] | [((20, 40), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (38, 40), False, 'import sys\n')] |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
UL call demonstrated: TmrDevice.pulse_out_start()
Purpose: Generate an output pulse using the
specified timer
Demonstration: Outputs user defined pulse on the
... | [
"sys.stdout.write",
"os.system",
"uldaq.DaqDevice",
"uldaq.get_daq_device_inventory",
"time.sleep",
"sys.stdout.flush"
] | [((6327, 6341), 'sys.stdout.flush', 'stdout.flush', ([], {}), '()\n', (6339, 6341), False, 'from sys import stdout\n'), ((6346, 6356), 'time.sleep', 'sleep', (['(0.5)'], {}), '(0.5)\n', (6351, 6356), False, 'from time import sleep\n'), ((1700, 1740), 'uldaq.get_daq_device_inventory', 'get_daq_device_inventory', (['inte... |
import os
import redis
import json
from flask import Flask, request, render_template, send_from_directory
from reporter import Reporter
host = os.getenv("REDIS_HOST")
if(host == None):
host = "redis"
app = Flask(__name__)
r = Reporter(host, 6379)
def build_cache():
cache = []
members = r.find_members()
... | [
"flask.Flask",
"json.dumps",
"reporter.Reporter",
"flask.render_template",
"flask.send_from_directory",
"os.getenv"
] | [((145, 168), 'os.getenv', 'os.getenv', (['"""REDIS_HOST"""'], {}), "('REDIS_HOST')\n", (154, 168), False, 'import os\n'), ((213, 228), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (218, 228), False, 'from flask import Flask, request, render_template, send_from_directory\n'), ((233, 253), 'reporter.Repor... |
import logging
import numpy as np
import pytest
import xskillscore as xs
from climpred.exceptions import CoordinateError
from climpred.prediction import compute_hindcast
def test_same_inits_initializations(
hind_ds_initialized_1d_cftime, reconstruction_ds_1d_cftime, caplog
):
"""Tests that inits are identic... | [
"climpred.prediction.compute_hindcast",
"pytest.raises",
"numpy.arange",
"xskillscore.mse",
"pytest.mark.parametrize",
"numpy.concatenate"
] | [((1597, 1664), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""alignment"""', "['same_inits', 'same_verifs']"], {}), "('alignment', ['same_inits', 'same_verifs'])\n", (1620, 1664), False, 'import pytest\n'), ((2371, 2438), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""alignment"""', "['same_i... |
'''
Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: MIT-0
'''
import json
import urllib.request
import os
import time
from neptune_python_utils.endpoints import Endpoints
class BulkLoad:
def __init__(self, source, format='csv', role=None, region=None, endpoint... | [
"neptune_python_utils.endpoints.Endpoints",
"json.dumps",
"time.sleep"
] | [((904, 915), 'neptune_python_utils.endpoints.Endpoints', 'Endpoints', ([], {}), '()\n', (913, 915), False, 'from neptune_python_utils.endpoints import Endpoints\n'), ((1323, 1339), 'json.dumps', 'json.dumps', (['data'], {}), '(data)\n', (1333, 1339), False, 'import json\n'), ((2006, 2040), 'json.dumps', 'json.dumps', ... |
#!/usr/bin/env python
"""
Plot signal heatmaps from TFBS across different bigwigs
@author: <NAME>
@contact: mette.bentsen (at) mpi-bn.mpg.de
@license: MIT
"""
import os
import sys
import argparse
import logging
import numpy as np
import matplotlib as mpl
mpl.use("Agg") #non-interactive backend
import matplotlib.pyp... | [
"numpy.abs",
"argparse.ArgumentParser",
"matplotlib.pyplot.suptitle",
"numpy.floor",
"matplotlib.pyplot.figure",
"numpy.mean",
"numpy.arange",
"tobias.parsers.add_heatmap_arguments",
"matplotlib.pyplot.Subplot",
"matplotlib.colors.Normalize",
"matplotlib.pyplot.close",
"numpy.ceil",
"os.path... | [((259, 273), 'matplotlib.use', 'mpl.use', (['"""Agg"""'], {}), "('Agg')\n", (266, 273), True, 'import matplotlib as mpl\n'), ((8567, 8601), 'numpy.arange', 'np.arange', (['(-args.flank)', 'args.flank'], {}), '(-args.flank, args.flank)\n', (8576, 8601), True, 'import numpy as np\n'), ((8610, 8653), 'matplotlib.pyplot.f... |
from contextlib import contextmanager
import random
import pylibmc
# project
import ddtrace
from ddtrace import config
# 3p
from ddtrace.vendor.wrapt import ObjectProxy
from ...constants import ANALYTICS_SAMPLE_RATE_KEY
from ...constants import SPAN_MEASURED_KEY
from ...ext import SpanTypes
from ...ext import memcac... | [
"ddtrace.config.pylibmc.get_analytics_sample_rate",
"ddtrace.Pin.get_from",
"random.choice",
"ddtrace.Pin"
] | [((1597, 1640), 'ddtrace.Pin', 'ddtrace.Pin', ([], {'service': 'service', 'tracer': 'tracer'}), '(service=service, tracer=tracer)\n', (1608, 1640), False, 'import ddtrace\n'), ((2088, 2114), 'ddtrace.Pin.get_from', 'ddtrace.Pin.get_from', (['self'], {}), '(self)\n', (2108, 2114), False, 'import ddtrace\n'), ((4526, 455... |
# Generated by Django 2.1.15 on 2020-02-25 12:03
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('news', '0001_initial'),
]
operations = [
migrations.RemoveField(
model_name='news',
... | [
"django.db.migrations.RemoveField",
"django.db.models.ForeignKey"
] | [((255, 310), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""news"""', 'name': '"""image"""'}), "(model_name='news', name='image')\n", (277, 310), False, 'from django.db import migrations, models\n'), ((449, 542), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'default'... |
import json
import urllib.parse
import urllib.request
class YahooApi:
def __init__(self, appid):
self.appid = appid
def api(self, apiurl, params, method='GET'):
params['appid'] = self.appid
params = urllib.parse.urlencode(params, encoding='UTF-8')
if method == 'GET':
... | [
"json.loads"
] | [((732, 752), 'json.loads', 'json.loads', (['response'], {}), '(response)\n', (742, 752), False, 'import json\n')] |
from __future__ import annotations
from typing import Any, Callable, Optional, TYPE_CHECKING
import string
from subtypes import Dict
from iotools import Config
from .argument import Argument
from .enums import RunMode
from .hierarchy import Hierarchy
if TYPE_CHECKING:
from .declarative import Command, Group
... | [
"iotools.Config",
"subtypes.Dict"
] | [((4374, 4414), 'iotools.Config', 'Config', ([], {'author': '"""command"""', 'name': 'self.name'}), "(author='command', name=self.name)\n", (4380, 4414), False, 'from iotools import Config\n'), ((4506, 4512), 'subtypes.Dict', 'Dict', ([], {}), '()\n', (4510, 4512), False, 'from subtypes import Dict\n')] |
from __future__ import absolute_import, division, print_function
from libtbx import easy_run
import libtbx.load_env
import os.path
import time
# taken from phenix_regression/refinement/ncs/tst_ncs_0.py
pdb_str = """\
CRYST1 100.000 100.000 100.000 90.00 90.00 90.00 P 1
ATOM 1 N ALA A 1 27.344 16.... | [
"libtbx.easy_run.call",
"time.time"
] | [((17972, 17983), 'time.time', 'time.time', ([], {}), '()\n', (17981, 17983), False, 'import time\n'), ((17437, 17455), 'libtbx.easy_run.call', 'easy_run.call', (['cmd'], {}), '(cmd)\n', (17450, 17455), False, 'from libtbx import easy_run\n'), ((18126, 18137), 'time.time', 'time.time', ([], {}), '()\n', (18135, 18137),... |
import pytest
import jax.numpy as np
from pzflow.distributions import *
@pytest.mark.parametrize(
"distribution,inputs,params",
[
(Normal, (2,), ()),
(Tdist, (2,), np.log(30.0)),
(Uniform, ((0, 1), (0, 1)), ()),
(Joint, (Normal(1), Uniform((0, 1))), ((), ())),
(Joint, (... | [
"jax.numpy.array",
"jax.numpy.log",
"jax.numpy.isclose",
"pytest.raises",
"jax.numpy.allclose",
"pytest.mark.parametrize"
] | [((1453, 1514), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""inputs"""', '[((-1, 1, 2),), ((2, 1),)]'], {}), "('inputs', [((-1, 1, 2),), ((2, 1),)])\n", (1476, 1514), False, 'import pytest\n'), ((1312, 1358), 'jax.numpy.array', 'np.array', (['[[[1, 0], [0, 1]], [[1, 1], [1, 1]]]'], {}), '([[[1, 0], [0, 1... |
# -*- coding: utf-8 -*-
""" 解压压缩包，支持zip, rar
"""
import os
import sys
import six
class CompressedFile(object):
""" a simple wrapper class for ZipFile and RarFile, it's only support read.
"""
EXTS = ['zip', 'rar']
def __init__(self, file):
self.file = file
self._file = Non... | [
"os.path.abspath",
"rarfile.RarFile",
"zipfile.ZipFile",
"os.path.splitext"
] | [((340, 362), 'os.path.splitext', 'os.path.splitext', (['file'], {}), '(file)\n', (356, 362), False, 'import os\n'), ((1510, 1536), 'os.path.splitext', 'os.path.splitext', (['filename'], {}), '(filename)\n', (1526, 1536), False, 'import os\n'), ((444, 475), 'zipfile.ZipFile', 'zipfile.ZipFile', (['self.file', '"""r"""'... |
from pyrr import matrix44
import moderngl
from demosys import geometry
from demosys.opengl.texture import helper
from demosys.effects import Effect
class DeferredRenderer(Effect):
runnable = False
def __init__(self, width, height, gbuffer=None, lightbuffer=None):
self.width = width
self.heig... | [
"demosys.opengl.texture.helper._depth_sampler.use",
"demosys.opengl.texture.helper.draw_depth",
"pyrr.matrix44.create_from_translation",
"demosys.geometry.quad_fs",
"demosys.opengl.texture.helper.draw",
"pyrr.matrix44.multiply",
"demosys.geometry.cube",
"demosys.opengl.texture.helper._depth_sampler.cl... | [((1404, 1445), 'demosys.geometry.cube', 'geometry.cube', ([], {'width': '(2)', 'height': '(2)', 'depth': '(2)'}), '(width=2, height=2, depth=2)\n', (1417, 1445), False, 'from demosys import geometry\n'), ((1750, 1768), 'demosys.geometry.quad_fs', 'geometry.quad_fs', ([], {}), '()\n', (1766, 1768), False, 'from demosys... |
# -*- coding: utf-8 -*-
# file: squeeze_embedding.py
# author: songyouwei <<EMAIL>>
# Copyright (C) 2018. All Rights Reserved.
import torch
import torch.nn as nn
import numpy as np
class SqueezeEmbedding(nn.Module):
"""
Squeeze sequence embedding length to the longest one in the batch
"""
def __ini... | [
"torch.sort",
"torch.nn.utils.rnn.pad_packed_sequence",
"torch.nn.utils.rnn.pack_padded_sequence"
] | [((879, 958), 'torch.nn.utils.rnn.pack_padded_sequence', 'torch.nn.utils.rnn.pack_padded_sequence', (['x', 'x_len'], {'batch_first': 'self.batch_first'}), '(x, x_len, batch_first=self.batch_first)\n', (918, 958), False, 'import torch\n'), ((999, 1076), 'torch.nn.utils.rnn.pad_packed_sequence', 'torch.nn.utils.rnn.pad_p... |
import json
commcare_build_config = json.loads("""{
"_id": "config--commcare-builds",
"doc_type": "CommCareBuildConfig",
"preview": {
"version": "1.2.1",
"build_number": null,
"latest": true
},
"defaults": [{
"version": "1.2.1",
"build_number": null,
"latest": ... | [
"json.loads"
] | [((38, 1318), 'json.loads', 'json.loads', (['"""{\n "_id": "config--commcare-builds",\n "doc_type": "CommCareBuildConfig",\n "preview": {\n "version": "1.2.1",\n "build_number": null,\n "latest": true\n },\n "defaults": [{\n "version": "1.2.1",\n "build_number": null,\n "la... |
import setuptools
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="opentool",
version="0.0.12",
author="huutrinh",
author_email="<EMAIL>",
description="Tools for AI project",
long_description=long_description,
long_description_content_type="text/m... | [
"setuptools.find_packages"
] | [((393, 419), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (417, 419), False, 'import setuptools\n')] |
#Object for handling numerical functions
from plotInt import Iplot
from re import split
class lightCurve:
x = 0
y = 1
dy = 2
class lcOutOfBound(Exception): pass
def __init__(self,table = []):
self.table = []
try:
for line in open(table):
try:
... | [
"plotInt.Iplot.plotCurves",
"plotInt.Iplot.clearPlots"
] | [((3343, 3361), 'plotInt.Iplot.clearPlots', 'Iplot.clearPlots', ([], {}), '()\n', (3359, 3361), False, 'from plotInt import Iplot\n'), ((3370, 3392), 'plotInt.Iplot.plotCurves', 'Iplot.plotCurves', (['self'], {}), '(self)\n', (3386, 3392), False, 'from plotInt import Iplot\n')] |
import argparse
import io
import os
import shutil
import unittest
import wx
from pathlib import Path
from contextlib import redirect_stdout
from unittests import pfr
from pyfuzzyrenamer import args, config, filters, main_listctrl, main_dlg, masks
from pyfuzzyrenamer.config import get_config
from pyfuzzyrenamer.args im... | [
"unittest.main",
"io.StringIO",
"os.path.dirname",
"os.path.exists",
"pyfuzzyrenamer.main_dlg.MainFrame",
"pyfuzzyrenamer.config.get_config",
"contextlib.redirect_stdout",
"shutil.rmtree",
"os.path.join",
"pyfuzzyrenamer.args.theArgsParser.parse_args"
] | [((9237, 9252), 'unittest.main', 'unittest.main', ([], {}), '()\n', (9250, 9252), False, 'import unittest\n'), ((897, 924), 'os.path.exists', 'os.path.exists', (['self.outdir'], {}), '(self.outdir)\n', (911, 924), False, 'import os\n'), ((1091, 1138), 'os.path.join', 'os.path.join', (['self.outdir', '"""sources_multima... |
# Generated by Django 3.1.5 on 2021-04-27 15:08
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('authentication', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='user',
... | [
"django.db.models.ManyToManyField"
] | [((366, 497), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'blank': '(True)', 'related_name': '"""_user_subscribers_+"""', 'to': 'settings.AUTH_USER_MODEL', 'verbose_name': '"""Subscibers"""'}), "(blank=True, related_name='_user_subscribers_+', to=\n settings.AUTH_USER_MODEL, verbose_name='Sub... |
# Copyright 2014 Rackspace Inc.
#
# Author: <NAME> <<EMAIL>>
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"oslo_config.cfg.OptGroup",
"oslo_config.cfg.StrOpt",
"oslo_config.cfg.FloatOpt",
"oslo_config.cfg.IntOpt",
"oslo_config.cfg.ListOpt"
] | [((699, 778), 'oslo_config.cfg.OptGroup', 'cfg.OptGroup', ([], {'name': '"""service:agent"""', 'title': '"""Configuration for the Agent Service"""'}), "(name='service:agent', title='Configuration for the Agent Service')\n", (711, 778), False, 'from oslo_config import cfg\n'), ((809, 880), 'oslo_config.cfg.IntOpt', 'cfg... |
import datetime
import logging
import localflavor
from paying_for_college.models.disclosures import (
DEFAULT_EXCLUSIONS, HIGHEST_DEGREES, School
)
STATES = sorted(
[tup[0] for tup in localflavor.us.us_states.CONTIGUOUS_STATES] +
[tup[0] for tup in localflavor.us.us_states.NON_CONTIGUOUS_STATES] +
[... | [
"paying_for_college.models.disclosures.HIGHEST_DEGREES.keys",
"paying_for_college.models.disclosures.School.objects.filter",
"datetime.datetime.now",
"logging.getLogger"
] | [((394, 421), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (411, 421), False, 'import logging\n'), ((2182, 2205), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (2203, 2205), False, 'import datetime\n'), ((361, 383), 'paying_for_college.models.disclosures.HIGHEST_DE... |
import sqlite3
class DBase:
def __init__(self, db_file):
self.conn = sqlite3.connect(db_file)
self.cur = self.conn.cursor()
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if self.cur:
self.cur.close()
if self.conn:
... | [
"sqlite3.connect"
] | [((84, 108), 'sqlite3.connect', 'sqlite3.connect', (['db_file'], {}), '(db_file)\n', (99, 108), False, 'import sqlite3\n')] |
import torch
import numpy as np
class Network(torch.nn.Module):
def __init__(self, structure):
super(Network, self).__init__()
self.structure = structure
self.layers_pool_inited = self.init_layers(self.structure)
def init_layers(self, structure):
# pool of layers, whic... | [
"numpy.where",
"torch.cat"
] | [((9206, 9253), 'numpy.where', 'np.where', (['(structure.matrix[:, layer_index] == 1)'], {}), '(structure.matrix[:, layer_index] == 1)\n', (9214, 9253), True, 'import numpy as np\n'), ((768, 820), 'numpy.where', 'np.where', (['(self.structure.matrix[:, layer_index] == 1)'], {}), '(self.structure.matrix[:, layer_index] ... |
import functools
import logging
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from typing import Iterable
import frontmatter
from libcst import AnnAssign, parse_module
from flake8_codes.semanticize import semanticize
from flake8_codes.wemake_python_styleguide.constants.models import (
... | [
"functools.partial",
"flake8_codes.wemake_python_styleguide.constants.models.NotPublicConstant",
"flake8_codes.wemake_python_styleguide.constants.models.NotAnAssignment",
"pathlib.Path",
"frontmatter.YAMLHandler",
"frontmatter.dump",
"libcst.parse_module",
"concurrent.futures.ThreadPoolExecutor",
"l... | [((417, 444), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (434, 444), False, 'import logging\n'), ((1510, 1535), 'libcst.parse_module', 'parse_module', (['python_code'], {}), '(python_code)\n', (1522, 1535), False, 'from libcst import AnnAssign, parse_module\n'), ((717, 736), 'flake8_c... |
from copy import deepcopy
from interface.task import Task
from lib.state import State
from lib.stateeffortmap import StateEffortMap
class SimpleTask(Task):
_process_start_state = State.S0
_process_terminal_state = State.S9
_global_id = 0
def __init__(self,
effort_map: StateEffortMap)... | [
"copy.deepcopy"
] | [((1226, 1244), 'copy.deepcopy', 'deepcopy', (['self._id'], {}), '(self._id)\n', (1234, 1244), False, 'from copy import deepcopy\n'), ((1423, 1448), 'copy.deepcopy', 'deepcopy', (['self._lead_time'], {}), '(self._lead_time)\n', (1431, 1448), False, 'from copy import deepcopy\n'), ((1599, 1620), 'copy.deepcopy', 'deepco... |
import mock
import os
from django.contrib.auth import get_user_model
from django.test.client import Client
from django.core.urlresolvers import reverse
from favit.models import Favorite
from firecares.firecares_core.tests.base import BaseFirecaresTestcase
from firecares.firestation.models import FireDepartment, FireSta... | [
"favit.models.Favorite.objects.create",
"django.core.urlresolvers.reverse",
"os.path.dirname",
"django.contrib.auth.get_user_model",
"mock.patch",
"django.test.client.Client",
"firecares.firestation.models.FireDepartment.objects.create",
"firecares.firestation.models.FireStation.create_station"
] | [((334, 350), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (348, 350), False, 'from django.contrib.auth import get_user_model\n'), ((402, 451), 'mock.patch', 'mock.patch', (['"""geopy.geocoders.base.urllib_urlopen"""'], {}), "('geopy.geocoders.base.urllib_urlopen')\n", (412, 451), False, 'i... |
import datetime
import time
from typing import Callable
import math
from utils.ask_library import AskLibrary
from transitions import Machine
#from social_interaction_cloud.basic_connector import BasicSICConnector, RobotPosture
from social_interaction_cloud.action import ActionRunner
from social_interaction_cloud.basic... | [
"transitions.Machine",
"pandas.read_csv",
"utils.ask_library.AskLibrary",
"time.sleep",
"social_interaction_cloud.action.ActionRunner",
"social_interaction_cloud.basic_connector.BasicSICConnector"
] | [((1001, 1023), 'social_interaction_cloud.action.ActionRunner', 'ActionRunner', (['self.sic'], {}), '(self.sic)\n', (1013, 1023), False, 'from social_interaction_cloud.action import ActionRunner\n'), ((1079, 1094), 'utils.ask_library.AskLibrary', 'AskLibrary', (['sic'], {}), '(sic)\n', (1089, 1094), False, 'from utils.... |
import logging
from optparse import make_option
import re
import types
from django.core.management.base import BaseCommand
from smsc.api import sms_read
from smsapp import models
logger = logging.getLogger(__name__)
class Command(BaseCommand):
option_list = BaseCommand.option_list + (
make_option('--h... | [
"smsapp.models.PhoneData.objects.get",
"optparse.make_option",
"smsc.api.sms_read.get_sms_list",
"logging.getLogger",
"re.compile"
] | [((192, 219), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (209, 219), False, 'import logging\n'), ((538, 566), 'smsc.api.sms_read.get_sms_list', 'sms_read.get_sms_list', (['hours'], {}), '(hours)\n', (559, 566), False, 'from smsc.api import sms_read\n'), ((759, 777), 're.compile', 're.... |
import os
from .firebase_authentication import firebase_auth
from itsdangerous import (
TimedJSONWebSignatureSerializer as Serializer,
BadSignature,
SignatureExpired,
)
SECRET_KEY = os.environ.get("SECRET_KEY")
def generate_auth_token(idToken, expiration=3600):
s = Serializer(SECRET_KEY, expires_in=e... | [
"os.environ.get",
"itsdangerous.TimedJSONWebSignatureSerializer"
] | [((195, 223), 'os.environ.get', 'os.environ.get', (['"""SECRET_KEY"""'], {}), "('SECRET_KEY')\n", (209, 223), False, 'import os\n'), ((285, 330), 'itsdangerous.TimedJSONWebSignatureSerializer', 'Serializer', (['SECRET_KEY'], {'expires_in': 'expiration'}), '(SECRET_KEY, expires_in=expiration)\n', (295, 330), True, 'from... |
# Generated by Django 3.2.8 on 2021-11-22 04:59
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
("twoops", "0010_tweetsearch"),
]
operations = [
migrations.AlterModelOptions(
name="tweetsearch",
options={"verbose_name_plur... | [
"django.db.migrations.AlterModelOptions"
] | [((219, 323), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""tweetsearch"""', 'options': "{'verbose_name_plural': 'Tweet Searches'}"}), "(name='tweetsearch', options={\n 'verbose_name_plural': 'Tweet Searches'})\n", (247, 323), False, 'from django.db import migrations\n')... |
# coding: utf-8
import numpy as np
import torch
def convert_to_np(weights):
for k, v in weights.items():
if isinstance(v, torch.Tensor):
weights[k] = v.cpu().numpy()
elif isinstance(v, np.ndarray):
pass
elif isinstance(v, list):
weights[k] = np.array(v)
... | [
"torch.mean",
"numpy.array",
"torch.no_grad",
"torch.cosine_similarity",
"torch.from_numpy"
] | [((1234, 1249), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (1247, 1249), False, 'import torch\n'), ((1413, 1454), 'torch.cosine_similarity', 'torch.cosine_similarity', (['old_out', 'new_out'], {}), '(old_out, new_out)\n', (1436, 1454), False, 'import torch\n'), ((610, 629), 'torch.from_numpy', 'torch.from_nump... |
#! /usr/bin/python
# by <EMAIL> at Mon Nov 6 18:08:44 CET 2017
import struct
import zlib
def write_pgm(filename, img_data):
f = open(filename, 'wb')
try:
f.write('P5 %d %d 255\n' % (len(img_data[0]), len(img_data)))
for line in img_data:
f.write(line.replace('\1', '\xff'))
finally:
f.close()... | [
"zlib.crc32",
"zlib.adler32",
"struct.pack"
] | [((1936, 2028), 'struct.pack', 'struct.pack', (['""">LL5B"""', 'width', 'height', 'bpc', 'color_type', 'compression', 'filter', 'is_interlaced'], {}), "('>LL5B', width, height, bpc, color_type, compression, filter,\n is_interlaced)\n", (1947, 2028), False, 'import struct\n'), ((842, 892), 'struct.pack', 'struct.pack... |
""" Compose multiple datasets in a single loader. """
import numpy as np
from copy import deepcopy
from torch.utils.data import Dataset
from dataset.wireframe_dataset import WireframeDataset
from dataset.holicity_dataset import HolicityDataset
class MergeDataset(Dataset):
def __init__(self, mode, config=None):
... | [
"dataset.wireframe_dataset.WireframeDataset",
"copy.deepcopy",
"dataset.holicity_dataset.HolicityDataset"
] | [((449, 465), 'copy.deepcopy', 'deepcopy', (['config'], {}), '(config)\n', (457, 465), False, 'from copy import deepcopy\n'), ((778, 813), 'dataset.wireframe_dataset.WireframeDataset', 'WireframeDataset', (['mode', 'spec_config'], {}), '(mode, spec_config)\n', (794, 813), False, 'from dataset.wireframe_dataset import W... |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch import optim
from torch.autograd import Variable
from torch.nn.parameter import Parameter
from torchvision import datasets, transforms
from torch.utils.data import DataLoader, Dataset
from xbbo.utils.constants import MAXIN... | [
"torch.FloatTensor",
"torch.empty",
"numpy.isnan",
"torch.no_grad",
"torch.optim.SGD"
] | [((1051, 1083), 'torch.optim.SGD', 'optim.SGD', (['[self.theta]'], {'lr': '(0.01)'}), '([self.theta], lr=0.01)\n', (1060, 1083), False, 'from torch import optim\n'), ((1326, 1360), 'torch.empty', 'torch.empty', (['(2)'], {'device': 'self.device'}), '(2, device=self.device)\n', (1337, 1360), False, 'import torch\n'), ((... |
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or ag... | [
"googlecloudsdk.command_lib.compute.flags.AddZoneFlag",
"googlecloudsdk.command_lib.compute.tpus.util.List"
] | [((959, 1152), 'googlecloudsdk.command_lib.compute.flags.AddZoneFlag', 'compute_flags.AddZoneFlag', (['parser'], {'resource_type': '"""tpu"""', 'operation_type': '"""list"""', 'explanation': '"""List TPUs from this zone. If not specified, will list TPUs in `default` compute/zone."""'}), "(parser, resource_type='tpu', o... |
from django.db.models import Q
from django.contrib.auth import get_user_model
from .utils import sorted_standings
def percent(num, denom):
return 0.0 if denom == 0 else num / denom * 100.0
class RosterStats:
def __init__(self, user, league, season=None):
self.user = user
self.season = seaso... | [
"django.contrib.auth.get_user_model",
"django.db.models.Q"
] | [((536, 552), 'django.db.models.Q', 'Q', ([], {'correct__gt': '(0)'}), '(correct__gt=0)\n', (537, 552), False, 'from django.db.models import Q\n'), ((555, 569), 'django.db.models.Q', 'Q', ([], {'wrong__gt': '(0)'}), '(wrong__gt=0)\n', (556, 569), False, 'from django.db.models import Q\n'), ((1755, 1771), 'django.contri... |
'''OpenGL extension NV.conservative_raster_pre_snap
This module customises the behaviour of the
OpenGL.raw.GLES2.NV.conservative_raster_pre_snap to provide a more
Python-friendly API
Overview (from the spec)
NV_conservative_raster_pre_snap_triangles provides a new mode to achieve
rasterization of trian... | [
"OpenGL.extensions.hasGLExtension"
] | [((1130, 1172), 'OpenGL.extensions.hasGLExtension', 'extensions.hasGLExtension', (['_EXTENSION_NAME'], {}), '(_EXTENSION_NAME)\n', (1155, 1172), False, 'from OpenGL import extensions\n')] |
# -*- coding: utf-8 -*-
import os
import platform
import pytest
import yaml
import giraffez
from giraffez.constants import *
from giraffez.errors import *
from giraffez.types import Columns
from giraffez.utils import *
@pytest.mark.usefixtures('config', 'tmpfiles')
class TestConfig(object):
def test_get_set_li... | [
"os.chmod",
"giraffez.Config.unlock_connection",
"pytest.raises",
"giraffez.Config",
"giraffez.Config.lock_connection",
"giraffez.Secret",
"platform.system",
"pytest.mark.usefixtures"
] | [((225, 270), 'pytest.mark.usefixtures', 'pytest.mark.usefixtures', (['"""config"""', '"""tmpfiles"""'], {}), "('config', 'tmpfiles')\n", (248, 270), False, 'import pytest\n'), ((2649, 2677), 'os.chmod', 'os.chmod', (['tmpfiles.conf', '(384)'], {}), '(tmpfiles.conf, 384)\n', (2657, 2677), False, 'import os\n'), ((3178,... |
#! /usr/bin/env python3
import argparse
import collections.abc
import glob
import json
import os
import re
import shutil
import subprocess
import sys
import time
from ast import literal_eval
from collections import OrderedDict
from itertools import combinations
from pathlib import Path
import mne
import pandas as pd
... | [
"argparse.ArgumentParser",
"pandas.read_csv",
"yaml.dump",
"json.dumps",
"os.path.isfile",
"pathlib.Path",
"glob.glob",
"os.path.join",
"os.chdir",
"mne_bids.make_dataset_description",
"pydeface.utils.deface_image",
"pkg_resources.Requirement.parse",
"os.path.exists",
"re.search",
"bids_... | [((3269, 3295), 'os.path.basename', 'os.path.basename', (['img_path'], {}), '(img_path)\n', (3285, 3295), False, 'import os\n'), ((4777, 4793), 'glob.glob', 'glob.glob', (['files'], {}), '(files)\n', (4786, 4793), False, 'import glob\n'), ((7820, 7889), 'os.path.join', 'os.path.join', (['data_root_path', "('sub-' + sub... |
from pymongo import MongoClient
from bson import ObjectId
import json
# Database connection information
host = 'localhost'
port = 27017
dbName = 'cellsideAssistance'
class JSONEncoder(json.JSONEncoder):
def default(self, o):
if isinstance(o, ObjectId):
return str(o)
return json.JSONEnc... | [
"pymongo.MongoClient",
"json.JSONEncoder.default"
] | [((308, 341), 'json.JSONEncoder.default', 'json.JSONEncoder.default', (['self', 'o'], {}), '(self, o)\n', (332, 341), False, 'import json\n'), ((415, 438), 'pymongo.MongoClient', 'MongoClient', (['host', 'port'], {}), '(host, port)\n', (426, 438), False, 'from pymongo import MongoClient\n')] |
__all__ = ['PyReplyDecoder']
import pickle
from tron import Misc
from .ReplyDecoder import ReplyDecoder
class PyReplyDecoder(ReplyDecoder):
""" Encode Replys as single-line pickled python objects.
"""
def __init__(self, **argv):
ReplyDecoder.__init__(self, **argv)
# How do we terminat... | [
"pickle.loads",
"tron.Misc.log"
] | [((600, 678), 'tron.Misc.log', 'Misc.log', (['"""PyReply.decoder"""', "('called with EOL=%r and buf=%r' % (self.EOL, buf))"], {}), "('PyReply.decoder', 'called with EOL=%r and buf=%r' % (self.EOL, buf))\n", (608, 678), False, 'from tron import Misc\n'), ((752, 818), 'tron.Misc.log', 'Misc.log', (['"""PyReply.decoder"""... |
#! /usr/bin/python3
# -*- coding: utf-8 -*-
#--------------------------------------------------------------------------------------------------
# Script to parse Japanese Wiktionary XML stream and export word information
#
# Usage:
# parse_wiktionary_ja.py [--sampling num] [--max num] [--quiet]
# (It reads the stan... | [
"html.unescape",
"tkrzw_dict.GetCommandFlag",
"regex.findall",
"regex.search",
"tkrzw_dict.GetLogger",
"random.random",
"regex.sub",
"random.seed"
] | [((1290, 1311), 'random.seed', 'random.seed', (['(19780211)'], {}), '(19780211)\n', (1301, 1311), False, 'import random\n'), ((1321, 1343), 'tkrzw_dict.GetLogger', 'tkrzw_dict.GetLogger', ([], {}), '()\n', (1341, 1343), False, 'import tkrzw_dict\n'), ((33947, 33992), 'tkrzw_dict.GetCommandFlag', 'tkrzw_dict.GetCommandF... |
# import sys
#
# sys.path.insert(0, '/content/gdrive/MyDrive/Tese/code') # for colab
import time
import torch.nn.functional as F
from src.classification_scripts.finetune_abstract import *
class FineTuneSupCon(FineTune):
"""
class that unfreezes the efficient-net model and pre-trains it on RSICD data
"""
... | [
"time.time"
] | [((2726, 2737), 'time.time', 'time.time', ([], {}), '()\n', (2735, 2737), False, 'import time\n'), ((3626, 3637), 'time.time', 'time.time', ([], {}), '()\n', (3635, 3637), False, 'import time\n')] |
'''
Created on January 5, 2020
Filer Guidelines: ESMA_ESEF Manula 2019.pdf
@author: Mark V Systems Limited
(c) Copyright 2020 Mark V Systems Limited, All rights reserved.
'''
from .Const import standardTaxonomyURIs, esefTaxonomyNamespaceURIs
from lxml.etree import XML, XMLSyntaxError
# check if a modelDocument URI i... | [
"lxml.etree.XML"
] | [((1270, 1279), 'lxml.etree.XML', 'XML', (['data'], {}), '(data)\n', (1273, 1279), False, 'from lxml.etree import XML, XMLSyntaxError\n')] |
# (C) Copyright 2021 ECMWF.
#
# This software is licensed under the terms of the Apache Licence Version 2.0
# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
# In applying this licence, ECMWF does not waive the privileges and immunities
# granted to it by virtue of its status as an intergovernmenta... | [
"os.path.isabs",
"inspect.stack",
"os.path.join",
"climetlab.utils.availability.Availability",
"climetlab.arguments.InputManager",
"threading.RLock",
"re.match",
"os.path.splitext",
"functools.wraps",
"climetlab.utils.load_json_or_yaml",
"logging.getLogger"
] | [((582, 609), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (599, 609), False, 'import logging\n'), ((930, 947), 'threading.RLock', 'threading.RLock', ([], {}), '()\n', (945, 947), False, 'import threading\n'), ((638, 649), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (643, 64... |
import json
from flask import request
from simplyrestful.resources import Resource
from simplyrestful.exceptions import Conflict
from serializers import ProcessSerializer
from settings import PROCESS_SPECIFICATION_FIELD
class ProcessResource(Resource):
endpoint = 'processes'
serializer = ProcessSerializer
... | [
"flask.request.form.get",
"simplyrestful.exceptions.Conflict"
] | [((734, 792), 'simplyrestful.exceptions.Conflict', 'Conflict', (['"""This endpoint only accepts multipart/form-data"""'], {}), "('This endpoint only accepts multipart/form-data')\n", (742, 792), False, 'from simplyrestful.exceptions import Conflict\n'), ((589, 634), 'flask.request.form.get', 'request.form.get', (['PROC... |
from django.db import models
from django.utils import timezone
from django.urls import reverse
# Create your models here.
class LogInfo(models.Model):
aims_id = models.CharField(max_length=100)
host_id = models.CharField(max_length=100)
app_id = models.CharField(max_length=100)
app_name = models.Char... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.utils.timezone.now",
"django.urls.reverse",
"django.db.models.DateTimeField"
] | [((168, 200), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (184, 200), False, 'from django.db import models\n'), ((215, 247), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (231, 247), False, 'from django.d... |
import argparse
import json
import os
import django
import logging
FSW_ACCOUNT = 18
CANVAS_URL = "https://canvas.vu.nl"
os.environ['DJANGO_SETTINGS_MODULE'] = 'dejavu.settings'
django.setup()
logging.basicConfig(level=logging.INFO, format='[%(asctime)s %(name)-12s %(levelname)-5s] %(message)s')
import canvasapi
fr... | [
"django.setup",
"dejaviewer.models.Course.objects.get",
"argparse.ArgumentParser",
"logging.basicConfig",
"dejaviewer.models.CourseField.objects.get",
"canvasapi.Canvas"
] | [((181, 195), 'django.setup', 'django.setup', ([], {}), '()\n', (193, 195), False, 'import django\n'), ((196, 304), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""[%(asctime)s %(name)-12s %(levelname)-5s] %(message)s"""'}), "(level=logging.INFO, format=\n '[%(asctime)s %(n... |
from src.utils.readConfig import getGeneralConfig
from discord import Guild, TextChannel
from typing import List
generalConfig = getGeneralConfig()
def fetchAnnouncementChannel(guild: Guild):
if 'channel' not in generalConfig['announcement']:
return None
allTextChannels: List[TextChannel] = guild.te... | [
"src.utils.readConfig.getGeneralConfig"
] | [((130, 148), 'src.utils.readConfig.getGeneralConfig', 'getGeneralConfig', ([], {}), '()\n', (146, 148), False, 'from src.utils.readConfig import getGeneralConfig\n')] |
import torch as ch
import utils
import numpy as np
from tqdm import tqdm
if __name__ == "__main__":
import sys
model_arch = sys.argv[1]
model_type = sys.argv[2]
prefix = sys.argv[3]
dataset = sys.argv[4]
if dataset == 'cifar10':
dx = utils.CIFAR10()
elif dataset == 'imagenet':
dx = utils.I... | [
"torch.mean",
"tqdm.tqdm",
"numpy.save",
"utils.ImageNet1000",
"utils.CIFAR10",
"torch.cat",
"torch.std",
"torch.no_grad"
] | [((952, 968), 'torch.cat', 'ch.cat', (['all_reps'], {}), '(all_reps)\n', (958, 968), True, 'import torch as ch\n'), ((981, 1005), 'torch.mean', 'ch.mean', (['all_reps'], {'dim': '(0)'}), '(all_reps, dim=0)\n', (988, 1005), True, 'import torch as ch\n'), ((1018, 1041), 'torch.std', 'ch.std', (['all_reps'], {'dim': '(0)'... |
#!/usr/bin/python
# Copyright (c) 2017, 2020 Oracle and/or its affiliates.
# This software is made available to you under the terms of the GPL 3.0 license or the Apache 2.0 license.
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Apache License v2.0
# See LICENSE.TXT for d... | [
"ansible_collections.oracle.oci.plugins.module_utils.oci_common_utils.raise_does_not_exist_service_error",
"ansible_collections.oracle.oci.plugins.module_utils.oci_common_utils.list_all_resources",
"ansible_collections.oracle.oci.plugins.module_utils.oci_common_utils.get_common_arg_spec",
"ansible_collections... | [((9997, 10043), 'ansible_collections.oracle.oci.plugins.module_utils.oci_resource_utils.get_custom_class', 'get_custom_class', (['"""SmtpCredentialHelperCustom"""'], {}), "('SmtpCredentialHelperCustom')\n", (10013, 10043), False, 'from ansible_collections.oracle.oci.plugins.module_utils.oci_resource_utils import OCIRe... |
""".. Ignore pydocstyle D400.
=========
Utilities
=========
Utilities for using global manager features.
"""
from django.test import override_settings
def disable_auto_calls():
"""Decorator/context manager which stops automatic manager calls.
When entered, automatic
:meth:`~resolwe.flow.managers.disp... | [
"django.test.override_settings"
] | [((426, 481), 'django.test.override_settings', 'override_settings', ([], {'FLOW_MANAGER_DISABLE_AUTO_CALLS': '(True)'}), '(FLOW_MANAGER_DISABLE_AUTO_CALLS=True)\n', (443, 481), False, 'from django.test import override_settings\n')] |
# -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://docs.scrapy.org/en/latest/topics/item-pipeline.html
import json
from scrapy.exceptions import DropItem
from data_pirate_cep.utils import beautify_item, validate_item, write_addr... | [
"data_pirate_cep.utils.write_addresses",
"json.loads",
"data_pirate_cep.utils.validate_item",
"data_pirate_cep.utils.beautify_item",
"scrapy.exceptions.DropItem"
] | [((682, 701), 'data_pirate_cep.utils.validate_item', 'validate_item', (['item'], {}), '(item)\n', (695, 701), False, 'from data_pirate_cep.utils import beautify_item, validate_item, write_addresses\n'), ((959, 992), 'data_pirate_cep.utils.write_addresses', 'write_addresses', (['spider.addresses'], {}), '(spider.address... |
import requests
import json
import jsonlines
import time
import os
import sys
from retrying import retry
import traceback
class User():
def __init__(self, uid):
self.uid = str(uid)
def get_info(self):
url = f'https://api.bilibili.com/x/space/acc/info?mid={self.uid}'
retu... | [
"traceback.print_exc",
"argparse.ArgumentParser",
"os.makedirs",
"json.loads",
"os.path.exists",
"time.sleep",
"jsonlines.open",
"requests.get",
"retrying.retry",
"os.path.join"
] | [((1171, 1220), 'retrying.retry', 'retry', ([], {'wait_random_min': '(1000)', 'wait_random_max': '(3000)'}), '(wait_random_min=1000, wait_random_max=3000)\n', (1176, 1220), False, 'from retrying import retry\n'), ((1013, 1055), 'requests.get', 'requests.get', (['url'], {'headers': 'DEFAULT_HEADERS'}), '(url, headers=DE... |
import tweepy
import time
auth = tweepy.OAuthHandler('','')
auth.set_access_token('', '')
api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
busca = 'Busque por tweet'
numTweets = 5
for tweet in tweepy.Cursor(api.search, busca).items(numTweets):
try:
if(len(twee... | [
"tweepy.OAuthHandler",
"tweepy.Cursor",
"tweepy.API",
"time.sleep"
] | [((37, 64), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (['""""""', '""""""'], {}), "('', '')\n", (56, 64), False, 'import tweepy\n'), ((104, 177), 'tweepy.API', 'tweepy.API', (['auth'], {'wait_on_rate_limit': '(True)', 'wait_on_rate_limit_notify': '(True)'}), '(auth, wait_on_rate_limit=True, wait_on_rate_limit_notif... |
# This is my main script
import json
import multiprocessing as mp
import os
import time
import matplotlib.cm
import matplotlib.pyplot
import matplotlib.pyplot as plt
import numpy as np
from sklearn import metrics
from sklearn.cluster import AgglomerativeClustering
from sklearn.cluster import OPTICS
import FeatureProc... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.suptitle",
"json.dumps",
"matplotlib.pyplot.figure",
"os.path.isfile",
"numpy.arange",
"matplotlib.pyplot.gca",
"numpy.full_like",
"json.loads",
"matplotlib.pyplot.close",
"process_cuckoo_reports.mp_get_all_files_api_sequen... | [((1607, 1616), 'multiprocessing.Pool', 'mp.Pool', ([], {}), '()\n', (1614, 1616), True, 'import multiprocessing as mp\n'), ((2641, 2650), 'matplotlib.pyplot.clf', 'plt.clf', ([], {}), '()\n', (2648, 2650), True, 'import matplotlib.pyplot as plt\n'), ((2665, 2708), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'f... |
"""
SAMS umbrella sampling for DDR1 kinase DFG loop flip.
"""
__author__ = '<NAME>'
################################################################################
# IMPORTS
################################################################################
import os, os.path
import sys, math
import numpy as np
impor... | [
"sams.analysis.analyze",
"simtk.openmm.CustomTorsionForce",
"simtk.openmm.MonteCarloBarostat",
"sams.ThermodynamicState",
"collections.namedtuple",
"numpy.linspace",
"simtk.openmm.app.PDBFile",
"sams.analysis.write_trajectory"
] | [((2874, 2905), 'simtk.openmm.app.PDBFile', 'app.PDBFile', (['state_pdb_filename'], {}), '(state_pdb_filename)\n', (2885, 2905), False, 'from simtk.openmm import app\n'), ((3863, 3905), 'simtk.openmm.CustomTorsionForce', 'openmm.CustomTorsionForce', (['energy_function'], {}), '(energy_function)\n', (3888, 3905), False,... |
import numpy as np
from numpy.random import beta
import sys
#sys.path.append('../h5hep')
#from write import *
import hepfile
################################################################################
def calc_energy(mass,px,py,pz):
energy = np.sqrt(mass*mass + px*px + py*py + pz*pz)
return energy
####... | [
"hepfile.initialize",
"hepfile.pack",
"numpy.random.beta",
"hepfile.create_single_bucket",
"hepfile.write_to_file",
"numpy.random.randint",
"numpy.random.random",
"hepfile.create_group",
"numpy.sqrt",
"hepfile.create_dataset"
] | [((405, 425), 'hepfile.initialize', 'hepfile.initialize', ([], {}), '()\n', (423, 425), False, 'import hepfile\n'), ((427, 476), 'hepfile.create_group', 'hepfile.create_group', (['data', '"""jet"""'], {'counter': '"""njet"""'}), "(data, 'jet', counter='njet')\n", (447, 476), False, 'import hepfile\n'), ((475, 566), 'he... |
from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
from rest_framework.authtoken.views import obtain_auth_token
urlpatterns = [
path('admin/', admin.site.urls),
path('token-auth/', obtain_auth_token, name='token_auth')... | [
"django.conf.urls.static.static",
"django.urls.path"
] | [((326, 389), 'django.conf.urls.static.static', 'static', (['settings.STATIC_URL'], {'document_root': 'settings.STATIC_ROOT'}), '(settings.STATIC_URL, document_root=settings.STATIC_ROOT)\n', (332, 389), False, 'from django.conf.urls.static import static\n'), ((229, 260), 'django.urls.path', 'path', (['"""admin/"""', 'a... |
"""Utility functions for scikit-learn-realted implementations"""
import os
from datetime import datetime
from sklearn.externals import joblib
from MLT.tools import prediction_entry as pe
def sklearn_train_model(model, training_data, training_labels, test_data, test_labels, model_savename):
"""Train the given mode... | [
"sklearn.externals.joblib.dump",
"os.path.join",
"MLT.tools.prediction_entry.PredictionEntry",
"os.path.splitext",
"sklearn.externals.joblib.load",
"datetime.datetime.now"
] | [((371, 385), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (383, 385), False, 'from datetime import datetime\n'), ((449, 463), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (461, 463), False, 'from datetime import datetime\n'), ((850, 944), 'MLT.tools.prediction_entry.PredictionEntry', 'pe.Pr... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
fro... | [
"pulumi.get",
"pulumi.getter",
"pulumi.set",
"pulumi.InvokeOptions",
"pulumi.runtime.invoke"
] | [((2915, 2953), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""allSubscriptions"""'}), "(name='allSubscriptions')\n", (2928, 2953), False, 'import pulumi\n'), ((3394, 3428), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""collectionId"""'}), "(name='collectionId')\n", (3407, 3428), False, 'import pulumi\n'), (... |
import asyncio
import time
from rich.pretty import pprint
import aiomysql
import asyncmy
import MySQLdb
import pymysql
from benchmark import COUNT, connection_kwargs
from benchmark.decorators import cleanup, fill_data
count = int(COUNT / 5)
@cleanup
@fill_data
async def update_asyncmy():
conn = await asyncmy.c... | [
"aiomysql.connect",
"asyncio.get_event_loop",
"MySQLdb.connect",
"asyncmy.connect",
"time.time",
"pymysql.connect"
] | [((1179, 1215), 'MySQLdb.connect', 'MySQLdb.connect', ([], {}), '(**connection_kwargs)\n', (1194, 1215), False, 'import MySQLdb\n'), ((1248, 1259), 'time.time', 'time.time', ([], {}), '()\n', (1257, 1259), False, 'import time\n'), ((1545, 1581), 'pymysql.connect', 'pymysql.connect', ([], {}), '(**connection_kwargs)\n',... |
from discord.ext import commands
from discord.ext.commands import Cog
# from discord import Embed
# from collections import defaultdict, Counter
# from itertools import islice
# from nltk import pos_tag, CFG, Production
# from nltk import Nonterminal, nonterminals
# from nltk.corpus import brown
import json
from pathl... | [
"json.dump",
"pathlib.Path",
"json.load",
"discord.ext.commands.group"
] | [((3963, 3996), 'discord.ext.commands.group', 'commands.group', ([], {'pass_context': '(True)'}), '(pass_context=True)\n', (3977, 3996), False, 'from discord.ext import commands\n'), ((4462, 4507), 'pathlib.Path', 'Path', (['parent_dir', '"""resources/data/words.json"""'], {}), "(parent_dir, 'resources/data/words.json'... |
#!/usr/bin/env python3
from intcode import Computer
from itertools import permutations
with open("inputs/7") as f:
inputs = list(map(int, f.readline().strip().split(",")))
for bounds in ((0, 5), (5, 10)):
output = float("-inf")
for config in permutations(range(*bounds)):
amps = []
for i ... | [
"intcode.Computer"
] | [((367, 383), 'intcode.Computer', 'Computer', (['inputs'], {}), '(inputs)\n', (375, 383), False, 'from intcode import Computer\n')] |
from setuptools import setup
import ssllabs
setup(name='python-ssllabs',
version=ssllabs.__version__,
packages=['ssllabs'],
scripts=['ssllabs-cli.py'],
install_requires=['requests'],
url='https://github.com/takeshixx/python-ssllabs',
license='Apache 2.0',
author='takeshix')
| [
"setuptools.setup"
] | [((45, 288), 'setuptools.setup', 'setup', ([], {'name': '"""python-ssllabs"""', 'version': 'ssllabs.__version__', 'packages': "['ssllabs']", 'scripts': "['ssllabs-cli.py']", 'install_requires': "['requests']", 'url': '"""https://github.com/takeshixx/python-ssllabs"""', 'license': '"""Apache 2.0"""', 'author': '"""takes... |
# Copyright 2020 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
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"requests.get",
"lib.concurrent.thread_map",
"lib.time.date_today",
"pandas.DataFrame.from_records"
] | [((1845, 1876), 'pandas.DataFrame.from_records', 'DataFrame.from_records', (['records'], {}), '(records)\n', (1867, 1876), False, 'from pandas import DataFrame\n'), ((1784, 1824), 'lib.concurrent.thread_map', 'thread_map', (['_get_daily_records', 'map_iter'], {}), '(_get_daily_records, map_iter)\n', (1794, 1824), False... |