code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from flasktaskr import app
app.run(debug=True)
| [
"flasktaskr.app.run"
] | [((27, 46), 'flasktaskr.app.run', 'app.run', ([], {'debug': '(True)'}), '(debug=True)\n', (34, 46), False, 'from flasktaskr import app\n')] |
import pyser as parser
import graph
import sys
def run():
graph.setup()
print("""Welcome to GraphCalc
To understand how it works type
/help
""")
while True:
try:
parser.parse(input("> "))
except KeyboardInterrupt:
... | [
"graph.setup",
"sys.exit"
] | [((68, 81), 'graph.setup', 'graph.setup', ([], {}), '()\n', (79, 81), False, 'import graph\n'), ((320, 330), 'sys.exit', 'sys.exit', ([], {}), '()\n', (328, 330), False, 'import sys\n')] |
# coding=utf-8
import ctypes
from ctypes import c_char_p,c_int, create_string_buffer, POINTER, pointer, Structure
from ctypes import c_float, c_char, string_at, cast
SO_LIB = '/home/fy/pyc/cpplib/'
C_NULL = '\x00'
# export LD_LIBRARY_PATH="/home/testlib/testlib/:$LD_LIBRARY_PATH"
# source ~/.bashrc
# global_so = ctype... | [
"ctypes.c_char_p",
"ctypes.c_int",
"ctypes.string_at",
"ctypes.pointer",
"ctypes.c_float",
"ctypes.CDLL",
"ctypes.POINTER"
] | [((385, 418), 'ctypes.CDLL', 'ctypes.CDLL', (["(SO_LIB + 'libpyc.so')"], {}), "(SO_LIB + 'libpyc.so')\n", (396, 418), False, 'import ctypes\n'), ((826, 834), 'ctypes.c_int', 'c_int', (['(2)'], {}), '(2)\n', (831, 834), False, 'from ctypes import c_char_p, c_int, create_string_buffer, POINTER, pointer, Structure\n'), ((... |
from rest_framework import serializers
from teams.serializers import TeamSerializer
from projects.serializers import ProjectLabelBaseSerializer
from .models import Requirement
from users.serializers import BasicUserSerializer
class RequirementSerializer(serializers.ModelSerializer):
class Meta:
model = Re... | [
"teams.serializers.TeamSerializer"
] | [((511, 536), 'teams.serializers.TeamSerializer', 'TeamSerializer', ([], {'many': '(True)'}), '(many=True)\n', (525, 536), False, 'from teams.serializers import TeamSerializer\n')] |
import requests
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.urls import reverse, reverse_lazy
from django.utils.decorators import method_decorator
from django.views.decorators.cache import never_cache
from django.vie... | [
"django.utils.decorators.method_decorator",
"django.urls.reverse_lazy",
"django.urls.reverse",
"rest_framework.response.Response",
"requests.post",
"rest_framework.decorators.api_view"
] | [((1133, 1182), 'django.utils.decorators.method_decorator', 'method_decorator', (['login_required'], {'name': '"""dispatch"""'}), "(login_required, name='dispatch')\n", (1149, 1182), False, 'from django.utils.decorators import method_decorator\n'), ((2089, 2106), 'rest_framework.decorators.api_view', 'api_view', (["['G... |
from uteis import moedas
#Programa principal
p = float(input('Digite qual valor você usará no modulo moedas: R$'))
print(f'O valor {moedas.real(p)} mais 10% é {moedas.real(moedas.aumentar(p,10))}')
print(f'O valor {moedas.real(p)} menos 20% é {moedas.real(moedas.diminuir(p,20))}')
print(f'O valor é {moedas.real(p)} e... | [
"uteis.moedas.aumentar",
"uteis.moedas.metade",
"uteis.moedas.dobro",
"uteis.moedas.real",
"uteis.moedas.diminuir"
] | [((134, 148), 'uteis.moedas.real', 'moedas.real', (['p'], {}), '(p)\n', (145, 148), False, 'from uteis import moedas\n'), ((217, 231), 'uteis.moedas.real', 'moedas.real', (['p'], {}), '(p)\n', (228, 231), False, 'from uteis import moedas\n'), ((304, 318), 'uteis.moedas.real', 'moedas.real', (['p'], {}), '(p)\n', (315, ... |
import logging
from OTLMOW.ModelGenerator import OSLOCollector
class OTLGeldigeRelatieCreator:
def __init__(self, osloCollector: OSLOCollector):
logging.info("Created an instance of OTLGeldigeRelatieCreator")
self.osloCollector = osloCollector
def CreateBlockToWriteFromRelations(self):
... | [
"logging.info"
] | [((160, 223), 'logging.info', 'logging.info', (['"""Created an instance of OTLGeldigeRelatieCreator"""'], {}), "('Created an instance of OTLGeldigeRelatieCreator')\n", (172, 223), False, 'import logging\n')] |
from math import cos, pi, tanh
from functools import partial
import torch
__all__ = ["ConstantScheduler", "cycle_scheduler", "step_scheduler", "lr_finder"]
def anneal_linear(start, end, proportion):
return start + proportion * (end - start)
def anneal_cos(start, end, proportion):
cos_val = cos(pi * propo... | [
"functools.partial",
"math.cos",
"math.tanh"
] | [((306, 326), 'math.cos', 'cos', (['(pi * proportion)'], {}), '(pi * proportion)\n', (309, 326), False, 'from math import cos, pi, tanh\n'), ((458, 478), 'math.cos', 'cos', (['(pi * proportion)'], {}), '(pi * proportion)\n', (461, 478), False, 'from math import cos, pi, tanh\n'), ((831, 873), 'math.tanh', 'tanh', (['(l... |
# -*- encoding: utf-8 -*-
from __future__ import absolute_import
from itertools import chain
from cubes_lite import compat
from cubes_lite.errors import (
NoSuchAttributeError, NoSuchDimensionError, ModelError, ArgumentError
)
from .base import ModelObjectBase
from .utils import (
object_dict, assert_all_in... | [
"cubes_lite.errors.ModelError",
"itertools.chain"
] | [((2650, 2689), 'itertools.chain', 'chain', (['dimensions', 'measures', 'aggregates'], {}), '(dimensions, measures, aggregates)\n', (2655, 2689), False, 'from itertools import chain\n'), ((1608, 1638), 'cubes_lite.errors.ModelError', 'ModelError', (['"""Cube has no name"""'], {}), "('Cube has no name')\n", (1618, 1638)... |
from ariadne import InterfaceType, make_executable_schema, QueryType
from graphql import graphql_sync
from graphql_relay import to_global_id
from ariadne_relay import NodeObjectType, resolve_node_query_sync
from .conftest import Foo
def test_node_resolver(type_defs: str, node_query: str) -> None:
test_nodes = {s... | [
"ariadne.QueryType",
"ariadne.make_executable_schema",
"ariadne_relay.NodeObjectType",
"ariadne.InterfaceType",
"graphql.graphql_sync"
] | [((375, 386), 'ariadne.QueryType', 'QueryType', ([], {}), '()\n', (384, 386), False, 'from ariadne import InterfaceType, make_executable_schema, QueryType\n'), ((467, 542), 'ariadne.InterfaceType', 'InterfaceType', (['"""Node"""'], {'type_resolver': '(lambda obj, *_: obj.__class__.__name__)'}), "('Node', type_resolver=... |
# Generated by Django 2.2 on 2019-10-09 18:19
from django.conf import settings
import django.contrib.auth.models
import django.contrib.auth.validators
import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migrat... | [
"django.db.migrations.RunPython",
"django.db.models.TextField",
"django.db.models.FileField",
"django.db.models.ManyToManyField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.AutoField",
"django.db.models.EmailField",
"django.db.mo... | [((8998, 9077), 'django.db.migrations.RunPython', 'migrations.RunPython', (['create_user_types'], {'reverse_code': 'migrations.RunPython.noop'}), '(create_user_types, reverse_code=migrations.RunPython.noop)\n', (9018, 9077), False, 'from django.db import migrations, models\n'), ((7282, 7402), 'django.db.models.ForeignK... |
try:
from plotting import hd_hist
except ImportError:
from utilities.plotting import hd_hist
from sklearn.externals import joblib
import numpy as np
etbins = np.linspace(20.0, 400.0, num=100)
etabins = np.linspace(-4.0, 4.0, num=100)
mbins = np.linspace(0.0, 200.0, num=100)
ktbins = np.linspace(0.0, 100000.0, ... | [
"utilities.plotting.hd_hist",
"numpy.linspace",
"sklearn.externals.joblib.load"
] | [((167, 200), 'numpy.linspace', 'np.linspace', (['(20.0)', '(400.0)'], {'num': '(100)'}), '(20.0, 400.0, num=100)\n', (178, 200), True, 'import numpy as np\n'), ((211, 242), 'numpy.linspace', 'np.linspace', (['(-4.0)', '(4.0)'], {'num': '(100)'}), '(-4.0, 4.0, num=100)\n', (222, 242), True, 'import numpy as np\n'), ((2... |
# import wx
# headImage = wx.Image('logo.png', wx.BITMAP_TYPE_ANY)
# headImageBitmap = headImage.Scale(50, 50, wx.IMAGE_QUALITY_HIGH).ConvertToBitmap()
# wx.StaticBitmap(panel, id = -1, bitmap = headImageBitmap, pos = (10,10))
import wx
# Used to determine the size of an image
from PIL import Image
# Use the wxP... | [
"matplotlib.pyplot.figure",
"matplotlib.backends.backend_wxagg.FigureCanvasWxAgg",
"shutil.rmtree",
"wx.Size",
"wx.Exit",
"pdf2image.convert_from_path",
"txt_csv2.makeCSV",
"matplotlib.patches.Rectangle",
"pdf_crop.crop",
"wx.Panel",
"wx.ListBox",
"wx.TextCtrl",
"matplotlib.pyplot.Axes",
"... | [((373, 396), 'matplotlib.use', 'matplotlib.use', (['"""WXAgg"""'], {}), "('WXAgg')\n", (387, 396), False, 'import matplotlib\n'), ((19415, 19423), 'wx.App', 'wx.App', ([], {}), '()\n', (19421, 19423), False, 'import wx\n'), ((949, 963), 'wx.Panel', 'wx.Panel', (['self'], {}), '(self)\n', (957, 963), False, 'import wx\... |
# Generated by Django 3.0.6 on 2020-07-14 09:37
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
import uuid
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(... | [
"django.db.migrations.swappable_dependency",
"django.db.models.UUIDField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DateTimeField"
] | [((288, 345), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (319, 345), False, 'from django.db import migrations, models\n'), ((488, 581), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)... |
# Copyright (c) 2022 <NAME>
#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
from __future__ import annotations
from mautrix.api import Method, Path
from mautrix.error... | [
"mautrix.types.Member.deserialize",
"mautrix.errors.MatrixResponseError",
"mautrix.types.User.deserialize"
] | [((6347, 6374), 'mautrix.types.Member.deserialize', 'Member.deserialize', (['content'], {}), '(content)\n', (6365, 6374), False, 'from mautrix.types import ContentURI, Member, SerializerError, User, UserID, UserSearchResults\n'), ((2471, 2524), 'mautrix.errors.MatrixResponseError', 'MatrixResponseError', (['"""Invalid ... |
import sys
import os
import re
import random
import csv
csvPath = "pairings_file.csv"
if (len(sys.argv) > 1):
# set the folder name of submissions as the next argument when running the script
filesPath = sys.argv[1]
else:
filesPath = input("Please input the path to the folder of the student submissions... | [
"csv.writer",
"os.listdir"
] | [((453, 474), 'os.listdir', 'os.listdir', (['filesPath'], {}), '(filesPath)\n', (463, 474), False, 'import os\n'), ((1185, 1225), 'csv.writer', 'csv.writer', (['pairings_file'], {'delimiter': '""","""'}), "(pairings_file, delimiter=',')\n", (1195, 1225), False, 'import csv\n')] |
import torch as T
import numpy as np
def get_cuda(tensor):
if T.cuda.is_available():
tensor = tensor.cuda()
return tensor
# def get_onehot_labels(labels, n_c):
# batch_size = len(labels)
# class_onehot = np.zeros((batch_size, n_c))
# class_onehot[np.arange(batch_size), labels] = 1
# cl... | [
"torch.cuda.is_available"
] | [((67, 88), 'torch.cuda.is_available', 'T.cuda.is_available', ([], {}), '()\n', (86, 88), True, 'import torch as T\n')] |
#!@PYTHON@
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensol... | [
"gettext.translation",
"os.strerror"
] | [((1308, 1379), 'gettext.translation', 'gettext.translation', (['"""SUNW_OST_OSLIB"""', '"""/usr/lib/locale"""'], {'fallback': '(True)'}), "('SUNW_OST_OSLIB', '/usr/lib/locale', fallback=True)\n", (1327, 1379), False, 'import gettext\n'), ((3278, 3301), 'os.strerror', 'os.strerror', (['self.errno'], {}), '(self.errno)\... |
import torch
import torch.nn as nn
import torchvision.models as models
import torch.nn.functional as F
import gc
class TridentResNet(nn.Module):
def __init__(self, pretrained):
super(TridentResNet, self).__init__()
if pretrained:
self.resnet_1 = models.resnet18(pretrained=True)
... | [
"torchvision.models.resnet18",
"torch.nn.ReLU",
"torch.nn.BatchNorm1d",
"torch.cat",
"torch.nn.Linear"
] | [((1017, 1036), 'torch.nn.Linear', 'nn.Linear', (['(512)', '(256)'], {}), '(512, 256)\n', (1026, 1036), True, 'import torch.nn as nn\n'), ((1064, 1083), 'torch.nn.Linear', 'nn.Linear', (['(512)', '(256)'], {}), '(512, 256)\n', (1073, 1083), True, 'import torch.nn as nn\n'), ((1111, 1130), 'torch.nn.Linear', 'nn.Linear'... |
import datetime
from enum import Enum
from django.utils import timezone
from apps.db_data.models import Event
class AnnouncementType(Enum):
WEEK = "week"
TOMORROW = "tomorrow"
TODAY = "today"
HOUR = "hour"
B_TIME = "now" # Berkeley Time
def get_events_in_time_delta(requested_atype: Announceme... | [
"django.utils.timezone.now",
"apps.db_data.models.Event.objects.filter",
"django.utils.timezone.get_current_timezone",
"datetime.timedelta"
] | [((1098, 1112), 'django.utils.timezone.now', 'timezone.now', ([], {}), '()\n', (1110, 1112), False, 'from django.utils import timezone\n'), ((529, 560), 'django.utils.timezone.get_current_timezone', 'timezone.get_current_timezone', ([], {}), '()\n', (558, 560), False, 'from django.utils import timezone\n'), ((503, 517)... |
import sys
from Classes.Measurement import Measurement
import xmltodict
from Panels.SelectData import SelectData
from Panels.MeasurementWidget import MeasurementWidget
from PyQt5.QtWidgets import (QApplication, QWidget, QMessageBox,
QDesktopWidget, QPushButton, QToolTip,
... | [
"functools.partial",
"PyQt5.QtGui.QIcon",
"PyQt5.QtCore.QCoreApplication.instance",
"PyQt5.QtWidgets.QDesktopWidget",
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtCore.QByteArray",
"PyQt5.QtGui.QFont",
"Panels.Measurement... | [((10588, 10697), 'Classes.Measurement.Measurement', 'Measurement', (['"""C:\\\\Users\\\\gpetrochenkov\\\\Desktop\\\\QRev\\\\Qrev Files/SP_13038000_356/13038000_356.mmt"""'], {}), "(\n 'C:\\\\Users\\\\gpetrochenkov\\\\Desktop\\\\QRev\\\\Qrev Files/SP_13038000_356/13038000_356.mmt'\n )\n", (10599, 10697), False, '... |
from fastapi import APIRouter, Depends
from price_series_calc.db.dals.index_dal import IndexDAL
from price_series_calc.db.models.index import Index
from price_series_calc.dependencies import get_index_dal
router = APIRouter()
@router.post("/indices")
async def create_index(index_id, weight, prices, index_dal: Index... | [
"fastapi.Depends",
"fastapi.APIRouter"
] | [((216, 227), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (225, 227), False, 'from fastapi import APIRouter, Depends\n'), ((326, 348), 'fastapi.Depends', 'Depends', (['get_index_dal'], {}), '(get_index_dal)\n', (333, 348), False, 'from fastapi import APIRouter, Depends\n'), ((503, 525), 'fastapi.Depends', 'Depe... |
from .. import config
import contextlib, logging, os, shutil, sys, tempfile
from ._tempfile import TemporaryDirectory
logger = logging.getLogger(__name__)
__all__ = [
'findfiles', 'getDebugSourceDir', 'getdir', 'makeNewfile', 'newer'
, 'remove_file_on_error'
]
def getdir(name, mkdirs=False, access=os.O_RDWR)... | [
"os.mkdir",
"os.path.abspath",
"os.makedirs",
"shutil.rmtree",
"os.unlink",
"os.path.isdir",
"os.__dict__.items",
"os.path.exists",
"os.path.getctime",
"os.path.join",
"os.access",
"logging.getLogger"
] | [((128, 155), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (145, 155), False, 'import contextlib, logging, os, shutil, sys, tempfile\n'), ((421, 442), 'os.path.abspath', 'os.path.abspath', (['name'], {}), '(name)\n', (436, 442), False, 'import contextlib, logging, os, shutil, sys, tempf... |
"""
Use this script to upload a pypi package, require below package:
pip install setuptools -U
pip install wheel -U
pip install twine -U
This is the script to release manually, now the package can be released via Github Actions:
- https://github.com/tobyqin/xmind2testlink/actions
"""
import os
egg = 'd... | [
"os.listdir",
"os.path.exists",
"os.system",
"os.path.join"
] | [((329, 348), 'os.path.exists', 'os.path.exists', (['egg'], {}), '(egg)\n', (343, 348), False, 'import os\n'), ((421, 467), 'os.system', 'os.system', (['"""python setup.py sdist bdist_wheel"""'], {}), "('python setup.py sdist bdist_wheel')\n", (430, 467), False, 'import os\n'), ((468, 500), 'os.system', 'os.system', ([... |
""" CISCO_IETF_ATM2_PVCTRAP_MIB
This MIB Module is a supplement to the
ATM\-MIB.
"""
from collections import OrderedDict
from ydk.types import Entity, EntityPath, Identity, Enum, YType, YLeaf, YLeafList, YList, LeafDataList, Bits, Empty, Decimal64
from ydk.filters import YFilter
from ydk.errors import YError, YMode... | [
"collections.OrderedDict",
"ydk.types.YLeaf",
"ydk.types.YList"
] | [((1327, 1472), 'collections.OrderedDict', 'OrderedDict', (["[('atmCurrentlyFailingPVclTable', ('atmcurrentlyfailingpvcltable',\n CISCOIETFATM2PVCTRAPMIB.AtmCurrentlyFailingPVclTable))]"], {}), "([('atmCurrentlyFailingPVclTable', (\n 'atmcurrentlyfailingpvcltable', CISCOIETFATM2PVCTRAPMIB.\n AtmCurrentlyFailin... |
#-*- coding:utf-8 -*-
from django.shortcuts import render
from django.http import HttpResponse
def error(request, err_msg):
rst = {}
rst['title'] = "出错啦"
rst['user'] = request.user
rst['reason'] = err_msg
return render(request, "error.html", rst)
def check_name(name):
return True
def check_phone(phone):
retur... | [
"django.shortcuts.render"
] | [((218, 252), 'django.shortcuts.render', 'render', (['request', '"""error.html"""', 'rst'], {}), "(request, 'error.html', rst)\n", (224, 252), False, 'from django.shortcuts import render\n')] |
from machin.frame.buffers.prioritized_buffer import PrioritizedBuffer
# pylint: disable=wildcard-import, unused-wildcard-import
from .dqn import *
class RAINBOW(DQN):
"""
RAINBOW DQN framework.
"""
def __init__(
self,
qnet: Union[NeuralNetworkModule, nn.Module],
qnet_target: ... | [
"machin.frame.buffers.prioritized_buffer.PrioritizedBuffer"
] | [((4026, 4071), 'machin.frame.buffers.prioritized_buffer.PrioritizedBuffer', 'PrioritizedBuffer', (['replay_size', 'replay_device'], {}), '(replay_size, replay_device)\n', (4043, 4071), False, 'from machin.frame.buffers.prioritized_buffer import PrioritizedBuffer\n')] |
#!/usr/bin/env python
#
# Copyright (c) 2019, Pycom Limited.
#
# This software is licensed under the GNU GPL version 3 or any
# later version, with permitted additional terms. For more information
# see the Pycom Licence v1.0 document supplied with this file, or
# available at https://www.pycom.io/opensource/licensing
... | [
"_thread.start_new_thread",
"pycom.heartbeat",
"time.sleep",
"gc.collect",
"pycom.rgbled",
"machine.Pin"
] | [((526, 548), 'pycom.heartbeat', 'pycom.heartbeat', (['(False)'], {}), '(False)\n', (541, 548), False, 'import pycom\n'), ((549, 564), 'pycom.rgbled', 'pycom.rgbled', (['(8)'], {}), '(8)\n', (561, 564), False, 'import pycom\n'), ((622, 635), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (632, 635), False, 'import... |
# Display blank screen.
#
# Copyright (C) 2010-2012 <NAME>
#
# See LICENSE.TXT that came with this file.
from __future__ import division
from StimControl.LightStim.FrameControl import FrameSweep
from StimControl.LightStim.Core import Dummy_Stimulus
duration = 15.0
dummy_stimulus = Dummy_Stimulus()
sweep = FrameSwee... | [
"StimControl.LightStim.FrameControl.FrameSweep",
"StimControl.LightStim.Core.Dummy_Stimulus"
] | [((285, 301), 'StimControl.LightStim.Core.Dummy_Stimulus', 'Dummy_Stimulus', ([], {}), '()\n', (299, 301), False, 'from StimControl.LightStim.Core import Dummy_Stimulus\n'), ((311, 323), 'StimControl.LightStim.FrameControl.FrameSweep', 'FrameSweep', ([], {}), '()\n', (321, 323), False, 'from StimControl.LightStim.Frame... |
from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt
def sigmoid(x):
return 1.0/(1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1.0 - x)
class NeuralNetwork:
def __init__(self, x, y, epoch, typeofweightinitialise = "random"):
self.inpu... | [
"matplotlib.pyplot.show",
"numpy.random.shuffle",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.legend",
"sklearn.model_selection.train_test_split",
"numpy.zeros",
"numpy.ones",
"numpy.array",
"numpy.random.multivariate_normal",
"numpy.exp",
"numpy.random.rand",
"numpy.dot",
"numpy.round",... | [((3232, 3248), 'numpy.array', 'np.array', (['[2, 3]'], {}), '([2, 3])\n', (3240, 3248), True, 'import numpy as np\n'), ((3259, 3275), 'numpy.array', 'np.array', (['[0, 0]'], {}), '([0, 0])\n', (3267, 3275), True, 'import numpy as np\n'), ((3287, 3321), 'numpy.array', 'np.array', (['[[10, 0.01], [0.01, 10]]'], {}), '([... |
from django.db import models
class Sim(models.Model):
date_created = models.DateTimeField(auto_now_add=True)
date_modified = models.DateTimeField(auto_now=True)
deleted = models.BooleanField(default=False)
friendly_name = models.CharField(max_length=255)
sid = models.CharField(max_length=255)
... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.DateTimeField"
] | [((75, 114), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'auto_now_add': '(True)'}), '(auto_now_add=True)\n', (95, 114), False, 'from django.db import models\n'), ((135, 170), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'auto_now': '(True)'}), '(auto_now=True)\n', (155, 170), Fal... |
# ----------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License
# ----------------------------------------------------------------------
"""Contains the Struct object"""
import os
import CommonEnvironment
... | [
"CommonEnvironment.ObjectReprImpl",
"os.path.split",
"CommonEnvironment.ThisFullpath"
] | [((510, 542), 'CommonEnvironment.ThisFullpath', 'CommonEnvironment.ThisFullpath', ([], {}), '()\n', (540, 542), False, 'import CommonEnvironment\n'), ((590, 621), 'os.path.split', 'os.path.split', (['_script_fullpath'], {}), '(_script_fullpath)\n', (603, 621), False, 'import os\n'), ((2065, 2103), 'CommonEnvironment.Ob... |
from subprocess import call
call(["ls", "-l"]) | [
"subprocess.call"
] | [((28, 46), 'subprocess.call', 'call', (["['ls', '-l']"], {}), "(['ls', '-l'])\n", (32, 46), False, 'from subprocess import call\n')] |
# built-in
from typing import Optional, Set
# external
from dephell_specifier import Specifier
from packaging.markers import Op, Value
from packaging.version import parse
# app
from .._cached_property import cached_property
from .._constants import REVERSED_OPERATIONS
from ._base import BaseMarker
class VersionMark... | [
"dephell_specifier.Specifier",
"packaging.version.parse",
"packaging.markers.Op"
] | [((932, 949), 'packaging.version.parse', 'parse', (['self.value'], {}), '(self.value)\n', (937, 949), False, 'from packaging.version import parse\n'), ((1012, 1049), 'dephell_specifier.Specifier', 'Specifier', (['(self.op.value + self.value)'], {}), '(self.op.value + self.value)\n', (1021, 1049), False, 'from dephell_s... |
import unittest
from operator import truediv
import sys
sys.path.append('./')
solutions = __import__('solutions.029_divide_two_integers', fromlist='*')
class Test029(unittest.TestCase):
def test_divide(self):
s = solutions.Solution()
dividend, divisor = 49, 7
self.assertEqual(s.divide(d... | [
"sys.path.append",
"unittest.main",
"operator.truediv"
] | [((56, 77), 'sys.path.append', 'sys.path.append', (['"""./"""'], {}), "('./')\n", (71, 77), False, 'import sys\n'), ((1395, 1410), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1408, 1410), False, 'import unittest\n'), ((1325, 1351), 'operator.truediv', 'truediv', (['dividend', 'divisor'], {}), '(dividend, divis... |
import os
import sys
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
from keras.models import load_model
from CommonHelper import GVar
from CommonHelper.Common import LoadFileToDict
from CommonHelper.GVar import CombineTrace
from LogHelper.ReadFile import ReadSavedLog
from LogHelper.Trace imp... | [
"pandas.DataFrame",
"keras.models.load_model",
"os.getcwd",
"CommonHelper.GVar.CombineTrace",
"CommonHelper.Common.LoadFileToDict",
"LogHelper.ReadFile.ReadSavedLog",
"MachineLearningHelper.trainningHelper.prepare_os_environment",
"MachineLearningHelper.trainningHelper.one_hot_decode",
"os.path.join... | [((463, 487), 'MachineLearningHelper.trainningHelper.prepare_os_environment', 'prepare_os_environment', ([], {}), '()\n', (485, 487), False, 'from MachineLearningHelper.trainningHelper import lstm_get_data_from_trace, one_hot_decode, prepare_os_environment\n'), ((4384, 4394), 'sys.exit', 'sys.exit', ([], {}), '()\n', (... |
import math
def f(N):
c = circle(N)
pass
# (x - c[0][0]) ** 2 + (y - c[0][1]) ** 2
def circle(N):
center = (math.sqrt(N), math.sqrt(N))
# radius = math.sqrt
return center
for x in range(1, 10 ** 11):
pass
| [
"math.sqrt"
] | [((128, 140), 'math.sqrt', 'math.sqrt', (['N'], {}), '(N)\n', (137, 140), False, 'import math\n'), ((142, 154), 'math.sqrt', 'math.sqrt', (['N'], {}), '(N)\n', (151, 154), False, 'import math\n')] |
# Generated by Django 3.2.4 on 2021-06-29 11:15
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='DumpTruck',
fields=[
... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BigAutoField",
"django.db.models.CharField",
"django.db.models.PositiveSmallIntegerField",
"django.db.models.DateTimeField"
] | [((3725, 3829), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'default': '(1)', 'on_delete': 'django.db.models.deletion.CASCADE', 'to': '"""front.dumptruckmodel"""'}), "(default=1, on_delete=django.db.models.deletion.CASCADE,\n to='front.dumptruckmodel')\n", (3742, 3829), False, 'from django.db import mi... |
from __future__ import print_function
import json
import requests
import luigi
import datetime
import re
from slack import *
## WIP - conversations have to be sampled by date, topic or something else
class GenerateChatterbotCorpusFromSlackChannel(luigi.Task):
channel_name = luigi.Parameter()
date = luigi.Date... | [
"json.dump",
"luigi.Parameter",
"datetime.date.today"
] | [((281, 298), 'luigi.Parameter', 'luigi.Parameter', ([], {}), '()\n', (296, 298), False, 'import luigi\n'), ((338, 359), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (357, 359), False, 'import datetime\n'), ((805, 881), 'json.dump', 'json.dump', (['corpus', 'outfile'], {'sort_keys': '(True)', 'indent... |
import os
import os.path
import shutil
HERE = os.path.dirname(__file__)
DATA_DIR = os.path.join(HERE, 'data')
TMP_DIR = os.path.join(HERE, 'tmp')
import unittest
class FunctionalTests(unittest.TestCase):
def setUp(self):
if not os.path.isdir(TMP_DIR):
os.mkdir(TMP_DIR)
def tearDown(self)... | [
"unittest.main",
"os.mkdir",
"os.path.isdir",
"os.path.dirname",
"tinyfasta.FastaParser",
"shutil.rmtree",
"os.path.join",
"tinyfasta.FastaRecord",
"re.compile"
] | [((47, 72), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (62, 72), False, 'import os\n'), ((84, 110), 'os.path.join', 'os.path.join', (['HERE', '"""data"""'], {}), "(HERE, 'data')\n", (96, 110), False, 'import os\n'), ((121, 146), 'os.path.join', 'os.path.join', (['HERE', '"""tmp"""'], {}),... |
import sys
import os
from cx_Freeze import setup, Executable
os.environ['TCL_LIBRARY'] = r'C:\Users\Ray\AppData\Local\Programs\Python\Python37\tcl\tcl8.6'
os.environ['TK_LIBRARY'] = r'C:\Users\Ray\AppData\Local\Programs\Python\Python37\tcl\tk8.6'
include_files = []
# Dependencies are automatically detected, but it... | [
"cx_Freeze.Executable"
] | [((864, 924), 'cx_Freeze.Executable', 'Executable', (['"""Package Scanner.py"""'], {'base': 'base', 'icon': '"""icon.ico"""'}), "('Package Scanner.py', base=base, icon='icon.ico')\n", (874, 924), False, 'from cx_Freeze import setup, Executable\n')] |
import cv2
import os
import glob
import pandas as pd
img_dir = "nut_snacks/dataset/"
data_path = os.path.join(img_dir,'*g')
files = glob.glob('nut_snacks/dataset/')
data = []
df_train= pd.DataFrame(columns=['img_name', 'class_no'])
i_train = 0
print(files)
for f1 in files:
img = cv2.imread(f1)
# v... | [
"pandas.DataFrame",
"cv2.imread",
"os.path.join",
"glob.glob"
] | [((105, 132), 'os.path.join', 'os.path.join', (['img_dir', '"""*g"""'], {}), "(img_dir, '*g')\n", (117, 132), False, 'import os\n'), ((141, 173), 'glob.glob', 'glob.glob', (['"""nut_snacks/dataset/"""'], {}), "('nut_snacks/dataset/')\n", (150, 173), False, 'import glob\n'), ((196, 242), 'pandas.DataFrame', 'pd.DataFram... |
from scipy import integrate
def f(x, a, b):
return a * x + b
integral,error = integrate.quad(f, 0, 4.5, args=(2,1)) # integrates 2*x+1
print(integral, error) | [
"scipy.integrate.quad"
] | [((82, 120), 'scipy.integrate.quad', 'integrate.quad', (['f', '(0)', '(4.5)'], {'args': '(2, 1)'}), '(f, 0, 4.5, args=(2, 1))\n', (96, 120), False, 'from scipy import integrate\n')] |
# -*- coding: utf-8 -*-
"""ahp.utils
This module contains the common functions and methods used by other modules in the class.
"""
import numpy as np
def normalize_priorities(criteria_pr, global_pr):
"""Normalize the priorities received from the lower layer.
This function performs a Global Prioritization a... | [
"numpy.dot"
] | [((584, 614), 'numpy.dot', 'np.dot', (['global_pr', 'criteria_pr'], {}), '(global_pr, criteria_pr)\n', (590, 614), True, 'import numpy as np\n')] |
import datetime
import re
from bs4 import BeautifulSoup, SoupStrainer
from vidscraper.exceptions import UnhandledVideo
from vidscraper.suites import BaseSuite, registry
from vidscraper.videos import VideoLoader
CONTENT_IDS = set(['program_title_text',])
CONTENT_CLASSES = set(['partner_header', 'information_left', '... | [
"vidscraper.exceptions.UnhandledVideo",
"datetime.datetime.strptime",
"bs4.SoupStrainer",
"bs4.BeautifulSoup",
"vidscraper.suites.registry.register",
"re.compile"
] | [((2731, 2755), 'vidscraper.suites.registry.register', 'registry.register', (['Suite'], {}), '(Suite)\n', (2748, 2755), False, 'from vidscraper.suites import BaseSuite, registry\n'), ((853, 920), 're.compile', 're.compile', (['"""https?://(www\\\\.)?fora\\\\.tv/\\\\d{4}/\\\\d{2}/\\\\d{2}/\\\\w+"""'], {}), "('https?://(... |
from flask_sqlalchemy import SQLAlchemy
db = SQLAlchemy()
"""Main program database helper."""
| [
"flask_sqlalchemy.SQLAlchemy"
] | [((47, 59), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', ([], {}), '()\n', (57, 59), False, 'from flask_sqlalchemy import SQLAlchemy\n')] |
"""
Custom preprocessing transformation functions for video/sequential frame
MRI data from the UK Biobank
"""
import numpy as np
from skimage.exposure import rescale_intensity
from torchvision.transforms import Lambda
class NullTransform(Lambda):
"""
Create a null transformation.
This is to be used whe... | [
"numpy.argmax",
"numpy.std",
"skimage.exposure.rescale_intensity",
"numpy.mean",
"numpy.array",
"numpy.sign"
] | [((7264, 7283), 'numpy.array', 'np.array', (['stdSeries'], {}), '(stdSeries)\n', (7272, 7283), True, 'import numpy as np\n'), ((1393, 1405), 'numpy.std', 'np.std', (['z[i]'], {}), '(z[i])\n', (1399, 1405), True, 'import numpy as np\n'), ((2050, 2078), 'numpy.sign', 'np.sign', (['(std[i + 1] - std[i])'], {}), '(std[i + ... |
import json
from models import Movie
from awstin.dynamodb import DynamoDB
def load_movies(movies):
dynamodb = DynamoDB()
table = dynamodb[Movie]
for movie_json in movies:
movie = Movie(
title=movie_json["title"],
year=movie_json["year"],
info=movie_json["info... | [
"models.Movie",
"awstin.dynamodb.DynamoDB",
"json.load"
] | [((118, 128), 'awstin.dynamodb.DynamoDB', 'DynamoDB', ([], {}), '()\n', (126, 128), False, 'from awstin.dynamodb import DynamoDB\n'), ((204, 291), 'models.Movie', 'Movie', ([], {'title': "movie_json['title']", 'year': "movie_json['year']", 'info': "movie_json['info']"}), "(title=movie_json['title'], year=movie_json['ye... |
import glob
import dimarray as da
#
# Add or update metadata
#
for nm in glob.glob('cmip5.*.nc'):
f = da.read_nc(nm)
f.reset_axis(False, axis='time', units='years since J.C', inplace=True)
f.reset_axis(False, axis='scenario', units='', long_name='RCP scenarios', inplace=True)
f['tsl'].long_name = 'gl... | [
"dimarray.read_nc",
"glob.glob"
] | [((74, 97), 'glob.glob', 'glob.glob', (['"""cmip5.*.nc"""'], {}), "('cmip5.*.nc')\n", (83, 97), False, 'import glob\n'), ((108, 122), 'dimarray.read_nc', 'da.read_nc', (['nm'], {}), '(nm)\n', (118, 122), True, 'import dimarray as da\n')] |
from discord import Embed, User
from datetime import datetime
def create_embed(title='', description='', color=0xFFFFFF, author=None, thumbnail=None):
embed = Embed(title=title, description=description, colour=color, timestamp=datetime.utcnow())
if author:
embed.set_author(name=get_formatted_name(autho... | [
"datetime.datetime.utcnow"
] | [((231, 248), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (246, 248), False, 'from datetime import datetime\n')] |
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity
# Return the top recommendations for an article
def get_recommendations(d... | [
"sklearn.feature_extraction.text.CountVectorizer",
"sklearn.metrics.pairwise.cosine_similarity",
"sklearn.metrics.pairwise.linear_kernel",
"pandas.read_csv",
"sklearn.feature_extraction.text.TfidfVectorizer",
"pandas.Series"
] | [((914, 957), 'pandas.read_csv', 'pd.read_csv', (['"""medium.csv"""'], {'low_memory': '(False)'}), "('medium.csv', low_memory=False)\n", (925, 957), True, 'import pandas as pd\n'), ((1128, 1165), 'sklearn.feature_extraction.text.TfidfVectorizer', 'TfidfVectorizer', ([], {'stop_words': '"""english"""'}), "(stop_words='e... |
#!/usr/bin/python
# Author: @BlankGodd_
import requests
import ast, json
from bs4 import BeautifulSoup
import re
class Search_Genius:
"""Songs, Artists and Search"""
def __init__(self):
"""Constructor for search genius
Methods
- search: to make a general search
- s... | [
"bs4.BeautifulSoup",
"re.sub",
"json.loads",
"requests.get"
] | [((1910, 1926), 'json.loads', 'json.loads', (['song'], {}), '(song)\n', (1920, 1926), False, 'import ast, json\n'), ((6082, 6101), 'json.loads', 'json.loads', (['artist_'], {}), '(artist_)\n', (6092, 6101), False, 'import ast, json\n'), ((7690, 7713), 'json.loads', 'json.loads', (['information'], {}), '(information)\n'... |
# Run gel modeling code
import sys
from optparse import OptionParser
from MIcalculator import MIcalculator
def processOptions():
parser = OptionParser()
parser.add_option("-r", dest="response", help="Name of the file containing the inputs.", default="")
#parser.add_option("-f", dest="inputFormat", ... | [
"MIcalculator.MIcalculator",
"optparse.OptionParser"
] | [((149, 163), 'optparse.OptionParser', 'OptionParser', ([], {}), '()\n', (161, 163), False, 'from optparse import OptionParser\n'), ((764, 803), 'MIcalculator.MIcalculator', 'MIcalculator', (['response_file', 'input_file'], {}), '(response_file, input_file)\n', (776, 803), False, 'from MIcalculator import MIcalculator\... |
import datetime
from flask import render_template, session, url_for, redirect, request, flash, current_app
from . import main
from .forms import NameForm
from .. import db
from ..models import User
from ..email import send_mail
app = current_app
@main.route('/', methods=['GET', 'POST'])
def index():
user_agent ... | [
"flask.flash",
"flask.request.headers.get",
"flask.session.get",
"datetime.datetime.utcnow",
"flask.url_for",
"flask.render_template"
] | [((322, 355), 'flask.request.headers.get', 'request.headers.get', (['"""User-Agent"""'], {}), "('User-Agent')\n", (341, 355), False, 'from flask import render_template, session, url_for, redirect, request, flash, current_app\n'), ((1563, 1602), 'flask.render_template', 'render_template', (['"""user.html"""'], {'name': ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.6 on 2017-09-16 14:09
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import utils
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependen... | [
"django.db.models.TextField",
"django.db.migrations.swappable_dependency",
"django.db.models.ManyToManyField",
"django.db.models.CharField",
"django.db.models.SlugField",
"django.db.models.AutoField",
"django.db.models.ImageField",
"django.db.models.DateTimeField"
] | [((291, 348), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (322, 348), False, 'from django.db import migrations, models\n'), ((480, 573), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)... |
# Copyright <NAME> S.A. 2019
import numpy as np
import cv2
from shapely.geometry import Point, Polygon
from shapely.ops import cascaded_union
from sklearn.cluster import KMeans, DBSCAN
from .Config import OCRConfig
from .utils import DebugUtils, sort_box
class TextBinarizer:
def __init__(self, config=None):
... | [
"numpy.sum",
"numpy.polyfit",
"numpy.ones",
"cv2.adaptiveThreshold",
"cv2.fillPoly",
"numpy.argsort",
"numpy.mean",
"numpy.linalg.norm",
"cv2.rectangle",
"cv2.imshow",
"numpy.unique",
"cv2.line",
"cv2.contourArea",
"cv2.subtract",
"numpy.zeros_like",
"shapely.geometry.Point",
"shapel... | [((1257, 1285), 'numpy.sqrt', 'np.sqrt', (['(750 * 750 / (h * w))'], {}), '(750 * 750 / (h * w))\n', (1264, 1285), True, 'import numpy as np\n'), ((14615, 14640), 'numpy.mean', 'np.mean', (['text_box'], {'axis': '(0)'}), '(text_box, axis=0)\n', (14622, 14640), True, 'import numpy as np\n'), ((14882, 14909), 'numpy.arra... |
#!/usr/bin/env python3
"""
Created on 13 Sep 2020
@author: <NAME> (<EMAIL>)
example CSV:
label,
praxis.meteo.val.hmd, praxis.meteo.val.tmp, praxis.pmx.val.per, praxis.pmx.val.bin:0, praxis.pmx.val.bin:1,
praxis.pmx.val.bin:2, praxis.pmx.val.bin:3, praxis.pmx.val.bin:4, praxis.pmx.val.bin:5, praxis.pmx.val.bin:6,
pra... | [
"scs_core.sample.sample.Sample.construct_from_jdict",
"json.loads",
"scs_core.sample.particulates_sample.ParticulatesSample",
"scs_core.sys.logging.Logging.config",
"scs_core.climate.sht_datum.SHTDatum",
"scs_core.particulate.opc_datum.OPCDatum",
"sys.stdout.flush",
"scs_core.sample.climate_sample.Cli... | [((1625, 1645), 'scs_core.climate.sht_datum.SHTDatum', 'SHTDatum', (['(25.0)', '(29.0)'], {}), '(25.0, 29.0)\n', (1633, 1645), False, 'from scs_core.climate.sht_datum import SHTDatum\n'), ((1656, 1676), 'scs_core.climate.sht_datum.SHTDatum', 'SHTDatum', (['(35.0)', '(21.0)'], {}), '(35.0, 21.0)\n', (1664, 1676), False,... |
from deta import Deta
from src.storages.base import BaseStorage
from src.types.messages import MESSAGES_TYPES, Message
class DetaStorage(BaseStorage):
"""
Messages storage with Deta as backend.
"""
def __init__(self, project_key: str, base_name: str):
self._base = Deta(project_key).Base(base... | [
"deta.Deta"
] | [((293, 310), 'deta.Deta', 'Deta', (['project_key'], {}), '(project_key)\n', (297, 310), False, 'from deta import Deta\n')] |
import ctypes
from typing import Optional
from matryoshka import Matryoshka
from api_element import ApiElement
class Status(ApiElement):
"""
A status reported by the shared library. Mostly for internal use.
"""
class Status(ctypes.Structure):
pass
# The underlying type of handle
HAN... | [
"ctypes.POINTER"
] | [((331, 353), 'ctypes.POINTER', 'ctypes.POINTER', (['Status'], {}), '(Status)\n', (345, 353), False, 'import ctypes\n')] |
import pandas as pd
import re
class Document(object):
"""
Document class represents a pandas DataFrame,
also applies some raw string transformations
"""
def __init__(self, document_name, n_rows, columns=["text", "title", "description"]):
self.document_set = pd.read_csv(
use... | [
"pandas.read_csv",
"re.sub",
"re.compile"
] | [((288, 397), 'pandas.read_csv', 'pd.read_csv', ([], {'usecols': 'columns', 'filepath_or_buffer': 'document_name', 'encoding': '"""utf-8"""', 'nrows': 'n_rows', 'header': '(0)'}), "(usecols=columns, filepath_or_buffer=document_name, encoding=\n 'utf-8', nrows=n_rows, header=0)\n", (299, 397), True, 'import pandas as... |
import os
from collections import defaultdict
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from scipy import stats
DISTRIBUTIONS = {
'exp' : "Exponential",
'N': "Normal"
}
def plot_cdf(groupings, name):
conf = name.split('-')
reservoir_size = conf[0]
distribution = DIST... | [
"scipy.stats.cumfreq",
"os.path.abspath",
"numpy.divide",
"pandas.read_csv",
"collections.defaultdict",
"numpy.linspace",
"matplotlib.pyplot.subplots",
"os.listdir"
] | [((1004, 1021), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (1015, 1021), False, 'from collections import defaultdict\n'), ((1034, 1054), 'os.listdir', 'os.listdir', (['"""../gen"""'], {}), "('../gen')\n", (1044, 1054), False, 'import os\n'), ((379, 393), 'matplotlib.pyplot.subplots', 'plt.sub... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import copy
from functools import reduce
from hypothesis import assume, given, settings
import hypothesis.strategies as st
from functools import partial
import unittest
from caffe2.python i... | [
"caffe2.python.core.Net",
"numpy.random.seed",
"numpy.abs",
"numpy.array_equal",
"numpy.argmax",
"numpy.empty",
"caffe2.python.core.BlobReference",
"numpy.iinfo",
"numpy.clip",
"numpy.ones",
"hypothesis.settings",
"numpy.random.randint",
"numpy.arange",
"hypothesis.given",
"numpy.exp",
... | [((456, 523), 'caffe2.python.dyndep.InitOpsLibrary', 'dyndep.InitOpsLibrary', (['"""@/caffe2/caffe2/fb/optimizers:sgd_simd_ops"""'], {}), "('@/caffe2/caffe2/fb/optimizers:sgd_simd_ops')\n", (477, 523), False, 'from caffe2.python import core, workspace, tt_core, dyndep\n'), ((2548, 2609), 'hypothesis.strategies.sampled_... |
# flake8: noqa E501
import networkx as nx
from partridge.parsers import \
vparse_date, \
vparse_time, \
vparse_numeric
def empty_config():
return nx.DiGraph()
'''
Default configs
'''
def default_config():
G = empty_config()
add_edge_config(G)
add_node_config(G)
return G
def add... | [
"networkx.DiGraph",
"networkx.bfs_successors"
] | [((166, 178), 'networkx.DiGraph', 'nx.DiGraph', ([], {}), '()\n', (176, 178), True, 'import networkx as nx\n'), ((8148, 8181), 'networkx.bfs_successors', 'nx.bfs_successors', (['G'], {'source': 'node'}), '(G, source=node)\n', (8165, 8181), True, 'import networkx as nx\n')] |
from baseLogger.Logger import Logger
from baseLogger.constants.MessageType import MessageType
from utilities.StringProcessor import StringProcessor
# Helper class for logging to the console.
class ConsoleLogger(Logger):
# Initializes a new instance of the ConsoleLogger class.
# @param level The logging level.... | [
"utilities.StringProcessor.StringProcessor.safe_formatter"
] | [((1955, 2000), 'utilities.StringProcessor.StringProcessor.safe_formatter', 'StringProcessor.safe_formatter', (['message', 'args'], {}), '(message, args)\n', (1985, 2000), False, 'from utilities.StringProcessor import StringProcessor\n'), ((2205, 2293), 'utilities.StringProcessor.StringProcessor.safe_formatter', 'Strin... |
from typing import Optional
import numpy as np
from sklearn.decomposition import KernelPCA, PCA
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import MinMaxScaler, OneHotEncoder, PolynomialFeatures, StandardScaler
from fedot.core.operations.evaluation.operation_implementations. \
implementati... | [
"sklearn.impute.SimpleImputer",
"sklearn.preprocessing.StandardScaler",
"sklearn.preprocessing.MinMaxScaler",
"sklearn.preprocessing.OneHotEncoder",
"numpy.hstack",
"sklearn.preprocessing.PolynomialFeatures",
"numpy.array",
"sklearn.decomposition.PCA",
"sklearn.decomposition.KernelPCA"
] | [((6063, 6106), 'numpy.array', 'np.array', (['features[:, self.categorical_ids]'], {}), '(features[:, self.categorical_ids])\n', (6071, 6106), True, 'import numpy as np\n'), ((2937, 2979), 'sklearn.decomposition.PCA', 'PCA', ([], {'svd_solver': '"""full"""', 'n_components': '"""mle"""'}), "(svd_solver='full', n_compone... |
# Copyright (c) 2021 Graphcore Ltd. All rights reserved.
import logging
import sys
from logging import handlers
class Singleton(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
... | [
"logging.StreamHandler",
"logging.Formatter",
"logging.getLevelName",
"logging.handlers.TimedRotatingFileHandler",
"logging.getLogger"
] | [((723, 750), 'logging.getLogger', 'logging.getLogger', (['filename'], {}), '(filename)\n', (740, 750), False, 'import logging\n'), ((772, 794), 'logging.Formatter', 'logging.Formatter', (['fmt'], {}), '(fmt)\n', (789, 794), False, 'import logging\n'), ((866, 899), 'logging.StreamHandler', 'logging.StreamHandler', (['s... |
# -*- encoding: utf-8 -*-
"""
Copyright (c) 2021 - <NAME>
"""
from django import forms
from apps.amcm.models import *
from django.urls import reverse
from django.utils.safestring import mark_safe
from django.forms import widgets
from django.conf import settings
class EventoForm(forms.ModelForm):
class Meta:
... | [
"django.urls.reverse",
"django.forms.ValidationError"
] | [((5396, 5421), 'django.urls.reverse', 'reverse', (['self.related_url'], {}), '(self.related_url)\n', (5403, 5421), False, 'from django.urls import reverse\n'), ((3078, 3108), 'django.forms.ValidationError', 'forms.ValidationError', (['"""Error"""'], {}), "('Error')\n", (3099, 3108), False, 'from django import forms\n'... |
from astropy.io import fits
import pandas as pd
import numpy as np
import glob
import os
class ExternalFile:
""" Read in external files and turn them into numpy arrays to work with pyRT_DISORT functions"""
def __init__(self, file_path, header_lines=0, text1d=True):
"""
Parameters
-----... | [
"pandas.DataFrame",
"numpy.load",
"numpy.save",
"pandas.read_csv",
"numpy.ndim",
"numpy.genfromtxt",
"numpy.array",
"astropy.io.fits.open",
"glob.glob",
"os.path.join"
] | [((2099, 2122), 'numpy.load', 'np.load', (['self.file_path'], {}), '(self.file_path)\n', (2106, 2122), True, 'import numpy as np\n'), ((2254, 2279), 'astropy.io.fits.open', 'fits.open', (['self.file_path'], {}), '(self.file_path)\n', (2263, 2279), False, 'from astropy.io import fits\n'), ((3229, 3286), 'numpy.array', '... |
# Copyright (C) 2016 <NAME>, <NAME>, <NAME>
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose with or without fee is hereby granted,
# provided that the above copyright notice and this permission notice
# appear in all copies.
#
# THE SOFTWARE IS PROVIDED... | [
"subprocess.check_output",
"subprocess.call",
"webbrowser.open",
"time.sleep"
] | [((2969, 3026), 'subprocess.check_output', 'subprocess.check_output', (['"""ipconfig /flushdns"""'], {'shell': '(True)'}), "('ipconfig /flushdns', shell=True)\n", (2992, 3026), False, 'import subprocess\n'), ((3333, 3377), 'webbrowser.open', 'webbrowser.open', (['key'], {'new': '(1)', 'autoraise': '(False)'}), '(key, n... |
from fastapi import FastAPI, Depends
from fastapi_cloudauth.firebase import FirebaseCurrentUser, FirebaseClaims
from fastapi.middleware.cors import CORSMiddleware
import os
import pyAesCrypt
# get credential file
cwd = os.getcwd()
password = os.environ['fast_api_password']
encrypted_file_path = "{}/credentials/credent... | [
"fastapi_cloudauth.firebase.FirebaseCurrentUser",
"os.getcwd",
"fastapi.Depends",
"pyAesCrypt.decryptFile",
"fastapi.FastAPI"
] | [((220, 231), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (229, 231), False, 'import os\n'), ((416, 490), 'pyAesCrypt.decryptFile', 'pyAesCrypt.decryptFile', (['encrypted_file_path', 'decrypted_file_path', 'password'], {}), '(encrypted_file_path, decrypted_file_path, password)\n', (438, 490), False, 'import pyAesCrypt\... |
import re
import sys
try:
from . import lib_util
from . import log
except ModuleNotFoundError:
import lib_util
import log
class Target(object):
MainMenu = [
'離開，再見…',
'人, 我是',
'[呼叫器]',
]
MainMenu_Exiting = [
'【主功能表】',
'您確定要離開',
]
QueryPost... | [
"re.findall",
"re.sub",
"lib_util.findnth",
"re.compile"
] | [((2972, 3006), 're.sub', 're.sub', (['"""[\\\\x1B]"""', '"""=PTT="""', 'result'], {}), "('[\\\\x1B]', '=PTT=', result)\n", (2978, 3006), False, 'import re\n'), ((4513, 4557), 're.findall', 're.findall', (['"""=PTT=\\\\[(\\\\d+);(\\\\d+)H"""', 'result'], {}), "('=PTT=\\\\[(\\\\d+);(\\\\d+)H', result)\n", (4523, 4557), ... |
from flask import Blueprint
from flask_restful import Api
from .resources import SignUpResource, LoginResource
auth = Blueprint('auth', __name__)
auth_api = Api(auth, catch_all_404s=True)
auth_api.add_resource(SignUpResource, '/signup', endpoint='signup')
auth_api.add_resource(LoginResource, '/login', endpoint='login... | [
"flask_restful.Api",
"flask.Blueprint"
] | [((119, 146), 'flask.Blueprint', 'Blueprint', (['"""auth"""', '__name__'], {}), "('auth', __name__)\n", (128, 146), False, 'from flask import Blueprint\n'), ((158, 188), 'flask_restful.Api', 'Api', (['auth'], {'catch_all_404s': '(True)'}), '(auth, catch_all_404s=True)\n', (161, 188), False, 'from flask_restful import A... |
# We start with mmtf-python and some APIs from DBs
import urllib as _urllib
import json as _json
#MMTF
#https://github.com/rcsb/mmtf/blob/master/spec.md#secstructlist
_sec_struct_codes = {0 : "I", #pi helix
1 : "S", # bend
2 : "H", # alpha helix
3 : "E", #... | [
"molmodel.io.to_pdb.from_pdb_id"
] | [((996, 1020), 'molmodel.io.to_pdb.from_pdb_id', '_pdb_from_pdb_id', (['pdb.id'], {}), '(pdb.id)\n', (1012, 1020), True, 'from molmodel.io.to_pdb import from_pdb_id as _pdb_from_pdb_id\n')] |
import sys
import os
sys.path.append("..")
from parse_outputs import parse_nimbus_log
import glob
fs = glob.iglob("./**/nimbus.log", recursive=True)
for f in fs:
ccp_log = open(f, 'r')
out_dir = os.path.dirname(f)
ccp_parsed_fn = os.path.join(out_dir, "nimbus.data")
ccp_parsed = open(ccp_parsed_fn, ... | [
"sys.path.append",
"os.path.dirname",
"parse_outputs.parse_nimbus_log",
"subprocess.call",
"glob.iglob",
"os.path.join"
] | [((22, 43), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (37, 43), False, 'import sys\n'), ((106, 151), 'glob.iglob', 'glob.iglob', (['"""./**/nimbus.log"""'], {'recursive': '(True)'}), "('./**/nimbus.log', recursive=True)\n", (116, 151), False, 'import glob\n'), ((207, 225), 'os.path.dirname',... |
from http import HTTPStatus
from jwt import InvalidSignatureError
from pytest import fixture
from unittest import mock
from requests.exceptions import SSLError, ConnectionError, InvalidURL
from .utils import headers
from tests.unit.mock_for_tests import (
EXPECTED_RESPONSE_DELIBERATE,
EXPECTED_RESPONSE_AUTH_E... | [
"unittest.mock.MagicMock",
"requests.exceptions.SSLError",
"pytest.fixture",
"unittest.mock.patch",
"jwt.InvalidSignatureError"
] | [((1243, 1268), 'pytest.fixture', 'fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (1250, 1268), False, 'from pytest import fixture\n'), ((1809, 1832), 'pytest.fixture', 'fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (1816, 1832), False, 'from pytest import fixture\n'), ((2358, 2... |
#!/usr/bin/env python
import os
from argparse import ArgumentParser
from os import listdir
from time import time
import h5py
import numpy as np
import tensorflow as tf
import tensorflow.contrib.slim.python.slim.nets.vgg as vgg
from PIL import Image, ImageFile
ImageFile.LOAD_TRUNCATED_IMAGES = True
from tqdm import tqd... | [
"h5py.File",
"argparse.ArgumentParser",
"tensorflow.train.Saver",
"h5py.special_dtype",
"tensorflow.contrib.slim.python.slim.nets.vgg.vgg_16",
"numpy.expand_dims",
"time.time",
"PIL.Image.open",
"tensorflow.placeholder",
"tensorflow.ConfigProto",
"tensorflow.image.resize_image_with_crop_or_pad",... | [((332, 348), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (346, 348), False, 'from argparse import ArgumentParser\n'), ((2429, 2435), 'time.time', 'time', ([], {}), '()\n', (2433, 2435), False, 'from time import time\n'), ((2564, 2627), 'tensorflow.placeholder', 'tf.placeholder', (['tf.float32', '[No... |
from typing import Union
import lab as B
from ..constant import Constant, Zero
from ..diagonal import Diagonal
from ..kronecker import Kronecker
from ..lowrank import LowRank
from ..matrix import Dense
from ..tiledblocks import TiledBlocks
from ..triangular import LowerTriangular, UpperTriangular
from ..woodbury impo... | [
"lab.dtype"
] | [((486, 500), 'lab.dtype', 'B.dtype', (['a.mat'], {}), '(a.mat)\n', (493, 500), True, 'import lab as B\n'), ((550, 565), 'lab.dtype', 'B.dtype', (['a.diag'], {}), '(a.diag)\n', (557, 565), True, 'import lab as B\n'), ((615, 631), 'lab.dtype', 'B.dtype', (['a.const'], {}), '(a.const)\n', (622, 631), True, 'import lab as... |
import networkx as nx
import numpy as np
from scipy.linalg import fractional_matrix_power, inv
import tensorlayerx as tlx
from sklearn.preprocessing import MinMaxScaler
import scipy.sparse as sp
def preprocess_features(features):
"""Row-normalize feature matrix and convert to tuple representation"""
rowsum = n... | [
"scipy.sparse.diags",
"numpy.sum",
"numpy.power",
"tensorlayerx.convert_to_numpy",
"scipy.linalg.fractional_matrix_power",
"sklearn.preprocessing.MinMaxScaler",
"numpy.isinf",
"tensorlayerx.convert_to_tensor",
"numpy.nonzero",
"networkx.convert_matrix.to_numpy_array",
"numpy.array",
"numpy.mat... | [((436, 451), 'scipy.sparse.diags', 'sp.diags', (['r_inv'], {}), '(r_inv)\n', (444, 451), True, 'import scipy.sparse as sp\n'), ((502, 533), 'tensorlayerx.convert_to_tensor', 'tlx.convert_to_tensor', (['features'], {}), '(features)\n', (523, 533), True, 'import tensorlayerx as tlx\n'), ((605, 662), 'networkx.convert_ma... |
import asyncio
import logging
from typing import Callable, List, cast
from haffmpeg.camera import CameraMjpeg
from haffmpeg.tools import IMAGE_JPEG, ImageFrame
from homeassistant.components.camera import SUPPORT_STREAM, Camera
from homeassistant.components.ffmpeg import CONF_EXTRA_ARGUMENTS, DATA_FFMPEG
from homeassist... | [
"homeassistant.components.camera.Camera.__init__",
"typing.cast",
"homeassistant.helpers.aiohttp_client.async_aiohttp_proxy_stream",
"haffmpeg.camera.CameraMjpeg",
"haffmpeg.tools.ImageFrame",
"logging.getLogger"
] | [((712, 739), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (729, 739), False, 'import logging\n'), ((977, 1052), 'typing.cast', 'cast', (['ParadoxDevice', 'hass.data[DOMAIN][config_entry.unique_id][CONF_MODULE]'], {}), '(ParadoxDevice, hass.data[DOMAIN][config_entry.unique_id][CONF_MODU... |
"""
test_head.py - tests for the HTTP metadata utilities module
author: mutantmonkey <<EMAIL>>
"""
import re
import time
import unittest
from web import HTTPError
from mock import MagicMock, patch
from modules import head
@patch('modules.head.web.head')
class TestHead(unittest.TestCase):
def setUp(self):
... | [
"modules.head.head",
"re.match",
"mock.patch",
"modules.head.setup",
"mock.MagicMock",
"modules.head.snarfuri"
] | [((224, 254), 'mock.patch', 'patch', (['"""modules.head.web.head"""'], {}), "('modules.head.web.head')\n", (229, 254), False, 'from mock import MagicMock, patch\n'), ((2307, 2336), 'mock.patch', 'patch', (['"""modules.head.web.get"""'], {}), "('modules.head.web.get')\n", (2312, 2336), False, 'from mock import MagicMock... |
# Generated by Django 2.1.4 on 2019-01-18 15:53
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('automation', '0023_vulnerability_vulnerability_fb_name'),
]
operations = [
migrations.AlterField(
model_name='vulnerability',
... | [
"django.db.models.CharField"
] | [((380, 440), 'django.db.models.CharField', 'models.CharField', ([], {'default': '"""Maybe"""', 'max_length': '(500)', 'null': '(True)'}), "(default='Maybe', max_length=500, null=True)\n", (396, 440), False, 'from django.db import migrations, models\n')] |
'''
Created on Sep 17, 2018
@author: <NAME> (<EMAIL>)
Initializer for the work log application
'''
from flask import Flask
from flasgger import Swagger
import yaml
from flask_cors import CORS
import os
def create_app():
worklog_app = Flask(__name__)
from app.web.rest.login import login_v1_blueprint
... | [
"flask_cors.CORS",
"flask.Flask",
"yaml.safe_load",
"os.getenv"
] | [((242, 257), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (247, 257), False, 'from flask import Flask\n'), ((645, 683), 'os.getenv', 'os.getenv', (['"""HOST_IP"""', '"""localhost:5000"""'], {}), "('HOST_IP', 'localhost:5000')\n", (654, 683), False, 'import os\n'), ((851, 868), 'flask_cors.CORS', 'CORS',... |
import unittest
from neuroptica.layers import Activation, ClementsLayer
from neuroptica.losses import CategoricalCrossEntropy, MeanSquaredError
from neuroptica.models import Sequential
from neuroptica.nonlinearities import *
from neuroptica.optimizers import Optimizer
from tests.base import NeuropticaTest
from tests.t... | [
"unittest.main",
"tests.test_models.TestModels.verify_model_gradients",
"neuroptica.layers.ClementsLayer",
"neuroptica.optimizers.Optimizer.make_batches"
] | [((1650, 1665), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1663, 1665), False, 'import unittest\n'), ((1212, 1260), 'neuroptica.optimizers.Optimizer.make_batches', 'Optimizer.make_batches', (['X_all', 'Y_all', 'batch_size'], {}), '(X_all, Y_all, batch_size)\n', (1234, 1260), False, 'from neuroptica.optimizers... |
import asyncio
import contextlib
import random
from discord import Forbidden, HTTPException
from discord_slash import Button, ButtonStyle, ComponentContext, SlashContext
from utils import AsteroidBot, get_content
from .game_utils import spread_to_rows
all_cards = [
"🇦🇨",
"🇦🇩",
"🇦🇪",
"🇦🇫",
... | [
"discord_slash.Button",
"asyncio.sleep",
"random.sample",
"random.shuffle",
"contextlib.suppress"
] | [((3074, 3095), 'random.shuffle', 'random.shuffle', (['cards'], {}), '(cards)\n', (3088, 3095), False, 'import random\n'), ((3117, 3152), 'random.sample', 'random.sample', (['(cards[:12] * 2)'], {'k': '(24)'}), '(cards[:12] * 2, k=24)\n', (3130, 3152), False, 'import random\n'), ((3449, 3492), 'discord_slash.Button', '... |
#!/bin/env python3
import argparse
import json
import time
import yaml
def get_options():
parser = argparse.ArgumentParser(description='Read inventory.yml')
parser.add_argument(
'--refresh-rate', dest='refresh_rate', action='store', default=0,
type=int, help='How often to refresh, (seconds).'... | [
"yaml.load",
"argparse.ArgumentParser",
"json.dumps",
"time.sleep"
] | [((106, 163), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Read inventory.yml"""'}), "(description='Read inventory.yml')\n", (129, 163), False, 'import argparse\n'), ((622, 654), 'time.sleep', 'time.sleep', (['options.refresh_rate'], {}), '(options.refresh_rate)\n', (632, 654), False, ... |
import pytorch_lightning as pl
import torch
import torch.nn as nn
import torch.nn.functional as F
from pl_bolts.optimizers.lr_scheduler import LinearWarmupCosineAnnealingLR
from solo.utils.lars import LARSWrapper
from solo.utils.metrics import accuracy_at_k, weighted_mean
from torch.optim.lr_scheduler import (
Cosi... | [
"solo.utils.metrics.accuracy_at_k",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.nn.functional.cross_entropy",
"pl_bolts.optimizers.lr_scheduler.LinearWarmupCosineAnnealingLR",
"torch.optim.lr_scheduler.CosineAnnealingLR",
"solo.utils.lars.LARSWrapper",
"torch.optim.lr_scheduler.ExponentialLR",
... | [((812, 856), 'torch.nn.Linear', 'nn.Linear', (['self.backbone.inplanes', 'n_classes'], {}), '(self.backbone.inplanes, n_classes)\n', (821, 856), True, 'import torch.nn as nn\n'), ((4927, 4955), 'torch.nn.functional.cross_entropy', 'F.cross_entropy', (['out', 'target'], {}), '(out, target)\n', (4942, 4955), True, 'impo... |
import os
import logging
import socket
from flask import Flask, jsonify
HOST_NAME = os.environ.get('HOSTNAME', 'unknown')
BUILD_NAME = os.environ.get('OPENSHIFT_BUILD_NAME', 'unknown')
PROJECT = os.environ.get('OPENSHIFT_BUILD_NAMESPACE', 'unknown')
log = logging.getLogger(__name__)
app = Flask(__name__)
@app.route(... | [
"os.environ.get",
"socket.gethostname",
"flask.Flask",
"logging.getLogger"
] | [((85, 122), 'os.environ.get', 'os.environ.get', (['"""HOSTNAME"""', '"""unknown"""'], {}), "('HOSTNAME', 'unknown')\n", (99, 122), False, 'import os\n'), ((136, 185), 'os.environ.get', 'os.environ.get', (['"""OPENSHIFT_BUILD_NAME"""', '"""unknown"""'], {}), "('OPENSHIFT_BUILD_NAME', 'unknown')\n", (150, 185), False, '... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('picmodels', '0011_auto_20170125_0242'),
]
operations = [
migrations.AddField(
model_name='consumernote',
... | [
"django.db.models.ForeignKey"
] | [((367, 441), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'to': '"""picmodels.PICConsumerBackup"""'}), "(blank=True, null=True, to='picmodels.PICConsumerBackup')\n", (384, 441), False, 'from django.db import migrations, models\n')] |
import pandas as pd
import matplotlib.pyplot as plt
retail_data1 = pd.read_csv('https://storage.googleapis.com/dqlab-dataset/10%25_original_randomstate%3D42/retail_data_from_1_until_3_reduce.csv')
retail_data2 = pd.read_csv('https://storage.googleapis.com/dqlab-dataset/10%25_original_randomstate%3D42/retail_data_from_... | [
"pandas.read_csv",
"pandas.to_datetime",
"pandas.concat"
] | [((68, 207), 'pandas.read_csv', 'pd.read_csv', (['"""https://storage.googleapis.com/dqlab-dataset/10%25_original_randomstate%3D42/retail_data_from_1_until_3_reduce.csv"""'], {}), "(\n 'https://storage.googleapis.com/dqlab-dataset/10%25_original_randomstate%3D42/retail_data_from_1_until_3_reduce.csv'\n )\n", (79, ... |
from __future__ import absolute_import, division, print_function, unicode_literals
import unittest
import ipaddress
from socks5.events import (
NeedMoreData,
Socks4Request, Socks4Response,
GreetingRequest, GreetingResponse,
Request, Response)
from socks5.define import (
REQ_COMMAND, AUTH_TYPE,
... | [
"socks5.events.NeedMoreData",
"socks5.events.Socks4Request",
"socks5.events.GreetingResponse",
"socks5.events.Response",
"socks5.events.Socks4Response",
"socks5.events.Request",
"ipaddress.IPv4Address",
"socks5.events.GreetingRequest"
] | [((436, 450), 'socks5.events.NeedMoreData', 'NeedMoreData', ([], {}), '()\n', (448, 450), False, 'from socks5.events import NeedMoreData, Socks4Request, Socks4Response, GreetingRequest, GreetingResponse, Request, Response\n'), ((551, 596), 'socks5.events.Socks4Request', 'Socks4Request', (['(1)', '"""127.0.0.1"""', '(55... |
import json
from types import new_class
from datetime import datetime
import re
import operator
import itertools
dict_creators_name = []
class edge_bundling:
"""
To read the JSON file from swallow, saved in the same folder
"""
file_path=str(input("Please provide the path to the JSON file: " ))
json... | [
"json.dump",
"operator.itemgetter",
"re.sub",
"json.loads"
] | [((488, 504), 'json.loads', 'json.loads', (['data'], {}), '(data)\n', (498, 504), False, 'import json\n'), ((4196, 4235), 'json.dump', 'json.dump', (['json_obj', 'out_file'], {'indent': '(6)'}), '(json_obj, out_file, indent=6)\n', (4205, 4235), False, 'import json\n'), ((2264, 2286), 'operator.itemgetter', 'operator.it... |
# -*- coding: utf-8 -*-
import torch
import torch.nn as nn
import torch.nn.functional as F
from supar.modules import (CharLSTM, ELMoEmbedding, IndependentDropout,
SharedDropout, TransformerEmbedding,
VariationalLSTM)
from supar.modules.anchor import AnchorGCN
from ... | [
"torch.nn.Dropout",
"supar.modules.TransformerEmbedding",
"supar.modules.VariationalLSTM",
"torch.nn.Embedding",
"torch.cat",
"torch.nn.utils.rnn.pad_packed_sequence",
"supar.modules.gnn.GAT",
"dgl.DGLGraph",
"supar.modules.gnn.GraphSAGE",
"torch.nn.functional.log_softmax",
"torch.nn.Linear",
... | [((8020, 8059), 'torch.cat', 'torch.cat', (['(word_embed, feat_embed)', '(-1)'], {}), '((word_embed, feat_embed), -1)\n', (8029, 8059), False, 'import torch\n'), ((9457, 9496), 'torch.cat', 'torch.cat', (['(word_embed, feat_embed)', '(-1)'], {}), '((word_embed, feat_embed), -1)\n', (9466, 9496), False, 'import torch\n'... |
import numpy as np
import k_means
import k_medians
dataArray = [[]]
# filepath = input("Enter data file path")
# filepath = "/home/kshitij/Downloads/sample"
filepath = "/home/kshitij/Downloads/assignment2fileformat_19856"
n = 0
with open(filepath, "r") as datafile:
for line in datafile:
n += 1
le... | [
"k_medians.cluster",
"k_means.cluster"
] | [((840, 882), 'k_means.cluster', 'k_means.cluster', (['dataArray', 'k', 'dim', 'dNo', 't'], {}), '(dataArray, k, dim, dNo, t)\n', (855, 882), False, 'import k_means\n'), ((956, 1000), 'k_medians.cluster', 'k_medians.cluster', (['dataArray', 'k', 'dim', 'dNo', 't'], {}), '(dataArray, k, dim, dNo, t)\n', (973, 1000), Fal... |
# Copyright 2015 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... | [
"collections.namedtuple"
] | [((907, 961), 'collections.namedtuple', 'collections.namedtuple', (['"""PathValue"""', "['path', 'value']"], {}), "('PathValue', ['path', 'value'])\n", (929, 961), False, 'import collections\n')] |
from django.apps import apps
from django.db import models
class EmotionEntry(models.Model):
"""Part of an emotion report from a user, pertaining to a specific emotion."""
emotion = models.ForeignKey("Emotion", on_delete=models.CASCADE)
report = models.ForeignKey("EmotionReport", on_delete=models.CASCADE... | [
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.PositiveSmallIntegerField"
] | [((193, 247), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""Emotion"""'], {'on_delete': 'models.CASCADE'}), "('Emotion', on_delete=models.CASCADE)\n", (210, 247), False, 'from django.db import models\n'), ((261, 321), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""EmotionReport"""'], {'on_delete'... |
from tweepy.streaming import StreamListener
from tweepy import OAuthHandler
from tweepy import Stream
from kafka import KafkaProducer
import json
import re
import argparse
from pathlib import Path
api_key = ""
api_secret = ""
access_token = ""
access_token_secret = ""
topic_name = "cv19"
parser = a... | [
"argparse.ArgumentParser",
"json.loads",
"kafka.KafkaProducer",
"tweepy.Stream",
"tweepy.OAuthHandler"
] | [((319, 344), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (342, 344), False, 'import argparse\n'), ((2260, 2310), 'kafka.KafkaProducer', 'KafkaProducer', ([], {'bootstrap_servers': '"""localhost:19092"""'}), "(bootstrap_servers='localhost:19092')\n", (2273, 2310), False, 'from kafka import K... |
from threading import Thread
from unittest import TestCase
from unittest.mock import Mock
from application.infrastructure.robotWorker import RobotWorker
class TestRobotWorker(TestCase):
def setUp(self) -> None:
self.vision_service = Mock()
self.communication_service = Mock()
self.display_... | [
"threading.Thread",
"unittest.mock.Mock",
"application.infrastructure.robotWorker.RobotWorker"
] | [((248, 254), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (252, 254), False, 'from unittest.mock import Mock\n'), ((292, 298), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (296, 298), False, 'from unittest.mock import Mock\n'), ((330, 336), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (334, 336), False, 'from... |
#!/usr/bin/env python
# coding: utf-8
# # Measure morphometric characters
#
# Computational notebook 02 for Climate adaptation plans in the context of coastal settlements: the case of Portugal.
#
# Date: 27/06/2020
#
# ---
#
# This notebook generates additional morphometric elements (morphological tessellation and... | [
"momepy.BuildingAdjacency",
"momepy.EquivalentRectangularIndex",
"momepy.Corners",
"momepy.Perimeter",
"momepy.nx_to_gdf",
"momepy.network_false_nodes",
"momepy.get_network_id",
"momepy.meshedness",
"momepy.AreaRatio",
"fiona.listlayers",
"momepy.StreetProfile",
"momepy.Reached",
"momepy.sw_... | [((2238, 2266), 'geopandas.read_file', 'gpd.read_file', (['path'], {'layer': 'l'}), '(path, layer=l)\n', (2251, 2266), True, 'import geopandas as gpd\n'), ((2380, 2403), 'momepy.unique_id', 'mm.unique_id', (['buildings'], {}), '(buildings)\n', (2392, 2403), True, 'import momepy as mm\n'), ((2689, 2735), 'momepy.Tessell... |
from collections import defaultdict
class Solution:
def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
ht = defaultdict(list)
for s in strs:
s_ = ''.join(sorted(s))
ht[s_].append(s)
return list(ht.values()) | [
"collections.defaultdict"
] | [((131, 148), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (142, 148), False, 'from collections import defaultdict\n')] |
from typing import List, Optional
import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as mpc
import matplotlib.cm as cm
from matplotlib import rc
from matplotlib import colors
from matplotlib.ticker import MaxNLocator
from matplotlib.colors import BoundaryNorm
import numpy as np
import... | [
"matplotlib.pyplot.yscale",
"numpy.argmin",
"numpy.shape",
"matplotlib.pyplot.figure",
"numpy.mean",
"matplotlib.pyplot.fill_between",
"matplotlib.pyplot.tight_layout",
"numpy.multiply",
"matplotlib.ticker.MaxNLocator",
"helper_funcs.get_tab_colors",
"numpy.insert",
"numpy.linalg.eig",
"nump... | [((1411, 1427), 'helper_funcs.get_tab_colors', 'get_tab_colors', ([], {}), '()\n', (1425, 1427), False, 'from helper_funcs import convert2rgb, get_tab_colors\n'), ((1438, 1456), 'matplotlib.pyplot.figure', 'plt.figure', (['metric'], {}), '(metric)\n', (1448, 1456), True, 'import matplotlib.pyplot as plt\n'), ((2354, 23... |