code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# -*- coding: utf-8 -*-
import logging
import requests as rqc
from flask.ext.restful import Resource
from flask import Response, request
from flask import stream_with_context
INPUT_DATA_SERVER_LOCATION = 'http://dataserver:3000/'
class UploadResource(Resource):
def get(self):
req = rqc.get(INPUT_DATA_SE... | [
"logging.debug",
"requests.get",
"flask.request.stream.read"
] | [((299, 347), 'requests.get', 'rqc.get', (['INPUT_DATA_SERVER_LOCATION'], {'stream': '(True)'}), '(INPUT_DATA_SERVER_LOCATION, stream=True)\n', (306, 347), True, 'import requests as rqc\n'), ((601, 629), 'logging.debug', 'logging.debug', (['"""UPLOAD POST"""'], {}), "('UPLOAD POST')\n", (614, 629), False, 'import loggi... |
import torch, add_path
import numpy as np
from baselines.all_baselines import Poly2SLS, Vanilla2SLS, DirectNN, \
GMM, DeepIV, AGMM
import os
import tensorflow
from MMR_IVs.util import ROOT_PATH, load_data
import random
random.seed(527)
def eval_model(model, test):
g_pred_test = model.predict(test.x)
mse = ... | [
"numpy.load",
"numpy.random.seed",
"numpy.mean",
"MMR_IVs.util.load_data",
"os.path.join",
"numpy.std",
"os.path.exists",
"baselines.all_baselines.DeepIV",
"tensorflow.set_random_seed",
"random.seed",
"baselines.all_baselines.DirectNN",
"numpy.save",
"torch.manual_seed",
"baselines.all_bas... | [((223, 239), 'random.seed', 'random.seed', (['(527)'], {}), '(527)\n', (234, 239), False, 'import random\n'), ((460, 528), 'numpy.savez', 'np.savez', (['save_path'], {'x': 'test.w', 'y': 'test.y', 'g_true': 'test.g', 'g_hat': 'g_pred'}), '(save_path, x=test.w, y=test.y, g_true=test.g, g_hat=g_pred)\n', (468, 528), Tru... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import discord
from classes.Plugin import Plugin
NAME = "Status"
DESCRIPTION = "Change the bot status and his played game on discord"
USAGE = {}
class StatusPlugin(Plugin):
def __init__(self, cdb):
super().__init__(cdb)
self.status_dict = {"online... | [
"discord.Game"
] | [((2320, 2358), 'discord.Game', 'discord.Game', ([], {'name': 'message.content[6:]'}), '(name=message.content[6:])\n', (2332, 2358), False, 'import discord\n')] |
import sys
import os
import shutil
if len(sys.argv) < 2:
print("Failed to obtain GView.hpp location")
exit(1)
header_location = sys.argv[1]
if not os.path.exists(header_location):
print("Path {} does not exists!".format(header_location))
exit(1)
default_version_to_update = 1 # major=0, minor=1, patc... | [
"os.putenv",
"os.path.exists",
"shutil.move"
] | [((1593, 1645), 'shutil.move', 'shutil.move', (['header_output_location', 'header_location'], {}), '(header_output_location, header_location)\n', (1604, 1645), False, 'import shutil\n'), ((157, 188), 'os.path.exists', 'os.path.exists', (['header_location'], {}), '(header_location)\n', (171, 188), False, 'import os\n'),... |
try:
from pyspark import SparkContext, SparkConf
from pyspark.sql import SparkSession
import pyspark.sql.functions as f
# from operator import add
except Exception as e:
print(e)
## http://www.hongyusu.com/imt/technology/spark-via-python-basic-setup-count-lines-and-word-counts.html
def push_mongo():... | [
"pyspark.sql.SparkSession.builder.appName"
] | [((333, 380), 'pyspark.sql.SparkSession.builder.appName', 'SparkSession.builder.appName', (['"""Push to MongoDB"""'], {}), "('Push to MongoDB')\n", (361, 380), False, 'from pyspark.sql import SparkSession\n')] |
from typing import List
from tudelft_utilities_logging.Reporter import Reporter
from geniusweb.deadline.Deadline import Deadline
from geniusweb.protocol.session.SessionProtocol import SessionProtocol
from geniusweb.protocol.session.SessionSettings import SessionSettings
from geniusweb.protocol.session.TeamInfo import... | [
"geniusweb.protocol.session.mopac.MOPACState.MOPACState"
] | [((1800, 1836), 'geniusweb.protocol.session.mopac.MOPACState.MOPACState', 'MOPACState', (['None', '[]', 'None', 'self', '{}'], {}), '(None, [], None, self, {})\n', (1810, 1836), False, 'from geniusweb.protocol.session.mopac.MOPACState import MOPACState\n')] |
import streamlit as st
import plotly_express as px
import pandas as pd
# configuration
st.set_option('deprecation.showfileUploaderEncoding', False)
# title of the app
st.title("Data Visualization App")
# Add a sidebar
st.sidebar.subheader("Visualization Settings")
# Setup file upload
uploaded_file = st.sidebar.file... | [
"streamlit.sidebar.slider",
"plotly_express.histogram",
"streamlit.sidebar.subheader",
"streamlit.set_option",
"streamlit.plotly_chart",
"pandas.read_csv",
"streamlit.title",
"streamlit.write",
"pandas.read_excel",
"streamlit.sidebar.selectbox",
"plotly_express.scatter",
"plotly_express.box",
... | [((88, 148), 'streamlit.set_option', 'st.set_option', (['"""deprecation.showfileUploaderEncoding"""', '(False)'], {}), "('deprecation.showfileUploaderEncoding', False)\n", (101, 148), True, 'import streamlit as st\n'), ((169, 203), 'streamlit.title', 'st.title', (['"""Data Visualization App"""'], {}), "('Data Visualiza... |
# coding: utf-8
import os
import shutil
import json
import click
from werkzeug.utils import cached_property
class Context(object):
def __init__(self):
self.config_filename = os.environ.get('RIGIDSEARCH_CONFIG')
@cached_property
def app(self):
from rigidsearch.app import create_app
... | [
"rigidsearch.app.make_production_server",
"os.path.abspath",
"json.load",
"click.argument",
"click.option",
"rigidsearch.search.get_index",
"click.echo",
"rigidsearch.app.create_app",
"rigidsearch.search.get_index_path",
"os.environ.get",
"click.make_pass_decorator",
"click.File",
"click.Pat... | [((376, 423), 'click.make_pass_decorator', 'click.make_pass_decorator', (['Context'], {'ensure': '(True)'}), '(Context, ensure=True)\n', (401, 423), False, 'import click\n'), ((427, 440), 'click.group', 'click.group', ([], {}), '()\n', (438, 440), False, 'import click\n'), ((1514, 1537), 'click.argument', 'click.argume... |
# Created by kamimura on 2018/07/21.
# Copyright © 2018 kamimura. All rights reserved.
import sys
import datetime
from antlr4 import *
from SIONLexer import SIONLexer
from SIONParser import SIONParser
from SIONVisitor import SIONVisitor
def load(file, encoding: str='utf-8', errors: str='strict') -> object:
data =... | [
"SIONParser.SIONParser",
"SIONLexer.SIONLexer",
"pprint.pprint",
"SIONVisitor.SIONVisitor"
] | [((466, 483), 'SIONLexer.SIONLexer', 'SIONLexer', (['stream'], {}), '(stream)\n', (475, 483), False, 'from SIONLexer import SIONLexer\n'), ((535, 553), 'SIONParser.SIONParser', 'SIONParser', (['tokens'], {}), '(tokens)\n', (545, 553), False, 'from SIONParser import SIONParser\n'), ((596, 609), 'SIONVisitor.SIONVisitor'... |
"""Implements widgets to visualize and modify basic fields. (french language)
ASSOCIATION should be updated with custom widgets, since common.abstractDetails will use it.
"""
import datetime
import re
from collections import defaultdict
from typing import List, Any
from PyQt5.QtCore import pyqtSignal, Qt, QPoint
from ... | [
"PyQt5.QtCore.pyqtSignal",
"PyQt5.QtWidgets.QStyledItemDelegate.__init__",
"PyQt5.QtGui.QColor",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QPushButton",
"collections.defaultdict",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtGui.QBrush",
"PyQt5.QtWidgets.QCompleter",
"PyQt5.QtWidgets.QSpinBox",
... | [((16988, 17618), 'collections.defaultdict', 'defaultdict', (['(lambda : Default)'], {'date_naissance': 'Date', 'departement_naissance': 'Departement', 'sexe': 'Sexe', 'tels': 'Tels', 'adresse': 'Adresse', 'date': 'Date', 'date_debut': 'Date', 'date_fin': 'Date', 'date_arrivee': 'Date', 'date_depart': 'Date', 'date_emi... |
import json
from sklearn.preprocessing import LabelEncoder
from src.comment_analysis.url_utils import get_text_by_url
from src.csv.csv_utils import get_link_line_type, get_keywords
from src.keys import line, serialize_outpath
from nltk.stem.porter import *
from spacy.lang.en.stop_words import STOP_WORDS
from src.comm... | [
"src.csv.csv_utils.get_keywords",
"json.loads",
"src.comment_analysis.url_utils.get_text_by_url",
"sklearn.preprocessing.LabelEncoder",
"json.dumps",
"src.csv.csv_utils.get_link_line_type"
] | [((3876, 3903), 'src.csv.csv_utils.get_link_line_type', 'get_link_line_type', ([], {'set': 'set'}), '(set=set)\n', (3894, 3903), False, 'from src.csv.csv_utils import get_link_line_type, get_keywords\n'), ((4457, 4471), 'sklearn.preprocessing.LabelEncoder', 'LabelEncoder', ([], {}), '()\n', (4469, 4471), False, 'from s... |
from unittest import TestCase
from h.models import User
from . import AppTestCase
class UserTest(AppTestCase):
def test_password_encrypt(self):
"""make sure user passwords are stored encrypted
"""
u1 = User(username=u'test', password=u'<PASSWORD>', email=u'<EMAIL>')
assert u1.pass... | [
"h.models.User"
] | [((233, 297), 'h.models.User', 'User', ([], {'username': 'u"""test"""', 'password': 'u"""<PASSWORD>"""', 'email': 'u"""<EMAIL>"""'}), "(username=u'test', password=u'<PASSWORD>', email=u'<EMAIL>')\n", (237, 297), False, 'from h.models import User\n')] |
"""
Class for parsing the main Ben Yehuda site page
"""
from urllib import request
from urllib import parse as urlparse
from bs4 import BeautifulSoup
from .helpers import NamedLink, clean_text
class MainPage(object):
"""
Parses and gets information from the main index page. Mostly used to get
links for a... | [
"urllib.request.urlopen"
] | [((465, 485), 'urllib.request.urlopen', 'request.urlopen', (['url'], {}), '(url)\n', (480, 485), False, 'from urllib import request\n')] |
import pandas as pd
def load_from_excel(file_path, sheet_name=None):
"""
Loads the data from an Excel file into a list of dictionaries, where each dictionary represents a row in the Excel
file and the keys of each dictionary represent each column header in the Excel file. The method creates this list
... | [
"pandas.DataFrame",
"pandas.ExcelFile",
"pandas.ExcelWriter"
] | [((771, 794), 'pandas.ExcelFile', 'pd.ExcelFile', (['file_path'], {}), '(file_path)\n', (783, 794), True, 'import pandas as pd\n'), ((2249, 2293), 'pandas.ExcelWriter', 'pd.ExcelWriter', (['file_path'], {'engine': '"""openpyxl"""'}), "(file_path, engine='openpyxl')\n", (2263, 2293), True, 'import pandas as pd\n'), ((23... |
"""WIP URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.10/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based ... | [
"django.conf.urls.url"
] | [((1004, 1035), 'django.conf.urls.url', 'url', (['"""^admin/"""', 'admin.site.urls'], {}), "('^admin/', admin.site.urls)\n", (1007, 1035), False, 'from django.conf.urls import url\n'), ((1042, 1073), 'django.conf.urls.url', 'url', (['"""^show/$"""', 'show_complaints'], {}), "('^show/$', show_complaints)\n", (1045, 1073... |
from devserver.modules import DevServerModule
from devserver.utils.time import ms_from_timedelta
from devserver.settings import DEVSERVER_AUTO_PROFILE
from datetime import datetime
import functools
import gc
class ProfileSummaryModule(DevServerModule):
"""
Outputs a summary of cache events once a response i... | [
"guppy.hpy",
"gc.enable",
"line_profiler.LineProfiler",
"cStringIO.StringIO",
"gc.collect",
"gc.set_debug",
"devserver.utils.time.ms_from_timedelta",
"functools.wraps",
"django.template.defaultfilters.filesizeformat",
"warnings.warn",
"datetime.datetime.now"
] | [((425, 439), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (437, 439), False, 'from datetime import datetime\n'), ((899, 910), 'gc.enable', 'gc.enable', ([], {}), '()\n', (908, 910), False, 'import gc\n'), ((919, 949), 'gc.set_debug', 'gc.set_debug', (['gc.DEBUG_SAVEALL'], {}), '(gc.DEBUG_SAVEALL)\n', (93... |
# -*- coding: utf-8 -*-
import hashlib
import json
import pycurl
from ..base.multi_account import MultiAccount
class LinkifierCom(MultiAccount):
__name__ = "LinkifierCom"
__type__ = "account"
__version__ = "0.01"
__status__ = "testing"
__pyload_version__ = "0.5"
__description__ = """Linki... | [
"json.dumps"
] | [((1184, 1200), 'json.dumps', 'json.dumps', (['post'], {}), '(post)\n', (1194, 1200), False, 'import json\n')] |
#This code is written for dynamic step-size. step size c0 gets smaller when it achieves the number 200.
#Author: <NAME>, Senior Research Fellow, University of Delhi
#Date: 5-07-2021
from math import *
import numpy as np
c0=50.0
for x in np.arange(c0,580,10):
t=10*(abs(200.1-c0)/200.1)*abs(np.log(0.3/abs(c0-200.1)... | [
"numpy.arange"
] | [((239, 261), 'numpy.arange', 'np.arange', (['c0', '(580)', '(10)'], {}), '(c0, 580, 10)\n', (248, 261), True, 'import numpy as np\n')] |
import theano
import argparse
_floatX = theano.config.floatX
def str2bool(v):
return v.lower() in ('yes', 'true', 't', '1', 'y')
def get_args():
parser = argparse.ArgumentParser()
parser.register('type', 'bool', str2bool)
# Basics
parser.add_argument('--debug',
type='... | [
"argparse.ArgumentParser"
] | [((169, 194), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (192, 194), False, 'import argparse\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.1 on 2016-01-30 00:57
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('measure_mate', '0009_auto_20160124_1245'),
]
operat... | [
"django.db.models.ForeignKey"
] | [((448, 605), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""target_measurements"""', 'to': '"""measure_mate.Rating"""'}), "(blank=True, null=True, on_delete=django.db.models.\n deletion.CASCADE, rel... |
'''
Created on Aug 26, 2014
@author: preethi
'''
import os
import sys
import shutil
sys.path.insert(0,os.path.abspath(os.path.dirname(__file__) + '/' + '../..')) #trick to make it run from CLI
import unittest
import sqlalchemy
from sqlalchemy.orm import sessionmaker
import pydot
from jnpr.openclos.model import Pod, D... | [
"os.path.abspath",
"jnpr.openclos.model.InterfaceDefinition",
"jnpr.openclos.writer.CablingPlanWriter",
"os.path.dirname",
"os.path.exists",
"pydot.Dot",
"jnpr.openclos.dao.Dao",
"test_model.createPod",
"jnpr.openclos.writer.ConfigWriter",
"shutil.rmtree",
"jnpr.openclos.model.Device"
] | [((1228, 1242), 'jnpr.openclos.dao.Dao', 'Dao', (['self.conf'], {}), '(self.conf)\n', (1231, 1242), False, 'from jnpr.openclos.dao import Dao\n'), ((1302, 1359), 'shutil.rmtree', 'shutil.rmtree', (["self.conf['outputDir']"], {'ignore_errors': '(True)'}), "(self.conf['outputDir'], ignore_errors=True)\n", (1315, 1359), F... |
# -*- coding: utf-8 -*-
from flask import Flask, request, make_response
import requests
import json
from core import Translation, RequestJson, PBMT
from bean import log
app = Flask(__name__)
def buildResponse(code, msg):
json_data = dict()
json_data['code'] = code
json_data['message'] = msg
response... | [
"flask.Flask",
"json.dumps",
"core.Translation",
"bean.log.writelogs",
"flask.request.get_json",
"bean.log.getlogs",
"core.RequestJson"
] | [((177, 192), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (182, 192), False, 'from flask import Flask, request, make_response\n'), ((337, 374), 'json.dumps', 'json.dumps', (['json_data'], {'sort_keys': '(True)'}), '(json_data, sort_keys=True)\n', (347, 374), False, 'import json\n'), ((1287, 1305), 'core... |
# Copyright (c) 2003-2019 by <NAME>
#
# TreeCorr is free software: redistribution and use in source and binary forms,
# with or without modification, are permitted provided that the following
# conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this
# list of conditions... | [
"numpy.sum",
"test_helper.assert_raises",
"treecorr.Catalog",
"numpy.mean",
"test_helper.get_from_wiki",
"os.path.join",
"numpy.unique",
"numpy.std",
"numpy.random.RandomState",
"numpy.max",
"numpy.testing.assert_allclose",
"numpy.average",
"numpy.testing.assert_array_equal",
"treecorr.set... | [((1012, 1040), 'test_helper.get_from_wiki', 'get_from_wiki', (['"""des_sv.fits"""'], {}), "('des_sv.fits')\n", (1025, 1040), False, 'from test_helper import get_from_wiki, CaptureLog, assert_raises, profile, timer\n'), ((1057, 1092), 'os.path.join', 'os.path.join', (['"""data"""', '"""des_sv.fits"""'], {}), "('data', ... |
'''
This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).
PM4Py is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any late... | [
"pm4py.objects.log.obj.EventStream",
"pm4py.objects.log.obj.Trace",
"pm4py.objects.log.obj.EventLog"
] | [((1331, 1373), 'pm4py.objects.log.obj.Trace', 'Trace', (['events'], {'attributes': 'trace.attributes'}), '(events, attributes=trace.attributes)\n', (1336, 1373), False, 'from pm4py.objects.log.obj import EventLog, Trace, EventStream\n'), ((1932, 2132), 'pm4py.objects.log.obj.EventStream', 'EventStream', (['events'], {... |
import theano
from utils import srng
def dropout(input, dropout_rate=0):
if dropout_rate > 0:
retain = 1 - dropout_rate
d_output = (input / retain) * srng.binomial(input.shape, p=retain,
dtype='int32').astype('float32')
else:
d_output = input
return d_output
| [
"utils.srng.binomial"
] | [((171, 222), 'utils.srng.binomial', 'srng.binomial', (['input.shape'], {'p': 'retain', 'dtype': '"""int32"""'}), "(input.shape, p=retain, dtype='int32')\n", (184, 222), False, 'from utils import srng\n')] |
from .. import Explanation
from ..utils import OpChain
from . import colors
import numpy as np
def convert_color(color):
try:
color = pl.get_cmap(color)
except:
pass
if color == "shap_red":
color = colors.red_rgb
elif color == "shap_blue":
color = colors.blue_rgb
... | [
"numpy.argsort",
"numpy.abs",
"numpy.array",
"numpy.delete"
] | [((1167, 1190), 'numpy.argsort', 'np.argsort', (['clust_order'], {}), '(clust_order)\n', (1177, 1190), True, 'import numpy as np\n'), ((3993, 4037), 'numpy.delete', 'np.delete', (['partition_tree_new', 'ptind'], {'axis': '(0)'}), '(partition_tree_new, ptind, axis=0)\n', (4002, 4037), True, 'import numpy as np\n'), ((46... |
# Copyright (c) 2016-2019 <NAME>
# License: MIT License
import ezdxf
dwg = ezdxf.new('R2000') # underlay requires the DXF R2000 format or newer
pdf_underlay_def = dwg.add_underlay_def(filename='underlay.pdf', name='1') # name = page to display
dwf_underlay_def = dwg.add_underlay_def(filename='underlay.dwf',
... | [
"ezdxf.new"
] | [((76, 94), 'ezdxf.new', 'ezdxf.new', (['"""R2000"""'], {}), "('R2000')\n", (85, 94), False, 'import ezdxf\n')] |
import re
import string
class Reformulator(object):
def __init__(self, question, qclass, lang='en', stopwords=None):
self.__original_question = question
punctuation = re.sub(r"[-+/&']", '', string.punctuation)
self.__punctuation_re = r'[{}]'.format(punctuation)
question = question[... | [
"re.sub"
] | [((189, 230), 're.sub', 're.sub', (['"""[-+/&\']"""', '""""""', 'string.punctuation'], {}), '("[-+/&\']", \'\', string.punctuation)\n', (195, 230), False, 'import re\n'), ((365, 405), 're.sub', 're.sub', (['"""(?<=[A-Z])\\\\."""', '"""QQQ"""', 'question'], {}), "('(?<=[A-Z])\\\\.', 'QQQ', question)\n", (371, 405), Fals... |
#! /usr/bin/env python3.6
import pymysql
import re
import random
import datetime
import sys
import argparse
import os
#########################
# Main-Routine #
#########################
def main():
#Initialization
print('> Crawler Initialization...')
iter_num = 0
crawler_nba.init()
#Argu... | [
"sys.path.append",
"package_crawler_nba.crawler_nba.GetWikiLinksContent",
"argparse.ArgumentParser",
"random.randint",
"package_crawler_nba.crawler_nba.init",
"os.path.realpath",
"os.path.dirname",
"package_crawler_nba.crawler_nba.cur.fetchall",
"package_crawler_nba.crawler_nba.MySQLDBInitialize",
... | [((291, 309), 'package_crawler_nba.crawler_nba.init', 'crawler_nba.init', ([], {}), '()\n', (307, 309), True, 'import package_crawler_nba.crawler_nba as crawler_nba\n'), ((484, 558), 'package_crawler_nba.crawler_nba.MySQLDBInitialize', 'crawler_nba.MySQLDBInitialize', (['password', 'table', 'unix_socket', 'database_nam... |
import autolens as al
grid = al.Grid.uniform(shape_2d=(10, 10), pixel_scales=1.0)
aplt.Grid(grid=grid)
grid = al.Grid.uniform(shape_2d=(10, 10), pixel_scales=1.0, origin=(5.0, 5.0))
aplt.Grid(grid=grid, symmetric_around_centre=False)
| [
"autolens.Grid.uniform"
] | [((32, 84), 'autolens.Grid.uniform', 'al.Grid.uniform', ([], {'shape_2d': '(10, 10)', 'pixel_scales': '(1.0)'}), '(shape_2d=(10, 10), pixel_scales=1.0)\n', (47, 84), True, 'import autolens as al\n'), ((119, 190), 'autolens.Grid.uniform', 'al.Grid.uniform', ([], {'shape_2d': '(10, 10)', 'pixel_scales': '(1.0)', 'origin'... |
import datetime
from app import db, mail
from app.models import Member, MemberInvite
from flask import Blueprint, flash, redirect, render_template, request, url_for
from flask_login import current_user, login_required, login_user
from flask_mail import Message
from .forms import MemberInviteForm, MemberJoinForm
memb... | [
"flask.flash",
"flask.Blueprint",
"app.models.Member",
"flask.request.args.get",
"flask.request.form.get",
"flask.redirect",
"flask_mail.Message",
"flask_login.login_user",
"app.models.MemberInvite.query.filter_by",
"datetime.datetime.utcnow",
"flask.url_for",
"app.db.session.delete",
"app.m... | [((326, 418), 'flask.Blueprint', 'Blueprint', (['"""members"""', '__name__'], {'subdomain': '"""<org_username>"""', 'template_folder': '"""templates"""'}), "('members', __name__, subdomain='<org_username>', template_folder=\n 'templates')\n", (335, 418), False, 'from flask import Blueprint, flash, redirect, render_t... |
# Copyright 2020 Google Inc.
#
# 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,... | [
"sideinput_refresh.util.get_formatted_time",
"apache_beam.typehints.with_input_types",
"apache_beam.typehints.with_output_types"
] | [((734, 772), 'apache_beam.typehints.with_input_types', 'beam.typehints.with_input_types', (['bytes'], {}), '(bytes)\n', (765, 772), True, 'import apache_beam as beam\n'), ((774, 832), 'apache_beam.typehints.with_output_types', 'beam.typehints.with_output_types', (['beam.pvalue.TaggedOutput'], {}), '(beam.pvalue.Tagged... |
from flask import (
render_template,
request,
redirect,
url_for)
from flask_login import login_user, logout_user
from app.helpers import BaseView
from .models import LoginForm, User
class AuthView(BaseView):
def dispatch_request(self):
form = LoginForm(request.form)
if request.meth... | [
"flask.render_template",
"flask.url_for",
"flask_login.login_user",
"flask_login.logout_user"
] | [((872, 885), 'flask_login.logout_user', 'logout_user', ([], {}), '()\n', (883, 885), False, 'from flask_login import login_user, logout_user\n'), ((352, 398), 'flask.render_template', 'render_template', (['self.template_name'], {'form': 'form'}), '(self.template_name, form=form)\n', (367, 398), False, 'from flask impo... |
import pandas as pd
import re
import nltk
import spacy
import torch
from nltk.corpus import stopwords
from cleantext import clean
from ekphrasis.classes.preprocessor import TextPreProcessor
from torch.utils.data import Dataset
# Params for
clean_text_param = {
"lower":False, # lowercase text
... | [
"pandas.DataFrame",
"ekphrasis.classes.preprocessor.TextPreProcessor",
"re.subn",
"spacy.load",
"nltk.corpus.stopwords.words",
"nltk.download",
"torch.tensor"
] | [((1261, 1289), 'spacy.load', 'spacy.load', (['"""en_core_web_sm"""'], {}), "('en_core_web_sm')\n", (1271, 1289), False, 'import spacy\n'), ((1626, 1676), 'torch.tensor', 'torch.tensor', (['self.y_train[idx]'], {'dtype': 'torch.float'}), '(self.y_train[idx], dtype=torch.float)\n', (1638, 1676), False, 'import torch\n')... |
"""projecto URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.1/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-base... | [
"django.urls.path"
] | [((747, 778), 'django.urls.path', 'path', (['"""admin/"""', 'admin.site.urls'], {}), "('admin/', admin.site.urls)\n", (751, 778), False, 'from django.urls import path, re_path\n'), ((784, 825), 'django.urls.path', 'path', (['"""index/"""', 'views.index'], {'name': '"""index"""'}), "('index/', views.index, name='index')... |
from models.basemodel import BaseModel
from sklearn import model_selection, svm
class SupportVectorMachineRegressionPoly3(BaseModel):
def _train(self, X_train, y_train):
parametres = {'gamma': [0.01, 0.1, 1], 'C': [1, 10, 100], 'degree': [2,3,4,5,6]}
grid_search = model_selection.GridSearchCV(svm... | [
"sklearn.svm.SVR"
] | [((317, 339), 'sklearn.svm.SVR', 'svm.SVR', ([], {'kernel': '"""poly"""'}), "(kernel='poly')\n", (324, 339), False, 'from sklearn import model_selection, svm\n')] |
# Mathematics > Number Theory > John and GCD list
# Help John in making a list from GCD list
#
# https://www.hackerrank.com/challenges/john-and-gcd-list/problem
#
import math
import functools
def gcd(*numbers):
""" greatest common divisor """
return functools.reduce(math.gcd, numbers)
def lcm(*numbers):
... | [
"functools.reduce"
] | [((261, 296), 'functools.reduce', 'functools.reduce', (['math.gcd', 'numbers'], {}), '(math.gcd, numbers)\n', (277, 296), False, 'import functools\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: <NAME>
"""
import melopero_RV_3028 as mp
import time
def main():
# First initialize and create the rtc device
rtc = mp.RV_3028()
# setup the rtc to use the eeprom memory (disables the automatic configuration refresh)
rtc.use_eeprom()
my... | [
"melopero_RV_3028.RV_3028",
"time.sleep"
] | [((186, 198), 'melopero_RV_3028.RV_3028', 'mp.RV_3028', ([], {}), '()\n', (196, 198), True, 'import melopero_RV_3028 as mp\n'), ((805, 818), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (815, 818), False, 'import time\n')] |
# Generated by Django 3.1.13 on 2021-11-28 15:25
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('clinical_annotations_manager', '0017_auto_20210424_1321'),
]
operations = [
migrations.RenameField(
model_name='coreannotation',
... | [
"django.db.migrations.RenameField"
] | [((249, 367), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""coreannotation"""', 'old_name': '"""creation_start_date"""', 'new_name': '"""action_start_time"""'}), "(model_name='coreannotation', old_name=\n 'creation_start_date', new_name='action_start_time')\n", (271, 367), Fal... |
"""
192.168.30.22 hostA.localdomain # hostA
192.168.30.33 hostB.localdomain # hostB
192.168.30.44 hostC.localdomain # hostB
"""
"""
groups = [{"hostname": "hostA","ip": "192.168.30.22", "fqdn": "hostA.localdomain"},
{"hostname": "hostB", "ip": "192.168.30.33", "fqdn": "hostB.localdomain"},
{"hostn... | [
"flask.session.pop",
"flask.redirect",
"flask.request.form.get",
"flask.Flask",
"flask.render_template"
] | [((628, 643), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (633, 643), False, 'from flask import Flask, request, redirect, url_for, session, render_template\n'), ((1522, 1564), 'flask.render_template', 'render_template', (['"""hosts.j2"""'], {'groups': 'groups'}), "('hosts.j2', groups=groups)\n", (1537, ... |
import numpy as np
import tensorflow as tf
from read_data import get_X_y
from sklearn.preprocessing import MinMaxScaler
import matplotlib.pyplot as plt
import pickle
class NN():
def __init__(self, batch_size = 300, graph = tf.get_default_graph(),test_size = 0.1, steps_back=8, num_TCL=30):
self.... | [
"tensorflow.reshape",
"sklearn.preprocessing.MinMaxScaler",
"tensorflow.matmul",
"tensorflow.nn.conv2d",
"tensorflow.get_default_graph",
"tensorflow.nn.relu",
"tensorflow.concat",
"tensorflow.placeholder",
"numpy.reshape",
"tensorflow.nn.bias_add",
"tensorflow.losses.mean_squared_error",
"tens... | [((11564, 11609), 'read_data.get_X_y', 'get_X_y', ([], {'steps_back': '(7)', 'filename': '"""Q_data0.csv"""'}), "(steps_back=7, filename='Q_data0.csv')\n", (11571, 11609), False, 'from read_data import get_X_y\n'), ((239, 261), 'tensorflow.get_default_graph', 'tf.get_default_graph', ([], {}), '()\n', (259, 261), True, ... |
'''
Compare the data where they overlap in the uv plane.
No offset correction is needed.
'''
from spectral_cube import SpectralCube
import numpy as np
import astropy.units as u
import matplotlib.pyplot as plt
import os
import scipy.ndimage as nd
from uvcombine.scale_factor import find_scale_factor
from cube_analys... | [
"numpy.exp",
"matplotlib.pyplot.tight_layout",
"os.path.join",
"scipy.ndimage.distance_transform_edt",
"numpy.zeros_like",
"uvcombine.scale_factor.find_scale_factor",
"cube_analysis.feather_cubes.feather_compare_cube",
"matplotlib.pyplot.close",
"plotting_styles.onecolumn_figure",
"numpy.isfinite"... | [((1775, 1805), 'os.path.join', 'os.path.join', (['data_path', '"""GBT"""'], {}), "(data_path, 'GBT')\n", (1787, 1805), False, 'import os\n'), ((2574, 2768), 'cube_analysis.feather_cubes.feather_compare_cube', 'feather_compare_cube', (['vla_cube', 'gbt_cube', 'las'], {'num_cores': '(1)', 'lowresfwhm': 'gbt_eff_beam', '... |
# Generated by Django 3.2.5 on 2021-08-05 18:01
import django.core.validators
from django.db import migrations, models
import re
class Migration(migrations.Migration):
dependencies = [
('exams', '0019_auto_20210805_1334'),
]
operations = [
migrations.AlterField(
model_name='... | [
"re.compile"
] | [((2105, 2137), 're.compile', 're.compile', (['"""^\\\\d+(?:,\\\\d+)*\\\\Z"""'], {}), "('^\\\\d+(?:,\\\\d+)*\\\\Z')\n", (2115, 2137), False, 'import re\n'), ((2465, 2497), 're.compile', 're.compile', (['"""^\\\\d+(?:,\\\\d+)*\\\\Z"""'], {}), "('^\\\\d+(?:,\\\\d+)*\\\\Z')\n", (2475, 2497), False, 'import re\n'), ((2825,... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** 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, Dict, List, Mapping, Optional, Tuple, Union
from .. import ... | [
"pulumi.get",
"pulumi.getter",
"pulumi.set",
"pulumi.InvokeOptions",
"pulumi.runtime.invoke"
] | [((1894, 1926), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""activeOnly"""'}), "(name='activeOnly')\n", (1907, 1926), False, 'import pulumi\n'), ((2545, 2578), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""labelPrefix"""'}), "(name='labelPrefix')\n", (2558, 2578), False, 'import pulumi\n'), ((797, 845), 'p... |
#!/usr/bin/env Python # This line is needed only for unix-based systems.
# Written by <NAME>, <NAME>, <NAME>.
# March 2020.
#
import qcportal as ptl
from qcfractal import FractalSnowflake
import pandas as pd
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-d", "--dry-run", action="store_true")
... | [
"qcportal.models.Citation",
"argparse.ArgumentParser",
"qcfractal.FractalSnowflake",
"qcportal.collections.ReactionDataset",
"qcportal.FractalClient.from_file",
"qcportal.Molecule.from_file"
] | [((234, 259), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (257, 259), False, 'import argparse\n'), ((580, 640), 'qcportal.collections.ReactionDataset', 'ptl.collections.ReactionDataset', (['dataset_name'], {'client': 'client'}), '(dataset_name, client=client)\n', (611, 640), True, 'import qc... |
import pygame
class Font():
def __init__(self, name, size):
self._name = name
self._size = size
self._font = pygame.font.SysFont(name, size)
#TODO Add support for font files
def getFontName(self):
return self._name
def getFontSize(self):
return self._siz... | [
"pygame.font.SysFont"
] | [((141, 172), 'pygame.font.SysFont', 'pygame.font.SysFont', (['name', 'size'], {}), '(name, size)\n', (160, 172), False, 'import pygame\n')] |
from mite.utils import pack_msg
class DirectReceiverMock:
def __init__(self):
self._listeners = []
self._raw_listeners = []
def __call__(self, msg):
return
def add_listener(self, listener):
self._listeners.append(listener)
def add_raw_listener(self, raw_listener):
... | [
"mite.utils.pack_msg"
] | [((484, 497), 'mite.utils.pack_msg', 'pack_msg', (['msg'], {}), '(msg)\n', (492, 497), False, 'from mite.utils import pack_msg\n')] |
from django.contrib.auth import authenticate, login
import graphene
import django_filters
from graphene_django import DjangoObjectType, DjangoListField
from graphene_django.filter import DjangoFilterConnectionField
from graphql_jwt.decorators import login_required
from .models import User
class UserType(DjangoObject... | [
"graphene.String",
"graphene.Field",
"graphene_django.filter.DjangoFilterConnectionField"
] | [((527, 557), 'graphene.String', 'graphene.String', ([], {'required': '(True)'}), '(required=True)\n', (542, 557), False, 'import graphene\n'), ((573, 603), 'graphene.String', 'graphene.String', ([], {'required': '(True)'}), '(required=True)\n', (588, 603), False, 'import graphene\n'), ((621, 638), 'graphene.String', '... |
"""Procedures to define the Command Line Interface (cli)"""
from pathlib import Path
import click
from conference_scheduler.scheduler import event_schedule_difference
from conference_scheduler.converter import solution_to_schedule
from conference_scheduler.validator import (
is_valid_solution, solution_violations)... | [
"click.version_option",
"scheduler.define.add_unavailability_to_events",
"click.option",
"scheduler.define.add_clashes_to_events",
"scheduler.define.add_allocations",
"scheduler.io.export_solution_and_definition",
"pathlib.Path",
"daiquiri.getLogger",
"scheduler.define.add_unsuitability_to_events",
... | [((506, 534), 'daiquiri.getLogger', 'daiquiri.getLogger', (['__name__'], {}), '(__name__)\n', (524, 534), False, 'import daiquiri\n'), ((1007, 1084), 'click.version_option', 'click.version_option', ([], {'message': '"""%(prog)s %(version)s :: UK Python Association"""'}), "(message='%(prog)s %(version)s :: UK Python Ass... |
# AUTOGENERATED! DO NOT EDIT! File to edit: utils.ipynb (unless otherwise specified).
__all__ = ['load_config', 'config', 'load_yaml', 'default_yaml', 'dict_to_paras']
# Cell
import pkg_resources
import configparser
import yaml
# Cell
def load_config(*configs):
config = configparser.ConfigParser()
config.r... | [
"yaml.load",
"configparser.ConfigParser",
"pkg_resources.resource_filename"
] | [((280, 307), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (305, 307), False, 'import configparser\n'), ((400, 462), 'pkg_resources.resource_filename', 'pkg_resources.resource_filename', (['"""pybiotools4p"""', '"""default.ini"""'], {}), "('pybiotools4p', 'default.ini')\n", (431, 462), Fa... |
import os
import hashlib
def generate_password_hash(password):
salt = os.urandom(32)
key = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)
return (salt, key)
def check_password_hash(password, salt, key):
# Use the exact same setup you used to generate the key, but this time put ... | [
"os.urandom"
] | [((76, 90), 'os.urandom', 'os.urandom', (['(32)'], {}), '(32)\n', (86, 90), False, 'import os\n')] |
#!/usr/bin/env python
# This file is part of the straitjacket project
# https://gitlab.com/mbarkhau/straitjacket
#
# Copyright (c) 2018 <NAME> (<EMAIL>) - MIT License
# SPDX-License-Identifier: MIT
try:
import backtrace
# To enable pretty tracebacks:
# echo "export ENABLE_BACKTRACE=1;" >> ~/.bashrc
... | [
"backtrace.hook",
"sys.exit"
] | [((320, 391), 'backtrace.hook', 'backtrace.hook', ([], {'align': '(True)', 'strip_path': '(True)', 'enable_on_envvar_only': '(True)'}), '(align=True, strip_path=True, enable_on_envvar_only=True)\n', (334, 391), False, 'import backtrace\n'), ((505, 516), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (513, 516), False,... |
"""terraform_to_ansible/parser.py"""
import json
import logging
import os
import subprocess
import sys
class Parser:
"""Main Terraform tfstate parser."""
def __init__(self, args):
"""Init a thing."""
# Define dictionary to hold all parsed resources
self.all_resources = {}
#... | [
"json.load",
"os.getcwd",
"logging.getLogger",
"subprocess.getoutput",
"os.chdir",
"sys.exit"
] | [((537, 564), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (554, 564), False, 'import logging\n'), ((1791, 1802), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1800, 1802), False, 'import os\n'), ((1870, 1895), 'os.chdir', 'os.chdir', (['self.tfstatedir'], {}), '(self.tfstatedir)\n', (18... |
#!/usr/bin/env python3
# Set this to True to enable building extensions using Cython.
# Set it to False to build extensions from the C file (that
# was previously created using Cython).
# Set it to 'auto' to build with Cython if available, otherwise
# from the C file.
import sys
from setuptools import setup, find_pac... | [
"setuptools.Extension",
"Cython.Build.cythonize",
"distutils.command.sdist.sdist.run",
"numpy.get_include",
"setuptools.find_packages"
] | [((1910, 1946), 'setuptools.Extension', 'Extension', (['module.name', '[module.pyx]'], {}), '(module.name, [module.pyx])\n', (1919, 1946), False, 'from setuptools import setup, find_packages, Extension\n'), ((2070, 2104), 'setuptools.Extension', 'Extension', (['module.name', '[module.c]'], {}), '(module.name, [module.c... |
from typing import Optional
from peek_plugin_base.PluginCommonEntryHookABC import PluginCommonEntryHookABC
from peek_plugin_base.agent.PeekAgentPlatformHookABC import PeekAgentPlatformHookABC
class PluginAgentEntryHookABC(PluginCommonEntryHookABC):
def __init__(self, pluginName: str, pluginRootDir: str, platfor... | [
"peek_plugin_base.PluginCommonEntryHookABC.PluginCommonEntryHookABC.__init__"
] | [((358, 453), 'peek_plugin_base.PluginCommonEntryHookABC.PluginCommonEntryHookABC.__init__', 'PluginCommonEntryHookABC.__init__', (['self'], {'pluginName': 'pluginName', 'pluginRootDir': 'pluginRootDir'}), '(self, pluginName=pluginName,\n pluginRootDir=pluginRootDir)\n', (391, 453), False, 'from peek_plugin_base.Plu... |
import os, math, yaml
from emonitor.extensions import db
class Struct(dict):
def __init__(self, **entries):
self.__dict__.update(entries)
class Settings(db.Model):
"""Settings class"""
__tablename__ = 'settings'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, prima... | [
"yaml.load",
"emonitor.extensions.db.Column",
"yaml.safe_dump",
"emonitor.extensions.db.app.config.get",
"emonitor.extensions.db.session.commit",
"emonitor.extensions.db.session.add",
"emonitor.extensions.db.String",
"emonitor.extensions.db.config.get",
"emonitor.modules.maps.map.Map.getMaps",
"ma... | [((293, 332), 'emonitor.extensions.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (302, 332), False, 'from emonitor.extensions import db\n'), ((382, 409), 'emonitor.extensions.db.Column', 'db.Column', (['"""value"""', 'db.Text'], {}), "('value', db.Text)\n", (3... |
# ---
# jupyter:
# jupytext:
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.4'
# jupytext_version: 1.1.5
# kernelspec:
# display_name: Python 3
# language: python
# name: python3
# ---
# # s_checklist_scenariobased_step04 [<img src="https:/... | [
"matplotlib.pyplot.title",
"pandas.read_csv",
"numpy.ones",
"numpy.shape",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.figure",
"numpy.arange",
"matplotlib.pyplot.gca",
"numpy.sqrt",
"scipy.stats.t.cdf",
"arpym.statistics.quantile_sp",
"matplotlib.pyplot.yticks",
"arpym.tools.add_logo"... | [((763, 795), 'pandas.plotting.register_matplotlib_converters', 'register_matplotlib_converters', ([], {}), '()\n', (793, 795), False, 'from pandas.plotting import register_matplotlib_converters\n'), ((1126, 1153), 'numpy.datetime64', 'np.datetime64', (['"""2012-10-26"""'], {}), "('2012-10-26')\n", (1139, 1153), True, ... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 4 08:24:48 2021
proto_optim.py
- Find the protoimage vectors
"""
import torch
import torch.optim as optim
import torch.nn as nn
import math
from tqdm import tqdm
from . import utils
#Optimization to get the protoimages
def proto_optim(... | [
"torch.ones",
"torch.optim.lr_scheduler.StepLR",
"math.ceil",
"torch.nn.CosineSimilarity",
"torch.optim.Adam",
"torch.zeros"
] | [((916, 950), 'torch.zeros', 'torch.zeros', (['num_samples', 'num_dims'], {}), '(num_samples, num_dims)\n', (927, 950), False, 'import torch\n'), ((801, 840), 'math.ceil', 'math.ceil', (['(num_samples / minibatch_size)'], {}), '(num_samples / minibatch_size)\n', (810, 840), False, 'import math\n'), ((1703, 1745), 'torc... |
import bblfsh_sonar_checks.utils as utils
import bblfsh
def check(uast):
findings = []
fin_calls = bblfsh.filter(uast, "//MethodInvocation//"
"Identifier[@roleCall and @roleReceiver and @Name='System']/parent::MethodInvocation/"
"Identifier[@roleCall and @roleCallee and @Name='gc']/pa... | [
"bblfsh.filter",
"bblfsh_sonar_checks.utils.run_default_fixture"
] | [((110, 323), 'bblfsh.filter', 'bblfsh.filter', (['uast', '"""//MethodInvocation//Identifier[@roleCall and @roleReceiver and @Name=\'System\']/parent::MethodInvocation/Identifier[@roleCall and @roleCallee and @Name=\'gc\']/parent::MethodInvocation"""'], {}), '(uast,\n "//MethodInvocation//Identifier[@roleCall and @r... |
# -*- coding: UTF-8 -*-
"""
This file is part of RT1.
(c) 2016- <NAME>
For COPYING and LICENSE details, please refer to the LICENSE file
"""
from setuptools import setup
#from setuptools import find_packages
from rt1 import __version__
setup(name='rt1',
version=__version__,
description='RT1 - bistatic ... | [
"setuptools.setup"
] | [((239, 1250), 'setuptools.setup', 'setup', ([], {'name': '"""rt1"""', 'version': '__version__', 'description': '"""RT1 - bistatic single scattering radiative transfer model"""', 'packages': "['rt1']", 'package_dir': "{'rt1': 'rt1'}", 'include_package_data': '(False)', 'author': '"""<NAME>"""', 'author_email': '"""<EMA... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** 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... | [
"pulumi.get",
"pulumi.getter",
"pulumi.ResourceOptions",
"pulumi.set"
] | [((1567, 1599), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""cidrBlocks"""'}), "(name='cidrBlocks')\n", (1580, 1599), False, 'import pulumi\n'), ((5128, 5160), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""cidrBlocks"""'}), "(name='cidrBlocks')\n", (5141, 5160), False, 'import pulumi\n'), ((5525, 5557), 'p... |
import os
import sys
sys.path.append(os.getcwd())
import tensorflow as tf
tf.get_logger().setLevel('ERROR')
from tensorflow import keras
from common.inputs.voc2010 import voc_parts
from common import layers, losses, utils, train, attacks
from common.ops.routing import activated_entropy, coupling_entropy
import numpy... | [
"tensorflow.keras.applications.VGG19",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.metrics.CategoricalAccuracy",
"common.attacks.evaluate_attacks_success_rate",
"tensorflow.keras.losses.CategoricalCrossentropy",
"common.train.Trainer",
"numpy.mean",
"config.parse_args",
"common.utils.get_shap... | [((384, 419), 'tensorflow.keras.regularizers.l2', 'keras.regularizers.l2', (['WEIGHT_DECAY'], {}), '(WEIGHT_DECAY)\n', (405, 419), False, 'from tensorflow import keras\n'), ((441, 471), 'tensorflow.keras.initializers.he_normal', 'keras.initializers.he_normal', ([], {}), '()\n', (469, 471), False, 'from tensorflow impor... |
# -*- coding: utf-8 -*-
"""
Displays some of the augmented images. Can be used to visually check that augmentation is working fine.
Created on Wed May 8 12:12:26 2019
@author: lbechberger
"""
import argparse, pickle
import matplotlib.pyplot as plt
import tensorflow as tf
parser = argparse.ArgumentParser(descriptio... | [
"matplotlib.pyplot.show",
"argparse.ArgumentParser",
"tensorflow.global_variables_initializer",
"tensorflow.Session",
"tensorflow.placeholder",
"matplotlib.pyplot.figure",
"pickle.load",
"tensorflow.image.decode_jpeg"
] | [((286, 353), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Visualizing augmented images"""'}), "(description='Visualizing augmented images')\n", (309, 353), False, 'import argparse, pickle\n'), ((809, 834), 'tensorflow.placeholder', 'tf.placeholder', (['tf.string'], {}), '(tf.string)\n... |
from teca import *
import numpy as np
import sys
def get_request_callback(rank, var_names):
def request(port, md_in, req_in):
sys.stderr.write('descriptive_stats::request MPI %d\n'%(rank))
req = teca_metadata(req_in)
req['arrays'] = var_names
return [req]
return request
def get... | [
"numpy.average",
"numpy.std",
"numpy.percentile",
"numpy.max",
"numpy.min",
"sys.stderr.write"
] | [((139, 201), 'sys.stderr.write', 'sys.stderr.write', (["('descriptive_stats::request MPI %d\\n' % rank)"], {}), "('descriptive_stats::request MPI %d\\n' % rank)\n", (155, 201), False, 'import sys\n'), ((401, 463), 'sys.stderr.write', 'sys.stderr.write', (["('descriptive_stats::execute MPI %d\\n' % rank)"], {}), "('des... |
# Copyright 2019-2020 by <NAME>, MGLAND animation studio. All rights reserved.
# This file is part of IUTest, and is released under the "MIT License Agreement".
# Please see the LICENSE file that should have been included as part of this package.
import os
from iutest.core import pathutils
from iutest.qt import iconFr... | [
"iutest.core.pathutils.iutestPackageDir",
"os.path.join",
"iutest.qt.iconFromPath"
] | [((369, 397), 'iutest.core.pathutils.iutestPackageDir', 'pathutils.iutestPackageDir', ([], {}), '()\n', (395, 397), False, 'from iutest.core import pathutils\n'), ((936, 954), 'iutest.qt.iconFromPath', 'iconFromPath', (['path'], {}), '(path)\n', (948, 954), False, 'from iutest.qt import iconFromPath\n'), ((752, 783), '... |
#!/usr/bin/env python
'''
Search a p4 for good indices. This imports the file specified by
the modulepath option, reads a function called "f" from it,
and filters the frames using it. Outputs a numpy array of
good trajectories.
Usage:
./search.py [options] <input> <hashd> <output>
Options:
--help -h ... | [
"lspreader.pmovie.filter_hashes_from_file",
"imp.find_module",
"docopt.docopt",
"imp.load_module",
"re.search",
"pys.load_pickle"
] | [((705, 731), 'docopt.docopt', 'docopt', (['__doc__'], {'help': '(True)'}), '(__doc__, help=True)\n', (711, 731), False, 'from docopt import docopt\n'), ((772, 810), 're.search', 're.search', (['"""(^.*)/(\\\\w+)\\\\.py$"""', 'fname'], {}), "('(^.*)/(\\\\w+)\\\\.py$', fname)\n", (781, 810), False, 'import re\n'), ((947... |
import asyncio
import dataclasses
import json
import re
import typing
from pathlib import Path
import aiohttp
from loguru import logger
from .utils import download_url, get_request, get_original_filename
# Format string linking to the download of a vscode extension .vsix file.
MARKETPLACE_DOWNLOAD_LINK = '''
htt... | [
"asyncio.gather",
"json.load",
"loguru.logger.warning",
"aiohttp.ClientSession",
"loguru.logger.info",
"pathlib.Path",
"loguru.logger.debug",
"re.search",
"re.compile"
] | [((747, 778), 're.compile', 're.compile', (['""""Version":"(.*?)\\""""'], {}), '(\'"Version":"(.*?)"\')\n', (757, 778), False, 'import re\n'), ((2980, 3027), 'loguru.logger.info', 'logger.info', (['f"""Downloading {extension_name}..."""'], {}), "(f'Downloading {extension_name}...')\n", (2991, 3027), False, 'from loguru... |
from textwrap import dedent
def test_code_block(script):
"""
Test code block.
"""
script.set_content(
dedent(
"""
```python
m = {}
m["x"] = 1
```
"""
)
)
assert (
'<ac:structured-mac... | [
"textwrap.dedent"
] | [((128, 261), 'textwrap.dedent', 'dedent', (['"""\n ```python\n m = {}\n m["x"] = 1\n ```\n """'], {}), '(\n """\n ```python\n m = {}\n m["x"] = 1\n ```\n """\n )\n', (134,... |
from threading import Timer
import logging
from igmp.packet.PacketIGMPHeader import PacketIGMPHeader
from igmp.packet.ReceivedPacket import ReceivedPacket
from igmp.rwlock.RWLock import RWLockWrite
from igmp.utils import TYPE_CHECKING
from . import igmp_globals
from .GroupState import GroupState
from .querier.Querier... | [
"threading.Timer",
"igmp.rwlock.RWLock.RWLockWrite",
"igmp.packet.PacketIGMPHeader.PacketIGMPHeader",
"logging.LoggerAdapter",
"logging.getLogger"
] | [((505, 549), 'logging.getLogger', 'logging.getLogger', (['"""igmp.igmpv2.RouterState"""'], {}), "('igmp.igmpv2.RouterState')\n", (522, 549), False, 'import logging\n'), ((799, 867), 'logging.LoggerAdapter', 'logging.LoggerAdapter', (['RouterState.ROUTER_STATE_LOGGER', 'logger_extra'], {}), '(RouterState.ROUTER_STATE_L... |
###
# Copyright 2021 New H3C Technologies Co., Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"utils.client.RedfishClient",
"utils.client.RestfulClient",
"exception.ToolException.FailException",
"utils.predo.GetVersion"
] | [((6216, 6228), 'utils.predo.GetVersion', 'GetVersion', ([], {}), '()\n', (6226, 6228), False, 'from utils.predo import GetVersion\n'), ((6708, 6727), 'utils.client.RestfulClient', 'RestfulClient', (['args'], {}), '(args)\n', (6721, 6727), False, 'from utils.client import RedfishClient, RestfulClient\n'), ((6352, 6371)... |
import torch
import argparse
import logging
from utils import corpora2idx, normalizeString
from const import *
class Dictionary(object):
def __init__(self):
self.word2idx = {
WORD[BOS]: BOS,
WORD[EOS]: EOS,
WORD[PAD]: PAD,
WORD[UNK]: UNK
}
s... | [
"torch.save",
"utils.normalizeString",
"utils.corpora2idx",
"argparse.ArgumentParser"
] | [((4136, 4190), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""seq2sqe corpora"""'}), "(description='seq2sqe corpora')\n", (4159, 4190), False, 'import argparse\n'), ((3875, 3908), 'torch.save', 'torch.save', (['data', 'self._save_data'], {}), '(data, self._save_data)\n', (3885, 3908), F... |
import streamlit as st
import os
from streamlit_img_label import st_img_label
from streamlit_img_label.manage import ImageManager, ImageDirManager
def run(img_dir, labels):
st.set_option("deprecation.showfileUploaderEncoding", False)
idm = ImageDirManager(img_dir)
if "files" not in st.session_state:
... | [
"streamlit_img_label.st_img_label",
"streamlit.columns",
"streamlit.set_option",
"streamlit.sidebar.write",
"os.path.join",
"streamlit.sidebar.selectbox",
"streamlit.button",
"streamlit.sidebar.columns",
"streamlit_img_label.manage.ImageManager",
"streamlit.warning",
"streamlit.sidebar.button",
... | [((178, 238), 'streamlit.set_option', 'st.set_option', (['"""deprecation.showfileUploaderEncoding"""', '(False)'], {}), "('deprecation.showfileUploaderEncoding', False)\n", (191, 238), True, 'import streamlit as st\n'), ((249, 273), 'streamlit_img_label.manage.ImageDirManager', 'ImageDirManager', (['img_dir'], {}), '(i... |
r"""
Library routines for minimally 3-connected graph generation.
This program requires cython.
"""
import pyximport
pyximport.install(language_level=3)
| [
"pyximport.install"
] | [((130, 165), 'pyximport.install', 'pyximport.install', ([], {'language_level': '(3)'}), '(language_level=3)\n', (147, 165), False, 'import pyximport\n')] |
from PyQt5 import QtCore, QtNetwork
import random
from gpusim_utils import smiles_to_fingerprint_bin
def parse_args():
import argparse
parser = argparse.ArgumentParser(description="Sample GPUSim Server - "
"run an HTTP server that loads fingerprint data onto GPU and " #noqa
"responds ... | [
"argparse.ArgumentParser",
"random.randint",
"PyQt5.QtCore.QCoreApplication",
"PyQt5.QtCore.QByteArray",
"PyQt5.QtNetwork.QLocalSocket",
"gpusim_utils.smiles_to_fingerprint_bin",
"PyQt5.QtCore.QDataStream"
] | [((155, 340), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Sample GPUSim Server - run an HTTP server that loads fingerprint data onto GPU and responds to queries to find most similar fingperints."""'}), "(description=\n 'Sample GPUSim Server - run an HTTP server that loads fingerpri... |
import click
import pendulum
import subprocess
import os
from pathlib import Path
from aoc.script import Script
import aoc.paths
import pendulum
@click.command()
@click.option("-y", "--year", type=str)
@click.option("-d", "--day", type=str)
def new(year: str, day: str):
"""Create new script for AOC"""
if not... | [
"subprocess.Popen",
"pendulum.tomorrow",
"click.option",
"click.command",
"pendulum.now",
"os.environ.get",
"pathlib.Path",
"pendulum.today",
"aoc.script.Script.from_year_day"
] | [((148, 163), 'click.command', 'click.command', ([], {}), '()\n', (161, 163), False, 'import click\n'), ((165, 203), 'click.option', 'click.option', (['"""-y"""', '"""--year"""'], {'type': 'str'}), "('-y', '--year', type=str)\n", (177, 203), False, 'import click\n'), ((205, 242), 'click.option', 'click.option', (['"""-... |
# coding: utf-8
import setuptools
setuptools.setup(
name = 'Pynames',
version = '0.1.0',
author = '<NAME>',
author_email = '<EMAIL>',
packages = setuptools.find_packages(),
url = 'https://github.com/Tiendil/pynames',
license = 'LICENSE',
description = "characters' name generation librar... | [
"setuptools.find_packages"
] | [((166, 192), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (190, 192), False, 'import setuptools\n')] |
from setuptools import setup, find_packages
setup(
name='TracSoftDueDate', version='1.0',
packages=find_packages(exclude=['*.tests*']),
entry_points = {
'trac.plugins': [
'softduedate = softduedate',
],
},
)
| [
"setuptools.find_packages"
] | [((102, 137), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "['*.tests*']"}), "(exclude=['*.tests*'])\n", (115, 137), False, 'from setuptools import setup, find_packages\n')] |
import os
from urllib.parse import urlparse
import requests
from PyPDF2 import PdfFileReader
def download_pdf(url):
parse = urlparse(url)
base_url = parse.scheme + '://' + parse.netloc
try:
redirect = requests.get(url, allow_redirects=False)
except requests.exceptions.ConnectionError as e:
... | [
"requests.get",
"os.path.isfile",
"PyPDF2.PdfFileReader",
"urllib.parse.urlparse"
] | [((131, 144), 'urllib.parse.urlparse', 'urlparse', (['url'], {}), '(url)\n', (139, 144), False, 'from urllib.parse import urlparse\n'), ((559, 583), 'os.path.isfile', 'os.path.isfile', (['filename'], {}), '(filename)\n', (573, 583), False, 'import os\n'), ((224, 264), 'requests.get', 'requests.get', (['url'], {'allow_r... |
#!/usr/bin/env python
r'''
Compare two datasets to determine whether there is a significant
difference between them for a specific confidence level using the
t-test methodology for unpaired observations.
Please note that this is not, strictly, a t-test because it switches
over to the standard normal distribution (SND)... | [
"math.exp",
"inspect.stack",
"argparse.ArgumentParser",
"math.sqrt",
"os.path.basename",
"os.path.splitext",
"math.log",
"datetime.datetime.now",
"sys.exit"
] | [((5739, 5762), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (5760, 5762), False, 'import datetime\n'), ((6313, 6324), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (6321, 6324), False, 'import sys\n'), ((7613, 7625), 'math.exp', 'math.exp', (['x7'], {}), '(x7)\n', (7621, 7625), False, 'import ... |
#!/usr/bin/env python
#
# Check trace components in FreeType 2 source.
# Author: <NAME>, 2009, 2013
#
# This code is explicitly into the public domain.
import sys
import os
import re
SRC_FILE_LIST = []
USED_COMPONENT = {}
KNOWN_COMPONENT = {}
SRC_FILE_DIRS = ["src"]
TRACE_DEF_FILES = ["include/freetype/internal/ftt... | [
"os.path.basename",
"os.walk",
"os.path.join",
"re.compile"
] | [((1658, 1698), 're.compile', 're.compile', (['"""^.*\\\\.[ch]$"""', 're.IGNORECASE'], {}), "('^.*\\\\.[ch]$', re.IGNORECASE)\n", (1668, 1698), False, 'import re\n'), ((1714, 1772), 're.compile', 're.compile', (['"""^[ \t]*#define[ \t]+FT_COMPONENT[ \t]+trace_"""'], {}), "('^[ \\t]*#define[ \\t]+FT_COMPONENT[ \\t]+trac... |
import os
import torch
import utils
import torchvision.transforms as T
from torch.utils import data
from PIL import Image
#定义自己的数据集合
class MyDataSet(data.Dataset):
def __init__(self,root,transform):
# 所有图片的绝对路径
imgs=os.listdir(root)
self.imgs=[os.path.join(root,k) for k in imgs]
sel... | [
"torch.utils.data.DataLoader",
"utils.get_saleincy_2channel",
"PIL.Image.open",
"torchvision.transforms.ToTensor",
"torchvision.transforms.Compose",
"torchvision.transforms.Grayscale",
"torchvision.transforms.Normalize",
"os.path.join",
"os.listdir",
"torchvision.transforms.Resize"
] | [((1995, 2013), 'torchvision.transforms.Compose', 'T.Compose', (['compose'], {}), '(compose)\n', (2004, 2013), True, 'import torchvision.transforms as T\n'), ((2192, 2219), 'torchvision.transforms.Compose', 'T.Compose', (['compose_saliency'], {}), '(compose_saliency)\n', (2201, 2219), True, 'import torchvision.transfor... |
# -*- coding: utf-8 -*-
# preggy assertions
# https://github.com/heynemann/preggy
# Licensed under the MIT license:
# http://www.opensource.org/licenses/mit-license
# Copyright (c) 2013 <NAME> <EMAIL>
from preggy import expect
#-----------------------------------------------------------------------------
def test_... | [
"preggy.expect"
] | [((338, 350), 'preggy.expect', 'expect', (['None'], {}), '(None)\n', (344, 350), False, 'from preggy import expect\n'), ((581, 600), 'preggy.expect', 'expect', (['"""something"""'], {}), "('something')\n", (587, 600), False, 'from preggy import expect\n'), ((382, 394), 'preggy.expect', 'expect', (['None'], {}), '(None)... |
"""Test dtool_lookup_server.utils.dataset_info_is_valid helper function."""
# Minimum data required to register a dataset.
INFO = {
"uuid": "af6727bf-29c7-43dd-b42f-a5d7ede28337",
"type": "dataset",
"uri": "file:///tmp/a_dataset",
"name": "my-dataset",
"readme": {"description": "test dataset"},
... | [
"dtool_lookup_server.utils.dataset_info_is_valid"
] | [((778, 805), 'dtool_lookup_server.utils.dataset_info_is_valid', 'dataset_info_is_valid', (['info'], {}), '(info)\n', (799, 805), False, 'from dtool_lookup_server.utils import dataset_info_is_valid\n'), ((1270, 1297), 'dtool_lookup_server.utils.dataset_info_is_valid', 'dataset_info_is_valid', (['info'], {}), '(info)\n'... |
from django.contrib import admin
from .models import Activity, Fitbit
class ActivityAdmin(admin.ModelAdmin):
fieldsets = [
('Date Information', {'fields': ['entry_date']}),
('Fitbit Data', {'fields': ['steps', 'distance'], 'classes' : ['collapse']}),
]
list_display = ('entry_date' , 'steps', 'distance')
class... | [
"django.contrib.admin.site.register"
] | [((640, 669), 'django.contrib.admin.site.register', 'admin.site.register', (['Activity'], {}), '(Activity)\n', (659, 669), False, 'from django.contrib import admin\n'), ((670, 697), 'django.contrib.admin.site.register', 'admin.site.register', (['Fitbit'], {}), '(Fitbit)\n', (689, 697), False, 'from django.contrib impor... |
import logging
import os
import sys
import tempfile
from contextlib import contextmanager
from typing import Callable, Dict, List, Optional, Type, Union
import pytest
from pydantic import BaseSettings, validator
from selenium import webdriver
from .browser import BrowserError, BrowserRecorder, Chrome, Remote
from .mo... | [
"tempfile.NamedTemporaryFile",
"logging.error",
"os.remove",
"os.makedirs",
"os.getcwd",
"pytest.hookimpl",
"os.path.dirname",
"pytest.fixture",
"os.path.exists",
"os.environ.get",
"pydantic.validator",
"selenium.webdriver.ChromeOptions",
"os.path.join",
"os.listdir",
"logging.getLogger"... | [((486, 513), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (503, 513), False, 'import logging\n'), ((2391, 2436), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""', 'autouse': '(True)'}), "(scope='session', autouse=True)\n", (2405, 2436), False, 'import pytest\n'), ((27... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (c) University of St Andrews 2020-2021
# (c) University of Strathclyde 2020-2021
# (c) James Hutton Institute 2020-2021
#
# Author:
# <NAME>
#
# Contact
# <EMAIL>
#
# <NAME>,
# Biomolecular Sciences Building,
# University of St Andrews,
# <NAME>,
# St And... | [
"pathlib.Path"
] | [((2179, 2194), 'pathlib.Path', 'Path', (['directory'], {}), '(directory)\n', (2183, 2194), False, 'from pathlib import Path\n'), ((3718, 3733), 'pathlib.Path', 'Path', (['directory'], {}), '(directory)\n', (3722, 3733), False, 'from pathlib import Path\n')] |
import tensorflow as tf
loss_object = tf.keras.losses.SparseCategoricalCrossentropy(
from_logits=True)
def loss_function(real, pred):
mask = tf.math.logical_not(tf.math.equal(real, 0))
loss_ = loss_object(real, pred)
mask = tf.cast(mask, dtype=loss_.dtype)
loss_ *= mask
return tf.reduce_sum(loss_)... | [
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.reduce_sum",
"tensorflow.math.logical_and",
"tensorflow.argmax",
"tensorflow.math.equal",
"tensorflow.cast"
] | [((39, 102), 'tensorflow.keras.losses.SparseCategoricalCrossentropy', 'tf.keras.losses.SparseCategoricalCrossentropy', ([], {'from_logits': '(True)'}), '(from_logits=True)\n', (84, 102), True, 'import tensorflow as tf\n'), ((241, 273), 'tensorflow.cast', 'tf.cast', (['mask'], {'dtype': 'loss_.dtype'}), '(mask, dtype=lo... |
import numpy as np
from numba import cuda, float32
import time
@cuda.jit
def matmul(A, B, C):
"""Perform square matrix multiplication of C = A * B
"""
i, j = cuda.grid(2)
if i < C.shape[0] and j < C.shape[1]:
tmp = 0.
for k in range(A.shape[1]):
tmp += A[i, k] * B[k, j]
... | [
"numba.cuda.grid",
"time.time"
] | [((360, 371), 'time.time', 'time.time', ([], {}), '()\n', (369, 371), False, 'import time\n'), ((405, 416), 'time.time', 'time.time', ([], {}), '()\n', (414, 416), False, 'import time\n'), ((172, 184), 'numba.cuda.grid', 'cuda.grid', (['(2)'], {}), '(2)\n', (181, 184), False, 'from numba import cuda, float32\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import urllib.request
import urllib.parse
import sys
from datetime import datetime
url = 'http://zzzzzz/api/upload.php'
def sendmessage(message):
print(message)
params = urllib.parse.urlencode(message)
params = params.encode("ascii")
req = urllib.reques... | [
"datetime.datetime.now"
] | [((630, 644), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (642, 644), False, 'from datetime import datetime\n')] |
import numpy as np
def time_between_values(df, cols):
gap_df = df[cols].dropna(how='any')
return gap_df.index.to_series().diff(-1).dt.total_seconds().abs()
def distance_to_monitor(df):
dist = np.sqrt(
df.left_gaze_origin_in_user_coordinate_system_x ** 2
+ df.left_gaze_origin_in_user_coor... | [
"numpy.sqrt"
] | [((208, 389), 'numpy.sqrt', 'np.sqrt', (['(df.left_gaze_origin_in_user_coordinate_system_x ** 2 + df.\n left_gaze_origin_in_user_coordinate_system_y ** 2 + df.\n left_gaze_origin_in_user_coordinate_system_z ** 2)'], {}), '(df.left_gaze_origin_in_user_coordinate_system_x ** 2 + df.\n left_gaze_origin_in_user_co... |
import pandas as pd
from mindsdb.api.mysql.mysql_proxy.datahub.datanodes.datanode import DataNode
class IntegrationDataNode(DataNode):
type = 'integration'
def __init__(self, integration_name, data_store):
self.integration_name = integration_name
self.data_store = data_store
def get_typ... | [
"pandas.core.dtypes.common.is_datetime_or_timedelta_dtype"
] | [((839, 912), 'pandas.core.dtypes.common.is_datetime_or_timedelta_dtype', 'pd.core.dtypes.common.is_datetime_or_timedelta_dtype', (['dso.df[column_name]'], {}), '(dso.df[column_name])\n', (891, 912), True, 'import pandas as pd\n')] |
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under t... | [
"tacker_horizon.openstack_dashboard.api.tacker.delete_vnffg",
"horizon.messages.error",
"django.utils.translation.pgettext_lazy",
"horizon.tables.Column",
"django.utils.translation.ungettext_lazy",
"django.utils.translation.ugettext_lazy",
"tacker_horizon.openstack_dashboard.api.tacker.get_vnffg"
] | [((3426, 3443), 'django.utils.translation.ugettext_lazy', '_', (['"""Deploy VNFFG"""'], {}), "('Deploy VNFFG')\n", (3427, 3443), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((8015, 8101), 'horizon.tables.Column', 'tables.Column', (['"""status"""'], {'hidden': '(False)', 'status': '(True)', 'stat... |
import torch
import Config
class Buffer:
# Since the enviroment we use has multiple agents that work in parallel and PPO requires to store whole episodes in
# buffer so the advantage can be calculated, each agent will have separate episode buffer in which will store each
# step of only its episode.... | [
"torch.zeros",
"torch.Tensor",
"torch.cuda.is_available",
"torch.from_numpy"
] | [((524, 549), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (547, 549), False, 'import torch\n'), ((2530, 2551), 'torch.from_numpy', 'torch.from_numpy', (['obs'], {}), '(obs)\n', (2546, 2551), False, 'import torch\n'), ((3125, 3146), 'torch.from_numpy', 'torch.from_numpy', (['obs'], {}), '(obs... |
import os
from concurrent.futures import ProcessPoolExecutor
import itertools
import yaml
import sys
import copy
import numpy as np
import pandas as pd
from lib.constants import *
from lib.utils import *
TOP_N = 15
loader = yaml.SafeLoader
loader.add_implicit_resolver(
u'tag:yaml.org,2002:float',
re.compile(u... | [
"pandas.DataFrame",
"yaml.load",
"pandas.option_context",
"copy.copy",
"pandas.set_option",
"pandas.to_numeric"
] | [((895, 922), 'yaml.load', 'yaml.load', (['f'], {'Loader': 'loader'}), '(f, Loader=loader)\n', (904, 922), False, 'import yaml\n'), ((1358, 1416), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': '[keys[-1] for keys in keys_to_value]'}), '(columns=[keys[-1] for keys in keys_to_value])\n', (1370, 1416), True, 'impor... |
from Main_algorithm_GCN.CR_MGC import CR_MGC
from Configurations import *
import matplotlib.pyplot as plt
from copy import deepcopy
from torch.optim import Adam
import Utils
# the range of the number of remained UAVs
meta_type = [i for i in range(2, 201)]
print("Meta Learning Starts...")
print("----------------------... | [
"matplotlib.pyplot.xlim",
"copy.deepcopy",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.ylim",
"Utils.check_if_a_connected_graph",
"matplotlib.pyplot.close",
"Main_algorithm_GCN.CR_MGC.CR_MGC",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.savefig"
] | [((378, 386), 'Main_algorithm_GCN.CR_MGC.CR_MGC', 'CR_MGC', ([], {}), '()\n', (384, 386), False, 'from Main_algorithm_GCN.CR_MGC import CR_MGC\n'), ((772, 780), 'Main_algorithm_GCN.CR_MGC.CR_MGC', 'CR_MGC', ([], {}), '()\n', (778, 780), False, 'from Main_algorithm_GCN.CR_MGC import CR_MGC\n'), ((1669, 1736), 'Utils.che... |
#!/usr/bin/env python
__author__ = '<NAME>'
import os
import argparse
import yaml
from collections import namedtuple
import logging
from wielder.util.arguer import LogLevel, convert_log_level
from wielder.util.log_util import setup_logging
class Conf:
def __init__(self):
self.template_ignore_dirs = [... | [
"yaml.load",
"logging.debug",
"argparse.ArgumentParser",
"logging.basicConfig",
"os.path.realpath",
"logging.info",
"wielder.util.log_util.setup_logging",
"wielder.util.arguer.convert_log_level"
] | [((628, 705), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Data Orchestration Reactive Framework."""'}), "(description='Data Orchestration Reactive Framework.')\n", (651, 705), False, 'import argparse\n'), ((3613, 3650), 'wielder.util.arguer.convert_log_level', 'convert_log_level', (['... |
"""Kernels for advecting particles in Parcels"""
from parcels import (JITParticle, Variable)
import numpy as np
class unbeachableBoundedParticle(JITParticle):
# Beaching dynamics from https://github.com/OceanParcels/Parcelsv2.0PaperNorthSeaScripts
# beached : 0 sea, 1 beached, 2 after non-beach... | [
"parcels.Variable"
] | [((380, 428), 'parcels.Variable', 'Variable', (['"""beached"""'], {'dtype': 'np.int32', 'initial': '(0.0)'}), "('beached', dtype=np.int32, initial=0.0)\n", (388, 428), False, 'from parcels import JITParticle, Variable\n'), ((451, 504), 'parcels.Variable', 'Variable', (['"""unbeachCount"""'], {'dtype': 'np.int32', 'init... |
import click
import configparser
import hmac
import os
from flask import Flask
from flask import request
from flask import render_template
from .ghia_patterns import GhiaPatterns
from .ghia_requests import GhiaRequests
from .ghia_issue import Issue
BAD_REQUEST = 400
ALLOWED_ACTIONS = ["opened", "edited", "transferred"... | [
"click.BadParameter",
"flask.request.headers.get",
"flask.Flask",
"flask.request.get_json",
"flask.request.get_data",
"flask.render_template",
"configparser.ConfigParser",
"os.getenv"
] | [((420, 444), 'os.getenv', 'os.getenv', (['"""GHIA_CONFIG"""'], {}), "('GHIA_CONFIG')\n", (429, 444), False, 'import os\n'), ((742, 769), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (767, 769), False, 'import configparser\n'), ((1522, 1537), 'flask.Flask', 'Flask', (['__name__'], {}), '(... |
import numpy as np
from datetime import datetime
from astropy.io import ascii
from astropy.time import Time
from argparse import ArgumentParser
from antares_client.search import search, download
def build_query(ra0, dec0, fov, date):
"""Generate a query (a Python dictionary) to submit to the ANTARES client.
... | [
"numpy.radians",
"antares_client.search.download",
"datetime.datetime.today",
"argparse.ArgumentParser",
"astropy.time.Time"
] | [((1882, 1898), 'datetime.datetime.today', 'datetime.today', ([], {}), '()\n', (1896, 1898), False, 'from datetime import datetime\n'), ((1913, 1979), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Client API to query ANTARES alert DB"""'}), "(description='Client API to query ANTARES alert DB')\n... |
"""
Creates a MobileNetV2 Model as defined in:
<NAME>, <NAME>, <NAME>, <NAME>, <NAME>. (2018).
MobileNetV2: Inverted Residuals and Linear Bottlenecks
arXiv preprint arXiv:1801.04381.
import from https://github.com/tonylins/pytorch-mobilenet-v2
"""
import torch.nn as nn
import math
import torch
from . import my_op
__... | [
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.ReLU6",
"math.sqrt",
"torch.nn.Sequential",
"torch.load",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d",
"torch.nn.Linear",
"torch.zeros"
] | [((1058, 1103), 'torch.nn.Conv2d', 'nn.Conv2d', (['inp', 'oup', '(3)', 'stride', '(1)'], {'bias': '(False)'}), '(inp, oup, 3, stride, 1, bias=False)\n', (1067, 1103), True, 'import torch.nn as nn\n'), ((1113, 1132), 'torch.nn.BatchNorm2d', 'nn.BatchNorm2d', (['oup'], {}), '(oup)\n', (1127, 1132), True, 'import torch.nn... |