code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from django.shortcuts import render, redirect, get_object_or_404
from .models import Guide
def measureguides(request):
guides = Guide.objects.all()
return render(request, 'measureguides.html', {'guides' : guides})
| [
"django.shortcuts.render"
] | [((164, 221), 'django.shortcuts.render', 'render', (['request', '"""measureguides.html"""', "{'guides': guides}"], {}), "(request, 'measureguides.html', {'guides': guides})\n", (170, 221), False, 'from django.shortcuts import render, redirect, get_object_or_404\n')] |
from unittest import TestCase
from mockredis import MockRedis
from datetime import datetime
from cartodb_services.refactor.service.mapzen_geocoder_config import *
from cartodb_services.refactor.storage.redis_config import *
from cartodb_services.refactor.storage.mem_config import InMemoryConfigStorage
class TestMapze... | [
"datetime.datetime.strptime",
"mockredis.MockRedis",
"cartodb_services.refactor.storage.mem_config.InMemoryConfigStorage"
] | [((406, 417), 'mockredis.MockRedis', 'MockRedis', ([], {}), '()\n', (415, 417), False, 'from mockredis import MockRedis\n'), ((448, 659), 'cartodb_services.refactor.storage.mem_config.InMemoryConfigStorage', 'InMemoryConfigStorage', (["{'server_conf': {'environment': 'testing'}, 'mapzen_conf': {'geocoder': {\n 'api_... |
import sys
import time
import threading
import socket
import serial
class Proxy(object):
"""
"""
def __init__(self):
self._is_started = False
self._serial_send_port = None
self._udp_send_ip = None
self._udp_send_port = None
def serial_connect(self... | [
"serial.Serial",
"threading.Thread",
"socket.socket",
"time.sleep"
] | [((414, 457), 'serial.Serial', 'serial.Serial', ([], {'port': 'port', 'baudrate': 'baudrate'}), '(port=port, baudrate=baudrate)\n', (427, 457), False, 'import serial\n'), ((523, 569), 'threading.Thread', 'threading.Thread', ([], {'target': 'self._serial_receiver'}), '(target=self._serial_receiver)\n', (539, 569), False... |
# -*- coding: utf-8 -*-
# Created on Sun Feb 23 16:02:31 2020
# @author: arthurd
import os
import pandas as pd
import torch
from torchtext import data
class SST(data.Dataset):
"""
Stanford Sentiment Treebank dataset.
Reads in the train and dev sets of the dataset.
Preprocesses fields where necessary... | [
"torchtext.data.RawField",
"os.mkdir",
"os.path.exists",
"torchtext.data.LabelField",
"pandas.read_table",
"torchtext.data.Example.fromlist",
"torchtext.data.BucketIterator.splits",
"torchtext.data.Field"
] | [((946, 961), 'torchtext.data.RawField', 'data.RawField', ([], {}), '()\n', (959, 961), False, 'from torchtext import data\n'), ((1043, 1058), 'torchtext.data.RawField', 'data.RawField', ([], {}), '()\n', (1056, 1058), False, 'from torchtext import data\n'), ((1079, 1094), 'torchtext.data.RawField', 'data.RawField', ([... |
#python libraries
import random
from string import ascii_letters, digits
from itertools import repeat
#from time import sleep
# apetools libraries
from apetools.baseclass import BaseClass
EMPTY_STRING = ''
class ChangePrompt(BaseClass):
"""
Changes a prompt.
"""
def __init__(self, adapter, length=10... | [
"random.choice",
"itertools.repeat"
] | [((1073, 1101), 'random.choice', 'random.choice', (['ascii_letters'], {}), '(ascii_letters)\n', (1086, 1101), False, 'import random\n'), ((1151, 1172), 'random.choice', 'random.choice', (['source'], {}), '(source)\n', (1164, 1172), False, 'import random\n'), ((1183, 1212), 'itertools.repeat', 'repeat', (['None', '(self... |
import datetime
import ipaddress
from itertools import chain
from pathlib import Path
import sqlite3
from .log_reader import BroLogReader
sqlite3.register_adapter(datetime.timedelta, lambda x: x.total_seconds())
sqlite3.register_adapter(ipaddress.IPv4Address, lambda x: str(x))
sqlite3.register_adapter(ipaddress.IPv6... | [
"pathlib.Path",
"sqlite3.connect",
"itertools.chain"
] | [((595, 608), 'pathlib.Path', 'Path', (['log_dir'], {}), '(log_dir)\n', (599, 608), False, 'from pathlib import Path\n'), ((620, 645), 'sqlite3.connect', 'sqlite3.connect', (['database'], {}), '(database)\n', (635, 645), False, 'import sqlite3\n'), ((1190, 1214), 'itertools.chain', 'chain', (['(first,)', 'records'], {}... |
from django.contrib import admin
# Register your models here.
from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.models import User
from ats_profiles.models import UserProfile, Tag, UserProfileAttachedFile
class UserInline(admin.StackedInline):
model = User... | [
"django.contrib.admin.site.register",
"django.contrib.admin.site.unregister"
] | [((478, 505), 'django.contrib.admin.site.unregister', 'admin.site.unregister', (['User'], {}), '(User)\n', (499, 505), False, 'from django.contrib import admin\n'), ((506, 549), 'django.contrib.admin.site.register', 'admin.site.register', (['User', 'UserProfileAdmin'], {}), '(User, UserProfileAdmin)\n', (525, 549), Fal... |
import os
from os import listdir
from os.path import isfile, join
from django.core.management import BaseCommand
from django.core.management import call_command
from django.db import connection
class Command(BaseCommand):
"""
Как пользоваться?
1) На локале запускаем скрипт, он удалит все старые файлы миг... | [
"os.path.exists",
"django.db.connection.cursor",
"django.core.management.call_command",
"os.path.join",
"os.listdir"
] | [((764, 783), 'django.db.connection.cursor', 'connection.cursor', ([], {}), '()\n', (781, 783), False, 'from django.db import connection\n'), ((1279, 1310), 'os.path.join', 'os.path.join', (['app', '"""migrations"""'], {}), "(app, 'migrations')\n", (1291, 1310), False, 'import os\n'), ((1322, 1352), 'os.path.exists', '... |
# -*- coding: utf-8 -*-
"""
Created on Tue Jan 8 09:24:07 2019
@author: madsa
"""
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
import numpy as np
import matplotlib
import pickle
import matplotlib.tri a... | [
"matplotlib.pyplot.figure",
"pickle.load",
"matplotlib.pyplot.show",
"numpy.meshgrid"
] | [((436, 459), 'pickle.load', 'pickle.load', (['pickleFile'], {}), '(pickleFile)\n', (447, 459), False, 'import pickle\n'), ((582, 594), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (592, 594), True, 'import matplotlib.pyplot as plt\n'), ((653, 670), 'numpy.meshgrid', 'np.meshgrid', (['x', 'y'], {}), '(x,... |
# -*- coding:utf-8 -*-
# ---------------------------------------------
# @file JSON
# @description JSON
# @author WcJun
# @date 2021/08/02
# ---------------------------------------------
import json
class JSON(object):
"""
utilities function of JSON.
"""
@staticmethod
def transferObject(body: o... | [
"json.loads",
"json.dumps"
] | [((461, 477), 'json.dumps', 'json.dumps', (['body'], {}), '(body)\n', (471, 477), False, 'import json\n'), ((679, 700), 'json.dumps', 'json.dumps', (['dict_body'], {}), '(dict_body)\n', (689, 700), False, 'import json\n'), ((903, 924), 'json.dumps', 'json.dumps', (['dict_body'], {}), '(dict_body)\n', (913, 924), False,... |
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.accordion import Accordion, AccordionItem
class minha_lista(App):
def build(self):
lista = Accordion()
item = AccordionItem(title = 'Amor', background_normal = 'cores.jpg', background_selected = 'um-video-super-legal-com-imagens-do-por-do-... | [
"kivy.uix.accordion.AccordionItem",
"kivy.uix.label.Label",
"kivy.uix.accordion.Accordion"
] | [((167, 178), 'kivy.uix.accordion.Accordion', 'Accordion', ([], {}), '()\n', (176, 178), False, 'from kivy.uix.accordion import Accordion, AccordionItem\n'), ((191, 344), 'kivy.uix.accordion.AccordionItem', 'AccordionItem', ([], {'title': '"""Amor"""', 'background_normal': '"""cores.jpg"""', 'background_selected': '"""... |
import Image, ImageDraw, scene
def diagonalLineImage(inLength = 200, inColors = ('blue', 'ivory')):
imageLength = inLength + 100 # the image can be larger than what you draw
theImage = Image.new('RGBA', (imageLength, imageLength), inColors[1])
draw = ImageDraw.Draw(theImage)
draw.line((0, 0, inLength,... | [
"ImageDraw.Draw",
"Image.new",
"scene.Rect",
"scene.load_pil_image",
"scene.background",
"scene.run"
] | [((195, 253), 'Image.new', 'Image.new', (['"""RGBA"""', '(imageLength, imageLength)', 'inColors[1]'], {}), "('RGBA', (imageLength, imageLength), inColors[1])\n", (204, 253), False, 'import Image, ImageDraw, scene\n'), ((265, 289), 'ImageDraw.Draw', 'ImageDraw.Draw', (['theImage'], {}), '(theImage)\n', (279, 289), False... |
import cv2
class ExtractArtworkROI(object):
def __init__(self):
# Load image
self.original_image = cv2.imread('1.png')
self.clone = self.original_image.copy()
cv2.namedWindow('image')
cv2.setMouseCallback('image', self.extractROI)
self.selected_ROI = False
#... | [
"cv2.waitKey",
"cv2.imwrite",
"cv2.destroyAllWindows",
"cv2.imread",
"cv2.setMouseCallback",
"cv2.rectangle",
"cv2.imshow",
"cv2.namedWindow"
] | [((120, 139), 'cv2.imread', 'cv2.imread', (['"""1.png"""'], {}), "('1.png')\n", (130, 139), False, 'import cv2\n'), ((196, 220), 'cv2.namedWindow', 'cv2.namedWindow', (['"""image"""'], {}), "('image')\n", (211, 220), False, 'import cv2\n'), ((229, 275), 'cv2.setMouseCallback', 'cv2.setMouseCallback', (['"""image"""', '... |
from rest_framework.views import APIView
# To return responses form API views
from rest_framework.response import Response
# List of HTTP state codes that can be used when returning responses
from rest_framework import status
from rest_framework import viewsets
# Generate a random token
from rest_framework.authentica... | [
"rest_framework.response.Response",
"profiles_api.models.UserProfile.objects.all",
"profiles_api.models.ProfileFeedItem.objects.all"
] | [((4432, 4464), 'profiles_api.models.UserProfile.objects.all', 'models.UserProfile.objects.all', ([], {}), '()\n', (4462, 4464), False, 'from profiles_api import models\n'), ((5337, 5373), 'profiles_api.models.ProfileFeedItem.objects.all', 'models.ProfileFeedItem.objects.all', ([], {}), '()\n', (5371, 5373), False, 'fr... |
# coding: utf-8
"""
LogicMonitor REST API
LogicMonitor is a SaaS-based performance monitoring platform that provides full visibility into complex, hybrid infrastructures, offering granular performance monitoring and actionable data and insights. logicmonitor_sdk enables you to manage your LogicMonitor account... | [
"six.iteritems"
] | [((11703, 11736), 'six.iteritems', 'six.iteritems', (['self.swagger_types'], {}), '(self.swagger_types)\n', (11716, 11736), False, 'import six\n')] |
import os
import re
import sys
import zipfile
from generator3.core import walk_python_path
from generator3.util_methods import is_text_file, say, report
def is_source_file(path):
# Skip directories, character and block special devices, named pipes
# Do not skip regular files and symbolic links to regular fil... | [
"os.path.samefile",
"os.path.isfile",
"sys.stdout.flush",
"os.path.join",
"sys.stdin.readline",
"os.path.sep.join",
"traceback.print_exc",
"os.path.exists",
"generator3.core.walk_python_path",
"os.path.normpath",
"generator3.util_methods.is_text_file",
"os.path.getsize",
"generator3.util_met... | [((1097, 1115), 'generator3.util_methods.is_text_file', 'is_text_file', (['path'], {}), '(path)\n', (1109, 1115), False, 'from generator3.util_methods import is_text_file, say, report\n'), ((334, 354), 'os.path.isfile', 'os.path.isfile', (['path'], {}), '(path)\n', (348, 354), False, 'import os\n'), ((1701, 1711), 'gen... |
'''
Copyright 2018 - LC
This file is part of webshscr.
webshscr 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 later version.
webshscr is distributed in... | [
"utils.load_properties"
] | [((801, 848), 'utils.load_properties', 'load_properties', (["(config_dir + '/' + CONFIG_FILE)"], {}), "(config_dir + '/' + CONFIG_FILE)\n", (816, 848), False, 'from utils import load_properties\n')] |
from joke.jokes import *
# This will import all joke-functions (geek, icanhazdad, chucknorris, icndb)
# Now you can use them to get some jokes.
all_jokes = [geek, icanhazdad, chucknorris, icndb]
# For example you can display 10 Chuck Norris jokes.
for i in range(10):
print(chucknorris())
# Or get a random joke-fu... | [
"random.choice"
] | [((360, 406), 'random.choice', 'choice', (['[geek, icanhazdad, chucknorris, icndb]'], {}), '([geek, icanhazdad, chucknorris, icndb])\n', (366, 406), False, 'from random import choice\n')] |
from flask import (
current_app as app,
render_template,
request,
redirect,
url_for,
session,
Blueprint,
)
from itsdangerous.exc import BadTimeSignature, SignatureExpired, BadSignature
from CTFd.models import db, Users, Teams
from CTFd.utils import get_config, get_app_config
from CTFd.util... | [
"flask_restplus.Namespace"
] | [((1731, 1771), 'flask_restplus.Namespace', 'Namespace', (['"""auths"""'], {'description': '"""考虑如何登陆"""'}), "('auths', description='考虑如何登陆')\n", (1740, 1771), False, 'from flask_restplus import Namespace, Resource\n')] |
# coding: utf-8
from kerasy.ML.cluster import DBSCAN
from kerasy.utils import generateWholeCakes
from kerasy.utils import cluster_accuracy
num_clusters = 3
num_samples = 300
def get_test_data():
x_train, y_train = generateWholeCakes(num_classes=num_clusters*2,
num_samples... | [
"kerasy.utils.generateWholeCakes",
"kerasy.ML.cluster.DBSCAN",
"kerasy.utils.cluster_accuracy"
] | [((220, 360), 'kerasy.utils.generateWholeCakes', 'generateWholeCakes', ([], {'num_classes': '(num_clusters * 2)', 'num_samples': '(num_samples * 2)', 'r_low': '(3)', 'r_high': '(10)', 'add_noise': '(False)', 'same': '(True)', 'seed': '(123)'}), '(num_classes=num_clusters * 2, num_samples=num_samples * \n 2, r_low=3,... |
from django.contrib import admin
from paymentSystem.models import PromoCode, Tickets
# Register your models here.
admin.site.register(PromoCode)
admin.site.register(Tickets) | [
"django.contrib.admin.site.register"
] | [((115, 145), 'django.contrib.admin.site.register', 'admin.site.register', (['PromoCode'], {}), '(PromoCode)\n', (134, 145), False, 'from django.contrib import admin\n'), ((146, 174), 'django.contrib.admin.site.register', 'admin.site.register', (['Tickets'], {}), '(Tickets)\n', (165, 174), False, 'from django.contrib i... |
import os, json
def readfile(filename, mode = 'r'):
if not os.path.exists(filename):
return False
fp = open(filename, mode)
f_body = fp.read()
fp.close()
return f_body
def writefile(filename, body, mode = 'w+'):
try:
fp = open(filename, mode);
fp.write(body)
fp.c... | [
"os.path.exists"
] | [((63, 87), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (77, 87), False, 'import os, json\n')] |
from types import SimpleNamespace
import pytest
from reader._types import entry_data_from_obj
from reader._types import EntryData
from reader._types import FeedData
from reader._types import fix_datetime_tzinfo
from reader._types import tag_filter_argument
TAG_DATA = [
([], [None, [], (), [[]], ((),), [[], []]]... | [
"reader._types.fix_datetime_tzinfo",
"reader._types.tag_filter_argument",
"pytest.raises",
"types.SimpleNamespace",
"pytest.mark.parametrize",
"reader._types.entry_data_from_obj"
] | [((971, 1028), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""input, expected"""', 'TAG_DATA_FLAT'], {}), "('input, expected', TAG_DATA_FLAT)\n", (994, 1028), False, 'import pytest\n'), ((1565, 1623), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""input, error"""', 'TAG_DATA_BAD_FLAT'], {}), "... |
# !/usr/bin/env python
# -*-coding:utf-8 -*-
# PROJECT : project-structure-collections
# Time ：2020/12/8 15:16
# Warning ：The Hard Way Is Easier
from celery import Celery
"""
TIP:
- 当前文件夹必须命名为celery，才能启动成功。
- include = ["moduleName.pyName"]
启动命令：
在 celery_docx 目录下：
celery -A demo1 worker -c 2 -l INFO
cel... | [
"celery.Celery"
] | [((380, 502), 'celery.Celery', 'Celery', (['"""module_name"""'], {'broker': '"""redis://localhost:6379/0"""', 'backend': '"""redis://localhost:6379/0"""', 'include': "['demo1.tasks']"}), "('module_name', broker='redis://localhost:6379/0', backend=\n 'redis://localhost:6379/0', include=['demo1.tasks'])\n", (386, 502)... |
import pytest
from users.signals import warn_insecure
@pytest.mark.django_db
def test_warn_insecure_emits_a_warning_when_no_user_exists(recwarn):
# When
warn_insecure(None)
# Then
assert len(recwarn) == 1
w = recwarn.pop()
assert issubclass(w.category, RuntimeWarning)
@pytest.mark.django_d... | [
"users.signals.warn_insecure"
] | [((164, 183), 'users.signals.warn_insecure', 'warn_insecure', (['None'], {}), '(None)\n', (177, 183), False, 'from users.signals import warn_insecure\n'), ((416, 435), 'users.signals.warn_insecure', 'warn_insecure', (['None'], {}), '(None)\n', (429, 435), False, 'from users.signals import warn_insecure\n')] |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file './UI/nine_patch.ui',
# licensing of './UI/nine_patch.ui' applies.
#
# Created: Mon May 27 11:56:54 2019
# by: pyside2-uic running on PySide2 5.12.3
#
# WARNING! All changes made in this file will be lost!
from PySide2 import QtCore, Q... | [
"PySide2.QtCore.QSize",
"PySide2.QtCore.QMetaObject.connectSlotsByName",
"PySide2.QtWidgets.QTableWidget",
"PySide2.QtWidgets.QApplication.translate",
"PySide2.QtWidgets.QLabel",
"PySide2.QtGui.QIcon",
"PySide2.QtWidgets.QVBoxLayout",
"PySide2.QtWidgets.QSpinBox",
"PySide2.QtWidgets.QPushButton",
... | [((519, 532), 'PySide2.QtGui.QIcon', 'QtGui.QIcon', ([], {}), '()\n', (530, 532), False, 'from PySide2 import QtCore, QtGui, QtWidgets\n'), ((699, 736), 'PySide2.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', (['NinePatchFrame'], {}), '(NinePatchFrame)\n', (720, 736), False, 'from PySide2 import QtCore, QtGui, QtWidg... |
from __future__ import absolute_import
from pychron.globals import globalv
from pychron.core.ui import set_toolkit
set_toolkit('qt4')
from pychron.paths import paths
paths.build('_unittest')
#build_directories(paths)
from pychron.core.helpers.logger_setup import logging_setup
from pychron.lasers.laser_managers.fusi... | [
"pychron.paths.paths.build",
"pychron.core.helpers.logger_setup.logging_setup",
"pychron.lasers.laser_managers.fusions_diode_manager.FusionsDiodeManager",
"pychron.core.ui.set_toolkit"
] | [((116, 134), 'pychron.core.ui.set_toolkit', 'set_toolkit', (['"""qt4"""'], {}), "('qt4')\n", (127, 134), False, 'from pychron.core.ui import set_toolkit\n'), ((169, 193), 'pychron.paths.paths.build', 'paths.build', (['"""_unittest"""'], {}), "('_unittest')\n", (180, 193), False, 'from pychron.paths import paths\n'), (... |
# -----------------------------------------------------------------------------
# Copyright (c) 2014--, The qiita Development Team.
#
# Distributed under the terms of the BSD 3-clause License.
#
# The full license is in the file LICENSE, distributed with this software.
# ------------------------------------------------... | [
"tornado.web.Application.__init__",
"moi.group.get_id_from_user",
"tornado.options.parse_command_line",
"uuid.uuid4",
"tornado.ioloop.IOLoop.instance",
"moi.r_client.get",
"os.path.dirname",
"moi.group.create_info",
"time.sleep",
"moi.job.submit",
"tornado.escape.json_encode",
"tornado.options... | [((912, 980), 'tornado.options.define', 'define', (['"""port"""'], {'default': '(8886)', 'help': '"""run on the given port"""', 'type': 'int'}), "('port', default=8886, help='run on the given port', type=int)\n", (918, 980), False, 'from tornado.options import define, options, parse_command_line\n'), ((993, 1010), 'os.... |
# Copyright (c) 2014 Evalf
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, s... | [
"numpy.pad",
"numpy.dtype",
"numpy.array",
"numpy.zeros_like"
] | [((5611, 5629), 'numpy.dtype', 'numpy.dtype', (['""">i1"""'], {}), "('>i1')\n", (5622, 5629), False, 'import contextlib, numpy\n'), ((5640, 5658), 'numpy.dtype', 'numpy.dtype', (['""">u1"""'], {}), "('>u1')\n", (5651, 5658), False, 'import contextlib, numpy\n'), ((5681, 5699), 'numpy.dtype', 'numpy.dtype', (['""">i2"""... |
import requests
files = {'file': open('1.jpg', 'rb')}
r = requests.post(url, files=files)
print(r.text) | [
"requests.post"
] | [((60, 91), 'requests.post', 'requests.post', (['url'], {'files': 'files'}), '(url, files=files)\n', (73, 91), False, 'import requests\n')] |
import argparse
import os, sys
import yaml
import torch
import pytorch_lightning as pl
from pytorch_lightning.callbacks import ModelCheckpoint
# DEFAULTS used by the Trainer
checkpoint_callback = ModelCheckpoint(
filepath=os.getcwd(),
save_top_k=1,
verbose=True,
monitor='val_loss',
mode='min',
... | [
"sys.path.append",
"os.mkdir",
"pytorch_lightning.Trainer",
"argparse.ArgumentParser",
"sewer.datamodule.SewerDataModule",
"os.getcwd",
"os.path.exists",
"yaml.safe_load",
"celeba.datamodule.CelebaDataModule",
"os.path.join"
] | [((385, 415), 'sys.path.append', 'sys.path.append', (['"""../datasets"""'], {}), "('../datasets')\n", (400, 415), False, 'import os, sys\n'), ((1497, 1522), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1520, 1522), False, 'import argparse\n'), ((2262, 2376), 'pytorch_lightning.Trainer', 'pl.... |
# Generated by Django 3.0.7 on 2020-06-08 08:03
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('Torrents', '0014_auto_20200608_0801'),
]
operations = [
migrations.RenameField(
model_name='comments',
old_name='post_id',
... | [
"django.db.migrations.RenameField"
] | [((228, 315), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""comments"""', 'old_name': '"""post_id"""', 'new_name': '"""post"""'}), "(model_name='comments', old_name='post_id', new_name=\n 'post')\n", (250, 315), False, 'from django.db import migrations\n'), ((367, 454), 'djang... |
#! /usr/bin/env python
import requests
from utils import check_response
def upload(name,host,user,pswd,cert=None):
url = host.strip("/") + "/rest/blob"
files = {'blob':open(name, 'rb')}
r = requests.post(url, files=files, auth=(user, pswd), verify=cert)
result = check_response(r)
return result['han... | [
"requests.post",
"utils.check_response"
] | [((203, 266), 'requests.post', 'requests.post', (['url'], {'files': 'files', 'auth': '(user, pswd)', 'verify': 'cert'}), '(url, files=files, auth=(user, pswd), verify=cert)\n', (216, 266), False, 'import requests\n'), ((280, 297), 'utils.check_response', 'check_response', (['r'], {}), '(r)\n', (294, 297), False, 'from ... |
import json
from flask import Flask, request
def run_parrot_server(host_name: str = '0.0.0.0', port_num: int = 6976) -> None:
"""
Run a parrot server in a specific port. A parrot server says the same thing that it receives.
"""
app = Flask(__name__)
@app.route('/')
def index() -> str:
... | [
"flask.Flask",
"json.loads",
"flask.request.args.get"
] | [((252, 267), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (257, 267), False, 'from flask import Flask, request\n'), ((332, 359), 'flask.request.args.get', 'request.args.get', (['"""message"""'], {}), "('message')\n", (348, 359), False, 'from flask import Flask, request\n'), ((380, 404), 'flask.request.a... |
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Filename: csvs_to_plots.py
# @Author: <NAME>
# @Time: 8/12/21 10:03
import re
from os import walk
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
def main():
path = '../test_unlabeled/'
dataset = 'titanic'
files = next(... | [
"matplotlib.pyplot.show",
"pandas.read_csv",
"os.walk",
"re.findall",
"numpy.array",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.savefig"
] | [((1234, 1285), 'numpy.array', 'np.array', (['[acc_algorithms[x] for x, _ in order_acc]'], {}), '([acc_algorithms[x] for x, _ in order_acc])\n', (1242, 1285), True, 'import numpy as np\n'), ((1464, 1515), 'numpy.array', 'np.array', (['[mse_algorithms[x] for x, _ in order_mse]'], {}), '([mse_algorithms[x] for x, _ in or... |
import os
import hashlib
def touch_dirs(path_to_dir):
if not os.path.exists(path_to_dir):
os.makedirs(path_to_dir)
return path_to_dir
def get_id_from_bot_token(token):
return token.split(':')[0]
def list2solid(payload: list, els_to_remove: list = None):
result = []
fo... | [
"hashlib.md5",
"os.path.exists",
"os.makedirs"
] | [((1481, 1494), 'hashlib.md5', 'hashlib.md5', ([], {}), '()\n', (1492, 1494), False, 'import hashlib\n'), ((72, 99), 'os.path.exists', 'os.path.exists', (['path_to_dir'], {}), '(path_to_dir)\n', (86, 99), False, 'import os\n'), ((110, 134), 'os.makedirs', 'os.makedirs', (['path_to_dir'], {}), '(path_to_dir)\n', (121, 1... |
from tqdm.auto import tqdm
import numpy as np
import os
from glob import glob
import cv2
import sys
from fastai.vision.all import *
from fastai.vision import models
import torch
import matplotlib.pyplot as plt
import pandas as df
import json
sys.path.append('./')
sys.path.append('../')
from src.helper_factories import... | [
"sys.path.append",
"src.types.fluorescence_slide.FluorescenceSlide.fromFluorescenceSlides",
"src.helper_factories.get_inference_func"
] | [((243, 264), 'sys.path.append', 'sys.path.append', (['"""./"""'], {}), "('./')\n", (258, 264), False, 'import sys\n'), ((265, 287), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (280, 287), False, 'import sys\n'), ((1432, 1461), 'src.helper_factories.get_inference_func', 'get_inference_func',... |
import datetime
import tkinter.ttk as ttk
import webbrowser
from tkinter import *
from tkinter import messagebox
from zeroconf import ZeroConf
import psutil
import os
PROGRAM_NAME = "ScanPL-APP"
class ScanPlApp:
def __init__(self):
self.root = Tk()
self.root.geometry('600x400')
self.root... | [
"psutil.process_iter",
"os.path.dirname",
"tkinter.messagebox.showwarning",
"tkinter.messagebox.showinfo",
"webbrowser.open_new_tab",
"zeroconf.ZeroConf",
"datetime.datetime.strptime",
"tkinter.ttk.Treeview",
"os.path.join",
"tkinter.messagebox.showerror"
] | [((416, 441), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (431, 441), False, 'import os\n'), ((463, 497), 'os.path.join', 'os.path.join', (['base_folder', '"""icons"""'], {}), "(base_folder, 'icons')\n", (475, 497), False, 'import os\n'), ((4281, 4337), 'tkinter.ttk.Treeview', 'ttk.Treevie... |
import torch
def collate_fn(batch):
"""Collects together univariate or multivariate sequences into a single batch, arranged in descending order of length.
Also returns the corresponding lengths and labels as :class:`torch:torch.LongTensor` objects.
Parameters
----------
batch: list of tuple(torch... | [
"torch.zeros",
"torch.nn.utils.rnn.pad_sequence"
] | [((1675, 1735), 'torch.nn.utils.rnn.pad_sequence', 'torch.nn.utils.rnn.pad_sequence', (['sequences'], {'batch_first': '(True)'}), '(sequences, batch_first=True)\n', (1706, 1735), False, 'import torch\n'), ((1383, 1424), 'torch.zeros', 'torch.zeros', (['batch_size'], {'dtype': 'torch.long'}), '(batch_size, dtype=torch.l... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Created by <NAME>
21/06/2010
The package contains functions that affect the analysis of nominal groups
We return all elements of a nominal group
Functions:
is_an_adj : to know if a word is an adjective
adjective_pos : to return the position of the no... | [
"dialogs.resources_manager.ResourcePool"
] | [((1980, 1994), 'dialogs.resources_manager.ResourcePool', 'ResourcePool', ([], {}), '()\n', (1992, 1994), False, 'from dialogs.resources_manager import ResourcePool\n'), ((3226, 3240), 'dialogs.resources_manager.ResourcePool', 'ResourcePool', ([], {}), '()\n', (3238, 3240), False, 'from dialogs.resources_manager import... |
import unittest
from sklearnclassifiers.DecisionTreeClassifier import DecisionTreeClassifier
from sklearnclassifiers.SupportVectorMachine import SupportVectorMachine
from sklearnclassifiers.DatasetLoader import DatasetLoader
from sklearnclassifiers.PerceptronClassifier import PerceptronClassifier
from sklearnclassifie... | [
"sklearnclassifiers.DatasetLoader.DatasetLoader"
] | [((747, 791), 'sklearnclassifiers.DatasetLoader.DatasetLoader', 'DatasetLoader', ([], {'test_size': '(0.3)', 'random_state': '(0)'}), '(test_size=0.3, random_state=0)\n', (760, 791), False, 'from sklearnclassifiers.DatasetLoader import DatasetLoader\n'), ((969, 1013), 'sklearnclassifiers.DatasetLoader.DatasetLoader', '... |
# Goal:
# Connect to a SpikeSafe and run Pulsed mode into a LED, Laser, or electrical component for 10 seconds while obtaining readings
#
# Expectation:
# Channel 1 will be driven with 100mA with a forward voltage of <1V during this time
import sys
import time
import logging
from spikesafe_python.MemoryTableReadData... | [
"spikesafe_python.TcpSocket.TcpSocket",
"logging.basicConfig",
"spikesafe_python.ReadAllEvents.log_all_events",
"time.time",
"spikesafe_python.Threading.wait",
"spikesafe_python.MemoryTableReadData.log_memory_table_read",
"spikesafe_python.ReadAllEvents.read_until_event",
"sys.exit",
"logging.getLog... | [((798, 825), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (815, 825), False, 'import logging\n'), ((826, 992), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""SpikeSafePythonSamples.log"""', 'format': '"""%(asctime)s, %(levelname)s, %(message)s"""', 'datefmt': '"""%... |
import re
import random
def roll(string):
many_dices = re.split(r'\s\+\s', string)
print(many_dices)
dices = list()
modifier = list()
for i in many_dices:
dice = re.match(r'(\d+)d(\d+)', i)
try:
dices.append(dice.groups())
except AttributeError:
pass
... | [
"re.split",
"re.match",
"re.search"
] | [((60, 89), 're.split', 're.split', (['"""\\\\s\\\\+\\\\s"""', 'string'], {}), "('\\\\s\\\\+\\\\s', string)\n", (68, 89), False, 'import re\n'), ((191, 219), 're.match', 're.match', (['"""(\\\\d+)d(\\\\d+)"""', 'i'], {}), "('(\\\\d+)d(\\\\d+)', i)\n", (199, 219), False, 'import re\n'), ((334, 358), 're.search', 're.sea... |
# Copyright (c) 2016 <NAME>
from __future__ import division
from __future__ import print_function
from os.path import basename
from scipy.io import loadmat
import argparse
import glob
import re
import os.path
from config import *
def create_data(images_dir, joints_mat_path, transpose_order=(2, 0, 1)):
"""
... | [
"os.path.basename",
"argparse.ArgumentParser",
"scipy.io.loadmat"
] | [((463, 487), 'scipy.io.loadmat', 'loadmat', (['joints_mat_path'], {}), '(joints_mat_path)\n', (470, 487), False, 'from scipy.io import loadmat\n'), ((1781, 1806), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1804, 1806), False, 'import argparse\n'), ((1055, 1073), 'os.path.basename', 'basen... |
from sqlalchemy import desc
from sqlalchemy.sql import func
from db.entities.stage_statistics import StageStatisticsEntity
from db.entities.task import TaskEntity
from sparkscope_web.analyzers.analyzer import Analyzer
from db.entities.stage import StageEntity
from sparkscope_web.metrics.helpers import fmt_bytes, fmt_t... | [
"sparkscope_web.metrics.metric.StageFailureMetric",
"sparkscope_web.metrics.metric_details.MetricDetailsList",
"sparkscope_web.metrics.metric.StageSkewMetric",
"db.entities.stage_statistics.StageStatisticsEntity.bytes_written.label",
"sparkscope_web.metrics.helpers.fmt_bytes",
"sparkscope_web.metrics.metr... | [((4143, 4176), 'sparkscope_web.metrics.metric_details.MetricDetailsList', 'MetricDetailsList', ([], {'ascending': '(True)'}), '(ascending=True)\n', (4160, 4176), False, 'from sparkscope_web.metrics.metric_details import MetricDetailsList, MetricDetails\n'), ((7241, 7274), 'sparkscope_web.metrics.metric_details.MetricD... |
# Generated by Django 3.2 on 2021-06-30 13:40
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('rbBot', '0003_alter_user_latest'),
]
operations = [
migrations.AddField(
model_name='location',
name='route',
... | [
"django.db.models.ManyToManyField",
"django.db.models.BigIntegerField"
] | [((330, 370), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'to': '"""rbBot.Route"""'}), "(to='rbBot.Route')\n", (352, 370), False, 'from django.db import migrations, models\n'), ((490, 535), 'django.db.models.BigIntegerField', 'models.BigIntegerField', ([], {'blank': '(True)', 'null': '(True)'}),... |
#!/usr/bin/python3
import os
import re
import sys
import copy
#import urllib
import requests
import tempfile
from bs4 import BeautifulSoup
#base = 'https://ukrainaincognita.com'
base = 'https://ukrainaincognita.com/mista-ta-regiony/vinnytska-oblast'
#base = 'https://docs.python.org'
has_percent = re.compile(r'.*%.*')... | [
"tempfile.NamedTemporaryFile",
"os.mkdir",
"os.fspath",
"requests.get",
"bs4.BeautifulSoup",
"re.compile"
] | [((300, 319), 're.compile', 're.compile', (['""".*%.*"""'], {}), "('.*%.*')\n", (310, 319), False, 'import re\n'), ((508, 529), 're.compile', 're.compile', (['"""https.*"""'], {}), "('https.*')\n", (518, 529), False, 'import re\n'), ((847, 868), 're.compile', 're.compile', (['"""https.*"""'], {}), "('https.*')\n", (857... |
import os
from openpyxl import load_workbook, worksheet
def normalize_view(file):
wb = load_workbook(filename = file)
for sheet in wb:
# Put to active cell to A1
sheet.sheet_view.selection[0].activeCell = 'A1'
sheet.sheet_view.selection[0].sqref = 'A1'
sheet.sheet_view.topLeftCell = None
sheet.sheet_view.... | [
"os.path.splitext",
"os.walk",
"os.path.join",
"openpyxl.load_workbook"
] | [((89, 117), 'openpyxl.load_workbook', 'load_workbook', ([], {'filename': 'file'}), '(filename=file)\n', (102, 117), False, 'from openpyxl import load_workbook, worksheet\n'), ((574, 587), 'os.walk', 'os.walk', (['path'], {}), '(path)\n', (581, 587), False, 'import os\n'), ((616, 638), 'os.path.splitext', 'os.path.spli... |
from urgent.cli import main
main() | [
"urgent.cli.main"
] | [((28, 34), 'urgent.cli.main', 'main', ([], {}), '()\n', (32, 34), False, 'from urgent.cli import main\n')] |
from django.contrib.messages.storage.cookie import CookieStorage
from django.http import HttpRequest
def get_messages_from_cookie(cookies):
"""Get :mod:`~django.contrib.messages` from ``cookies``"""
request = HttpRequest()
request.COOKIES = {CookieStorage.cookie_name: cookies.get(
CookieStorage.co... | [
"django.http.HttpRequest",
"django.contrib.messages.storage.cookie.CookieStorage"
] | [((219, 232), 'django.http.HttpRequest', 'HttpRequest', ([], {}), '()\n', (230, 232), False, 'from django.http import HttpRequest\n'), ((349, 371), 'django.contrib.messages.storage.cookie.CookieStorage', 'CookieStorage', (['request'], {}), '(request)\n', (362, 371), False, 'from django.contrib.messages.storage.cookie i... |
from sys import argv
from time import sleep
print("\nRunning fab directly isn't supported anymore for commcare deploys.\n")
sleep(2)
print("Try running\n")
print(" commcare-cloud {} fab deploy".format(argv[1]))
print("\ninstead.")
exit(0)
| [
"time.sleep"
] | [((126, 134), 'time.sleep', 'sleep', (['(2)'], {}), '(2)\n', (131, 134), False, 'from time import sleep\n')] |
from optparse import OptionParser
#open vcf file
#submit to provean or run provean with vcf
parser = OptionParser()
parser.add_option('-i', help='vcf', dest='vcffile') #, nargs=2
(options, args) = parser.parse_args()
vcffile=options.vcffile
filename = ".".join(vcffile.split("/")[-1].split(".")[:-1])
readfile = op... | [
"optparse.OptionParser"
] | [((104, 118), 'optparse.OptionParser', 'OptionParser', ([], {}), '()\n', (116, 118), False, 'from optparse import OptionParser\n')] |
# -*- coding: utf-8 -*-
"""Trains a convolutional neural network on the MNIST dataset, then attacks it with the FGSM attack."""
from __future__ import absolute_import, division, print_function, unicode_literals
from os.path import abspath
import sys
sys.path.append(abspath('.'))
import keras.backend as k
import tenso... | [
"os.path.abspath",
"numpy.save",
"numpy.argmax",
"keras.layers.Dropout",
"art.classifiers.KerasClassifier",
"keras.layers.Flatten",
"keras.backend.set_learning_phase",
"keras.layers.Dense",
"keras.layers.Conv2D",
"keras.models.Sequential",
"art.attacks.fast_gradient.FastGradientMethod",
"keras... | [((940, 963), 'keras.backend.set_learning_phase', 'k.set_learning_phase', (['(1)'], {}), '(1)\n', (960, 963), True, 'import keras.backend as k\n'), ((973, 985), 'keras.models.Sequential', 'Sequential', ([], {}), '()\n', (983, 985), False, 'from keras.models import Sequential\n'), ((994, 1093), 'keras.layers.Conv2D', 'C... |
import numpy as np
import cv2
import matplotlib.pyplot as plt
from moviepy.editor import VideoFileClip
from src.sliding_window import SlidingWindow
from src.lane_line import LaneLine
from src.image_reader import ImageReader
from src.image_plotter import ImagePlotter
from src.camera import Camera
from src.threshold_app... | [
"numpy.dstack",
"src.camera.Camera",
"cv2.warpPerspective",
"numpy.zeros_like",
"cv2.putText",
"moviepy.editor.VideoFileClip",
"numpy.argmax",
"src.threshold_applier.ThresholdApplier",
"src.image_plotter.ImagePlotter",
"numpy.empty",
"src.sliding_window.SlidingWindow",
"cv2.fillPoly",
"src.i... | [((6900, 6928), 'src.image_reader.ImageReader', 'ImageReader', ([], {'read_mode': '"""RGB"""'}), "(read_mode='RGB')\n", (6911, 6928), False, 'from src.image_reader import ImageReader\n'), ((6938, 6954), 'src.camera.Camera', 'Camera', (['ir', 'None'], {}), '(ir, None)\n', (6944, 6954), False, 'from src.camera import Cam... |
from typing import Set, List
import bs4
from bs4 import BeautifulSoup
import arrow
import re
from recurrent_ics import RecurrentEvent, Event, Calendar
from arrow_extensions import parse_date, parse_time, get_weekday_after, shift_timezone, combine_date_time
ISO_WEEKDAY = {"M": 1, "T": 2, "W": 3, "R": 4, "F": 5, "S": 6,... | [
"arrow_extensions.parse_date",
"arrow_extensions.get_weekday_after",
"arrow_extensions.parse_time",
"arrow.utcnow",
"arrow_extensions.combine_date_time",
"recurrent_ics.Calendar"
] | [((4445, 4455), 'recurrent_ics.Calendar', 'Calendar', ([], {}), '()\n', (4453, 4455), False, 'from recurrent_ics import RecurrentEvent, Event, Calendar\n'), ((1497, 1522), 'arrow_extensions.parse_date', 'parse_date', (['date_range[0]'], {}), '(date_range[0])\n', (1507, 1522), False, 'from arrow_extensions import parse_... |
import os
import pymysql
from urllib.parse import unquote
import traceback
import json
from datetime import datetime, timedelta
password_decoded = unquote(os.environ.get('DB_PASSWORD'))
conn = pymysql.connect(host=os.environ.get('DB_HOST'),
user=os.environ.get('DB_USER'),
password=password_dec... | [
"os.environ.get",
"traceback.print_exc",
"datetime.datetime.now",
"datetime.timedelta"
] | [((432, 475), 'os.environ.get', 'os.environ.get', (['"""KEY_NAME"""', '"""quay-readonly"""'], {}), "('KEY_NAME', 'quay-readonly')\n", (446, 475), False, 'import os\n'), ((156, 185), 'os.environ.get', 'os.environ.get', (['"""DB_PASSWORD"""'], {}), "('DB_PASSWORD')\n", (170, 185), False, 'import os\n'), ((216, 241), 'os.... |
from django.contrib import admin
from .models import Challenge, ChallengeAdmin
admin.site.register(Challenge, ChallengeAdmin)
| [
"django.contrib.admin.site.register"
] | [((82, 128), 'django.contrib.admin.site.register', 'admin.site.register', (['Challenge', 'ChallengeAdmin'], {}), '(Challenge, ChallengeAdmin)\n', (101, 128), False, 'from django.contrib import admin\n')] |
#!/usr/bin/env python
# coding: utf-8
# In[3]:
get_ipython().run_line_magic('matplotlib', 'inline')
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import root_pandas
import pandas as pd
import ROOT as R
sns.set_style('whitegrid')
sns.set(color_codes=True)
# In[4]:
pd.set_option('display... | [
"matplotlib.pyplot.title",
"seaborn.heatmap",
"sklearn.feature_selection.mutual_info_classif",
"matplotlib.pyplot.figure",
"seaborn.pairplot",
"pandas.set_option",
"pandas.DataFrame",
"sklearn.ensemble.ExtraTreesClassifier",
"seaborn.set",
"pandas.concat",
"seaborn.set_style",
"matplotlib.pypl... | [((232, 258), 'seaborn.set_style', 'sns.set_style', (['"""whitegrid"""'], {}), "('whitegrid')\n", (245, 258), True, 'import seaborn as sns\n'), ((259, 284), 'seaborn.set', 'sns.set', ([], {'color_codes': '(True)'}), '(color_codes=True)\n', (266, 284), True, 'import seaborn as sns\n'), ((298, 357), 'pandas.set_option', ... |
# pylint: disable=super-init-not-called
import os
import warnings
try:
from collections.abc import Mapping, Iterable
except ImportError:
from collections import Mapping, Iterable
from numbers import Number
from ..utils import checksum_file
from ..xml import _element, element, TagBase, CV
from ..document import ... | [
"warnings.warn",
"os.path.join",
"os.path.exists"
] | [((4339, 4379), 'os.path.join', 'os.path.join', (['[self.location, self.name]'], {}), '([self.location, self.name])\n', (4351, 4379), False, 'import os\n'), ((4536, 4556), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (4550, 4556), False, 'import os\n'), ((32723, 32793), 'warnings.warn', 'warnings.war... |
from rest_framework import serializers
from .models import Question, Answer
from accounts.serializers import AccountShowSerializer
class QuestionSerializer(serializers.ModelSerializer):
author = AccountShowSerializer()
class Meta:
model = Question
exclude = ('id',)
class AnswerSerializer(ser... | [
"accounts.serializers.AccountShowSerializer"
] | [((201, 224), 'accounts.serializers.AccountShowSerializer', 'AccountShowSerializer', ([], {}), '()\n', (222, 224), False, 'from accounts.serializers import AccountShowSerializer\n'), ((360, 383), 'accounts.serializers.AccountShowSerializer', 'AccountShowSerializer', ([], {}), '()\n', (381, 383), False, 'from accounts.s... |
"""Author: <NAME>, Copyright 2019
Implements a convolutional capsule layer with a scaled dot product attention mechanism.
MIT License
"""
import tensorflow as tf
class ScaledDotProductAttentionLayer(tf.keras.layers.Layer):
def __init__(self, num_heads, hidden_size, output_size, **kwargs):
super(ScaledD... | [
"tensorflow.keras.layers.Conv2D",
"tensorflow.keras.layers.Dense",
"tensorflow.global_variables_initializer",
"tensorflow.reshape",
"tensorflow.transpose",
"tensorflow.shape",
"tensorflow.random_normal",
"tensorflow.GPUOptions",
"tensorflow.norm"
] | [((2342, 2376), 'tensorflow.norm', 'tf.norm', (['x'], {'axis': '(-1)', 'keepdims': '(True)'}), '(x, axis=-1, keepdims=True)\n', (2349, 2376), True, 'import tensorflow as tf\n'), ((4022, 4056), 'tensorflow.random_normal', 'tf.random_normal', (['[100, 64, 64, 3]'], {}), '([100, 64, 64, 3])\n', (4038, 4056), True, 'import... |
from active_reward_learning.util.helpers import get_dict_default
from .argmax_solver import ArgmaxSolver
from .ars import AugmentedRandomSearchSolver
from .base import BaseSolver
from .lbfgsb_argmax_solver import LBFGSArgmaxSolver
from .lbfgsb_solver import LBFGSSolver
from .lp_solver import LPSolver
try:
from st... | [
"active_reward_learning.util.helpers.get_dict_default"
] | [((1128, 1180), 'active_reward_learning.util.helpers.get_dict_default', 'get_dict_default', (['kwargs', '"""candidate_policies"""', 'None'], {}), "(kwargs, 'candidate_policies', None)\n", (1144, 1180), False, 'from active_reward_learning.util.helpers import get_dict_default\n'), ((1448, 1502), 'active_reward_learning.u... |
import numpy as np
import matplotlib.pyplot as plt
import pickle
# load data
data_folder = "traffic-signs-data/"
training_file = data_folder+"train.p"
validation_file = data_folder+"valid.p"
testing_file = data_folder+"test.p"
with open(training_file, mode='rb') as f:
train = pickle.load(f)
with open(validation_... | [
"torch.utils.data.DataLoader",
"torch.nn.CrossEntropyLoss",
"LeNet.LeNet",
"pickle.load",
"numpy.where",
"Dataset.SignDataset",
"cv2.normalize"
] | [((2092, 2132), 'Dataset.SignDataset', 'SignDataset', (['X_train', 'y_train', 'n_classes'], {}), '(X_train, y_train, n_classes)\n', (2103, 2132), False, 'from Dataset import SignDataset\n'), ((2148, 2186), 'Dataset.SignDataset', 'SignDataset', (['X_test', 'y_test', 'n_classes'], {}), '(X_test, y_test, n_classes)\n', (2... |
#
# This file is part of LiteX-Boards.
# FPGA Board Info : https://shop.trenz-electronic.de/en/TE0725-03-35-2C-FPGA-Module-with-Xilinx-Artix-7-XC7A35T-2CSG324C-2-x-50-Pin-with-2.54-mm-pitch
#
# Copyright (c) 2021 <NAME> <<EMAIL>>
# SPDX-License-Identifier: BSD-2-Clause
from litex.build.generic_platform import *
from l... | [
"litex.build.xilinx.XilinxPlatform.__init__",
"litex.build.openocd.OpenOCD",
"litex.build.xilinx.XilinxPlatform.do_finalize"
] | [((2645, 2735), 'litex.build.xilinx.XilinxPlatform.__init__', 'XilinxPlatform.__init__', (['self', '"""xc7a35tcsg324-2"""', '_io', '_connectors'], {'toolchain': '"""vivado"""'}), "(self, 'xc7a35tcsg324-2', _io, _connectors,\n toolchain='vivado')\n", (2668, 2735), False, 'from litex.build.xilinx import XilinxPlatform... |
# -*- coding: utf-8 -*-
"""img-grid-processing.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1rrkKK1WGrbCC5TnJSGX8772RCMdavj-L
"""
from google.colab import drive
drive.mount('/content/drive')
import os
import PIL
img_dir = "/content/drive/MyD... | [
"PIL.Image.open",
"numpy.random.choice",
"google.colab.drive.mount",
"matplotlib.pyplot.subplots",
"os.listdir",
"matplotlib.pyplot.savefig"
] | [((238, 267), 'google.colab.drive.mount', 'drive.mount', (['"""/content/drive"""'], {}), "('/content/drive')\n", (249, 267), False, 'from google.colab import drive\n'), ((345, 364), 'os.listdir', 'os.listdir', (['img_dir'], {}), '(img_dir)\n', (355, 364), False, 'import os\n'), ((455, 511), 'PIL.Image.open', 'PIL.Image... |
from typing import Dict
import matplotlib.pyplot as plt
import numpy as np
from IPython.core.display import display
from matplotlib.ticker import FormatStrFormatter, MaxNLocator
from mpl_toolkits.mplot3d import Axes3D
from plotly import offline as plotly, graph_objs as go, tools
PLOT_TYPES = {'random', 'grid', 'explo... | [
"plotly.offline.iplot",
"matplotlib.pyplot.get_cmap",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.close",
"matplotlib.ticker.MaxNLocator",
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.ticker.FormatStrFormatter",
"plotly.tools.make_subplots",
"plotly.offline.init_notebook_mode",
"matplo... | [((2187, 2228), 'plotly.offline.init_notebook_mode', 'plotly.init_notebook_mode', ([], {'connected': '(True)'}), '(connected=True)\n', (2212, 2228), True, 'from plotly import offline as plotly, graph_objs as go, tools\n'), ((2586, 2700), 'plotly.tools.make_subplots', 'tools.make_subplots', ([], {'rows': '(1)', 'cols': ... |
#!/usr/bin/env python
import sys,string
import os
import argparse
import tempfile
from pprint import *
import math
from collections import defaultdict
import operator
#********************************************************************************************
# Map ECs to Uniref50 and Uniref90 ... | [
"tempfile.mkdtemp",
"os.system",
"argparse.ArgumentParser",
"os.path.split"
] | [((14426, 14455), 'os.system', 'os.system', (['cmd_remove_tempdir'], {}), '(cmd_remove_tempdir)\n', (14435, 14455), False, 'import os\n'), ((2881, 2985), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Build relation: Reaction --> EC --> UniprotAC --> Uniref5090"""'}), "(description=\n ... |
import sttClient
import json
from watson_developer_cloud import SpeechToTextV1
from os.path import join, dirname
def test():
sttClient.Utils.getAuthenticationToken()
speech_to_text = SpeechToTextV1(
username='1b438e08-110f-4b25-943b-fb55c25db642',
password='<PASSWORD>',
x_watson_learni... | [
"watson_developer_cloud.SpeechToTextV1",
"sttClient.Utils.getAuthenticationToken",
"os.path.dirname"
] | [((131, 171), 'sttClient.Utils.getAuthenticationToken', 'sttClient.Utils.getAuthenticationToken', ([], {}), '()\n', (169, 171), False, 'import sttClient\n'), ((193, 317), 'watson_developer_cloud.SpeechToTextV1', 'SpeechToTextV1', ([], {'username': '"""1b438e08-110f-4b25-943b-fb55c25db642"""', 'password': '"""<PASSWORD>... |
"""
This file just makes sure that the parser can actually handle all the benchmark files
"""
import os
from typing import Iterator, Tuple
from pond import parser
from pond.file_reader import read_all_files
def find_files_matching_prefix(parent_dir: str, prefix: str) -> Iterator[Tuple[str, str]]:
"""
:param... | [
"os.path.basename",
"pond.parser.Problem",
"os.path.exists",
"os.path.split",
"pond.file_reader.read_all_files"
] | [((609, 635), 'pond.file_reader.read_all_files', 'read_all_files', (['parent_dir'], {}), '(parent_dir)\n', (623, 635), False, 'from pond.file_reader import read_all_files\n'), ((2357, 2378), 'os.path.exists', 'os.path.exists', (['fname'], {}), '(fname)\n', (2371, 2378), False, 'import os\n'), ((2393, 2426), 'pond.parse... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from six.moves import range
import os
import logging
logging.basicConfig(level=logging.DEBUG)
import sys
#sys.stdout = sys.stderr
# Prevent reaching to maximum recursion depth in `theano.tensor.grad`
#sys.set... | [
"tensorflow.keras.preprocessing.image.ImageDataGenerator",
"numpy.random.seed",
"tensorflow.keras.optimizers.SGD",
"tensorflow.keras.callbacks.ModelCheckpoint",
"tensorflow.keras.layers.Flatten",
"tensorflow.keras.regularizers.l2",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.keras.layers... | [((164, 204), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (183, 204), False, 'import logging\n'), ((364, 387), 'numpy.random.seed', 'np.random.seed', (['(2 ** 10)'], {}), '(2 ** 10)\n', (378, 387), True, 'import numpy as np\n'), ((1034, 1066), 'logging.debu... |
import io
import sys
from contextlib import redirect_stdout
from unittest import TestCase
from limis.management import CommandLineInterface, execute_limis_management, execute_limis_project_management, \
exit_codes
class TestCaseWithSysArgumentOverride(TestCase):
def setUp(self):
self.original_sys_arg... | [
"limis.management.execute_limis_project_management",
"limis.management.execute_limis_management",
"io.StringIO",
"limis.management.CommandLineInterface.run"
] | [((520, 533), 'io.StringIO', 'io.StringIO', ([], {}), '()\n', (531, 533), False, 'import io\n'), ((616, 642), 'limis.management.CommandLineInterface.run', 'CommandLineInterface.run', ([], {}), '()\n', (640, 642), False, 'from limis.management import CommandLineInterface, execute_limis_management, execute_limis_project_... |
"""
De-identify personally identifiable information (PII) by generating a hash.
"""
import click
import logging
import hashlib
import pandas as pd
from os import environ
from sys import stdout
from typing import Tuple
from id3c.cli import cli
from id3c.cli.io.pandas import (
load_input_from_file_or_stdin,
)
LOG =... | [
"click.argument",
"id3c.cli.cli.command",
"click.option",
"click.File",
"id3c.cli.io.pandas.load_input_from_file_or_stdin",
"hashlib.sha256",
"logging.getLogger"
] | [((321, 348), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (338, 348), False, 'import logging\n'), ((351, 377), 'id3c.cli.cli.command', 'cli.command', (['"""de-identify"""'], {}), "('de-identify')\n", (362, 377), False, 'from id3c.cli import cli\n'), ((379, 435), 'click.argument', 'clic... |
# Copyright (C) 2015 Google Inc., authors, and contributors <see AUTHORS file>
# Licensed under http://www.apache.org/licenses/LICENSE-2.0 <see LICENSE file>
# Created By: <EMAIL>
# Maintained By: <EMAIL>
"""Migrate objective_controls to relationships
Revision ID: 5345a09722f1
Revises: <PASSWORD>
Create Date: 2015-05... | [
"alembic.op.create_foreign_key",
"alembic.op.execute",
"alembic.op.drop_constraint"
] | [((882, 897), 'alembic.op.execute', 'op.execute', (['sql'], {}), '(sql)\n', (892, 897), False, 'from alembic import op\n'), ((900, 994), 'alembic.op.drop_constraint', 'op.drop_constraint', (['"""objective_controls_ibfk_1"""', '"""objective_controls"""'], {'type_': '"""foreignkey"""'}), "('objective_controls_ibfk_1', 'o... |
import asyncio
import json
from itertools import count
class RequestMessage(object):
msg_counter = count(0)
def __init__(self, method, timeout=20, **params):
self.id_msg = next(self.msg_counter)
self.method = method
self.params = params
self._timeout = timeout
self._o... | [
"asyncio.Event",
"json.loads",
"itertools.count",
"json.dumps"
] | [((105, 113), 'itertools.count', 'count', (['(0)'], {}), '(0)\n', (110, 113), False, 'from itertools import count\n'), ((337, 352), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (350, 352), False, 'import asyncio\n'), ((699, 798), 'json.dumps', 'json.dumps', (["{'jsonrpc': '2.0', 'id': self.id_msg, 'method': self... |
import numpy as np
def _load_embeddings(fn):
return np.load(fn)
a = _load_embeddings('_embs/symptoms-en.npy')
b = _load_embeddings('_output/paraphrase-MiniLM-L6-v2-symptoms-en.npy')
for x, y in zip(a, b):
for n, m in zip(x, y):
if abs(n - m) > 1e-5:
print(abs(n - m))
| [
"numpy.load"
] | [((57, 68), 'numpy.load', 'np.load', (['fn'], {}), '(fn)\n', (64, 68), True, 'import numpy as np\n')] |
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import os
import torch
import torch.nn.functional as F
import torch.optim as optim
from torchvision import transforms
import torch.nn as nn
import numpy as np
import cv2
import os.path as osp
from glob import glob
from tqdm import tqdm
c... | [
"numpy.zeros",
"os.path.join",
"numpy.maximum"
] | [((1154, 1187), 'os.path.join', 'osp.join', (['self.root_dir', 'taskname'], {}), '(self.root_dir, taskname)\n', (1162, 1187), True, 'import os.path as osp\n'), ((4893, 4931), 'os.path.join', 'osp.join', (['self.root_dir', 'self.taskname'], {}), '(self.root_dir, self.taskname)\n', (4901, 4931), True, 'import os.path as ... |
ALL_ABILITIES_CODE = """
1032E074 00000052
1032E076 00000089
1032E078 0000010F
1032E07A 0000010B
1032E07C 00000111
1032E07E 00000106
1032E080 00000107
1032E082 0000022F
1032E084 00000108
1032E086 00000232
1032E088 00000109
1032E08A 0000010A
1032E08C 0000010D
1032E08E 00000230
1032E090 0000010E
1032E092 00000110
1032E09... | [
"csv.reader",
"os.path.join"
] | [((6168, 6208), 'os.path.join', 'os.path.join', (['"""cheats"""', '"""F266B00B.pnach"""'], {}), "('cheats', 'F266B00B.pnach')\n", (6180, 6208), False, 'import csv, os\n'), ((9278, 9291), 'csv.reader', 'csv.reader', (['f'], {}), '(f)\n', (9288, 9291), False, 'import csv, os\n')] |
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
"""
About: Basic test of TUN interfaces and XDP (eBPF)
The compiling and attachment of the XDP program use IOVisor/BCC, please install
it with ../util/install.sh -b before running this example.
"""
from bcc import BPF # pylint: disable=import-error
f... | [
"comnetsemu.net.Containernet",
"bcc.BPF",
"mininet.log.info",
"mininet.log.setLogLevel"
] | [((474, 569), 'bcc.BPF', 'BPF', ([], {'text': '"""\n#include <uapi/linux/bpf.h>\nint drop_all() {\n return XDP_DROP;\n}\n"""'}), '(text=\n """\n#include <uapi/linux/bpf.h>\nint drop_all() {\n return XDP_DROP;\n}\n"""\n )\n', (477, 569), False, 'from bcc import BPF\n'), ((646, 694), 'comnetsemu.net.Container... |
from gym.envs.registration import register
from gym_foodhunting.foodhunting.gym_foodhunting import R2D2, R2D2Simple, R2D2Discrete, HSR, HSRSimple, HSRDiscrete
# FoodHunting R2D2
register(
id='FoodHunting-v0',
entry_point='gym_foodhunting.foodhunting:FoodHuntingEnv',
max_episode_steps=50,
kwargs={'rende... | [
"gym.envs.registration.register"
] | [((179, 515), 'gym.envs.registration.register', 'register', ([], {'id': '"""FoodHunting-v0"""', 'entry_point': '"""gym_foodhunting.foodhunting:FoodHuntingEnv"""', 'max_episode_steps': '(50)', 'kwargs': "{'render': False, 'robot_model': R2D2Simple, 'max_steps': 50, 'num_foods': \n 2, 'num_fakes': 0, 'object_size': 0.... |
import argparse
import os
import sys
import time
import traceback
import multiprocessing
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import matplotlib.animation as animation
from collections import OrderedDict
from pynput.keyboard import Listener, Key, KeyCo... | [
"pynput.keyboard.KeyCode.from_char",
"os.mkdir",
"argparse.ArgumentParser",
"matplotlib.pyplot.clf",
"matplotlib.animation.FuncAnimation",
"matplotlib.pyplot.figure",
"os.path.join",
"matplotlib.pyplot.imshow",
"os.path.exists",
"numpy.reshape",
"traceback.format_exc",
"matplotlib.image.imread... | [((517, 539), 'pynput.keyboard.KeyCode.from_char', 'KeyCode.from_char', (['"""a"""'], {}), "('a')\n", (534, 539), False, 'from pynput.keyboard import Listener, Key, KeyCode\n'), ((541, 563), 'pynput.keyboard.KeyCode.from_char', 'KeyCode.from_char', (['"""b"""'], {}), "('b')\n", (558, 563), False, 'from pynput.keyboard ... |
import black_jack, games, cards
class BJ_Game(object):
"""A Blackjack Game."""
def __init__(self, names):
self.players = []
for name in names:
player = black_jack.BJ_Player(name)
self.players.append(player)
self.dealer = black_jack.BJ_Dealer("Dealer")
... | [
"games.ask_yes_no",
"black_jack.BJ_Player",
"black_jack.BJ_Dealer",
"games.ask_number",
"black_jack.BJ_Deck"
] | [((2334, 2396), 'games.ask_number', 'games.ask_number', (['"""How many players? (1 - 7): """'], {'low': '(1)', 'high': '(8)'}), "('How many players? (1 - 7): ', low=1, high=8)\n", (2350, 2396), False, 'import black_jack, games, cards\n'), ((280, 310), 'black_jack.BJ_Dealer', 'black_jack.BJ_Dealer', (['"""Dealer"""'], {... |
from TASSELpy.utils.Overloading import javaOverload,javaConstructorOverload
from TASSELpy.javaObj import javaObj, javaArray
from TASSELpy.java.lang.Object import Object
from TASSELpy.utils.helper import make_sig
from abc import ABCMeta
import numpy as np
import javabridge
java_imports = {'String':'java/lang/String'}
... | [
"TASSELpy.javaObj.javaArray.to_wrapped_array",
"TASSELpy.utils.helper.make_sig",
"javabridge.get_env"
] | [((4187, 4250), 'TASSELpy.javaObj.javaArray.to_wrapped_array', 'javaArray.to_wrapped_array', (['arr_instance', 'String'], {'setter': 'setter'}), '(arr_instance, String, setter=setter)\n', (4213, 4250), False, 'from TASSELpy.javaObj import javaObj, javaArray\n'), ((910, 930), 'TASSELpy.utils.helper.make_sig', 'make_sig'... |
"""
Write a function called mul_time that takes a Time object and a number and returns a new Time
object that contains the product of the original Time and the number.
Then use mul_time to write a function that takes a Time object that represents the finishing
time in a race, and a number that represents the distanc... | [
"chapter_16.time_to_int",
"chapter_16.Time",
"chapter_16.int_to_time"
] | [((682, 706), 'chapter_16.int_to_time', 'int_to_time', (['time_as_int'], {}), '(time_as_int)\n', (693, 706), False, 'from chapter_16 import Time, time_to_int, int_to_time\n'), ((1059, 1065), 'chapter_16.Time', 'Time', ([], {}), '()\n', (1063, 1065), False, 'from chapter_16 import Time, time_to_int, int_to_time\n'), ((6... |
from eth_utils import encode_hex
from raiden_libs.utils import (
pack_data,
sign_data,
to_checksum_address,
)
from raiden.transfer.state import BalanceProofSignedState
from raiden.encoding.messages import (
nonce as nonce_field,
transferred_amount as transferred_amount_field,
locked_amount as ... | [
"eth_utils.encode_hex",
"raiden.encoding.messages.nonce.encoder.encode",
"raiden_libs.utils.to_checksum_address",
"raiden.encoding.messages.transferred_amount.encoder.encode",
"raiden.encoding.messages.locked_amount.encoder.encode"
] | [((592, 649), 'raiden.encoding.messages.nonce.encoder.encode', 'nonce_field.encoder.encode', (['nonce', 'nonce_field.size_bytes'], {}), '(nonce, nonce_field.size_bytes)\n', (618, 649), True, 'from raiden.encoding.messages import nonce as nonce_field, transferred_amount as transferred_amount_field, locked_amount as lock... |
"""Tests for permissions in the irodsbackend app"""
from django.conf import settings
from django.test import override_settings
from unittest import skipIf
# Projectroles dependency
from projectroles.models import SODAR_CONSTANTS
from projectroles.plugins import get_backend_api
from projectroles.tests.test_permission... | [
"unittest.skipIf",
"django.test.override_settings",
"projectroles.plugins.get_backend_api"
] | [((1068, 1114), 'unittest.skipIf', 'skipIf', (['(not BACKENDS_ENABLED)', 'BACKEND_SKIP_MSG'], {}), '(not BACKENDS_ENABLED, BACKEND_SKIP_MSG)\n', (1074, 1114), False, 'from unittest import skipIf\n'), ((3866, 3918), 'django.test.override_settings', 'override_settings', ([], {'PROJECTROLES_ALLOW_ANONYMOUS': '(True)'}), '... |
import time
import random
from robworld.RobotThymio2 import RobotThymio2
# Requiere simulador corriendo el "enjambre.world"
class TestEnjambre():
def __init__( self ):
pass
def run( self ):
# Los datos de conexion al simulador
host = "127.0.0.1"
port = 44444
# Usamos ... | [
"time.sleep",
"random.uniform",
"robworld.RobotThymio2.RobotThymio2",
"time.time"
] | [((679, 690), 'time.time', 'time.time', ([], {}), '()\n', (688, 690), False, 'import time\n'), ((568, 598), 'robworld.RobotThymio2.RobotThymio2', 'RobotThymio2', (['name', 'host', 'port'], {}), '(name, host, port)\n', (580, 598), False, 'from robworld.RobotThymio2 import RobotThymio2\n'), ((876, 889), 'time.sleep', 'ti... |
# coding=utf-8
from pypint.problems.i_problem import IProblem
from pypint.problems.has_direct_implicit_mixin import HasDirectImplicitMixin, problem_has_direct_implicit
import unittest
class HasDirectImplicitMixinTest(unittest.TestCase):
class TestProblem(IProblem, HasDirectImplicitMixin):
def __init__(se... | [
"unittest.main",
"pypint.problems.has_direct_implicit_mixin.problem_has_direct_implicit",
"pypint.problems.i_problem.IProblem",
"pypint.problems.has_direct_implicit_mixin.HasDirectImplicitMixin.__init__"
] | [((947, 962), 'unittest.main', 'unittest.main', ([], {}), '()\n', (960, 962), False, 'import unittest\n'), ((444, 498), 'pypint.problems.has_direct_implicit_mixin.HasDirectImplicitMixin.__init__', 'HasDirectImplicitMixin.__init__', (['self', '*args'], {}), '(self, *args, **kwargs)\n', (475, 498), False, 'from pypint.pr... |
from conway import conway
import unittest
import numpy as np
class TestConway(unittest.TestCase):
def test_still(self):
"""2x2 block"""
A = np.zeros((10,10))
A[1:3,1:3] = 1
B = conway(A)
assert (A == B).all()
def test_scillator(self):
"""blinker"""
A =... | [
"unittest.main",
"conway.conway",
"numpy.zeros",
"numpy.random.random"
] | [((712, 727), 'unittest.main', 'unittest.main', ([], {}), '()\n', (725, 727), False, 'import unittest\n'), ((163, 181), 'numpy.zeros', 'np.zeros', (['(10, 10)'], {}), '((10, 10))\n', (171, 181), True, 'import numpy as np\n'), ((216, 225), 'conway.conway', 'conway', (['A'], {}), '(A)\n', (222, 225), False, 'from conway ... |
from unittest import TestCase
import operators as op
class TestEvaluate(TestCase):
def test_ConstStr(self):
self.assertEqual('c', op.ConstStr('c').eval('ignored'))
def test_SubStr(self):
self.assertEqual('123', op.SubStr(1, 3).eval('1234'))
self.assertEqual('1234', op.SubStr(0, 4).ev... | [
"operators.GetAll",
"operators.GetToken",
"operators.GetSpan",
"operators.GetFirst",
"operators.Trim",
"operators.SubStr",
"operators.ToCase",
"operators.GetFrom",
"operators.ConstStr",
"operators.Replace",
"operators.GetUpto"
] | [((8772, 8899), 'operators.GetSpan', 'op.GetSpan', ([], {'dsl_regex1': 'op.Type.WORD', 'index1': '(1)', 'bound1': 'op.Boundary.START', 'dsl_regex2': '"""("""', 'index2': '(5)', 'bound2': 'op.Boundary.START'}), "(dsl_regex1=op.Type.WORD, index1=1, bound1=op.Boundary.START,\n dsl_regex2='(', index2=5, bound2=op.Bounda... |
import numpy as np
import torch
from pruning import RePruning
class RePruningConvDet(RePruning):
def __init__(self, softness, magnitude_threshold, metric_quantile, lr, sample, lb, scale):
super().__init__()
self.masks = {}
self.strength = softness
self.magnitude_threshold = magnit... | [
"torch.ones_like",
"torch.zeros_like",
"torch.norm",
"numpy.isnan",
"torch.no_grad",
"torch.abs"
] | [((571, 586), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (584, 586), False, 'import torch\n'), ((5141, 5156), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (5154, 5156), False, 'import torch\n'), ((5728, 5743), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (5741, 5743), False, 'import torch\n'), ((... |
import numpy as np
import pandas as pd
import pytest
from sklearn.model_selection import train_test_split
from mercari.datasets_mx import prepare_vectorizer_1, prepare_vectorizer_2, prepare_vectorizer_3
from mercari.datasets_tf import prepare_vectorizer_1_tf, prepare_vectorizer_2_tf, prepare_vectorizer_3_tf
from merca... | [
"mercari.datasets_tf.prepare_vectorizer_3_tf",
"mercari.mx_sparse.MXRegression",
"mercari.datasets_mx.prepare_vectorizer_2",
"mercari.mercari_io.load_train",
"mercari.datasets_mx.prepare_vectorizer_3",
"mercari.tf_sparse.RegressionClf",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
... | [((1584, 1708), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""n_rows"""', "[None, 'random', 1, 2, 2 ** 10, 2 ** 13 - 1, 2 ** 13, 2 ** 13 + 1, 2 ** 13 +\n 2 ** 10]"], {}), "('n_rows', [None, 'random', 1, 2, 2 ** 10, 2 ** 13 -\n 1, 2 ** 13, 2 ** 13 + 1, 2 ** 13 + 2 ** 10])\n", (1607, 1708), False, 'im... |
import argparse
from source import tools
from config import option
import random
from source import runtime
from source import constants as C
import json
import numpy as np
parser = argparse.ArgumentParser(description="Im2Latex Training Program")
parser.add_argument("-m", "--mode", dest="mode", choices=("train", "test... | [
"source.tools.get_blind_maze",
"argparse.ArgumentParser",
"random.uniform",
"numpy.square",
"random.choice",
"source.runtime.RuntimeGlobalInfo",
"json.dumps"
] | [((183, 247), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Im2Latex Training Program"""'}), "(description='Im2Latex Training Program')\n", (206, 247), False, 'import argparse\n'), ((1888, 1915), 'source.runtime.RuntimeGlobalInfo', 'runtime.RuntimeGlobalInfo', ([], {}), '()\n', (1913, 1... |
#
# Copyright 2016 The BigDL Authors.
#
# 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 ... | [
"torchvision.transforms.ColorJitter",
"argparse.ArgumentParser",
"torch.utils.data.DataLoader",
"torchvision.datasets.utils.download_and_extract_archive",
"torchvision.transforms.RandomHorizontalFlip",
"os.path.realpath",
"time.time",
"torchvision.datasets.ImageFolder",
"torchvision.transforms.ToTen... | [((1142, 1196), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""PyTorch Cat Dog"""'}), "(description='PyTorch Cat Dog')\n", (1165, 1196), False, 'import argparse\n'), ((1955, 1981), 'os.path.realpath', 'os.path.realpath', (['root_dir'], {}), '(root_dir)\n', (1971, 1981), False, 'import os... |
from flask import Blueprint
from .views import listar, cadastrar, pesquisar, alterar, deletar
app_funcionario = Blueprint('funcionario', __name__,
url_prefix='/funcionario')
app_funcionario.add_url_rule('/listar', 'listar', listar)
app_funcionario.add_url_rule('/cadastrar', 'cadastrar', c... | [
"flask.Blueprint"
] | [((114, 175), 'flask.Blueprint', 'Blueprint', (['"""funcionario"""', '__name__'], {'url_prefix': '"""/funcionario"""'}), "('funcionario', __name__, url_prefix='/funcionario')\n", (123, 175), False, 'from flask import Blueprint\n')] |
# Copyright 2015 Huawei Technologies Co., Ltd.
# 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
#
# Unl... | [
"sqlalchemy.MetaData",
"migrate.UniqueConstraint",
"sqlalchemy.Enum",
"sqlalchemy.ForeignKey",
"sqlalchemy.dialects.mysql.MEDIUMTEXT",
"sqlalchemy.Text",
"sqlalchemy.Table",
"sqlalchemy.Boolean",
"sqlalchemy.text",
"sqlalchemy.Column",
"sqlalchemy.String",
"sqlalchemy.Integer"
] | [((849, 863), 'sqlalchemy.MetaData', 'sql.MetaData', ([], {}), '()\n', (861, 863), True, 'import sqlalchemy as sql\n'), ((3924, 3984), 'sqlalchemy.Enum', 'sql.Enum', (['"""ssh"""', '"""x509"""'], {'metadata': 'meta', 'name': '"""keypair_types"""'}), "('ssh', 'x509', metadata=meta, name='keypair_types')\n", (3932, 3984)... |
from algotimer import Timer, TimerPloter
def fib(n):
if n <= 2:
return 1
return fib(n - 1) + fib(n - 2)
def fibMemo(n):
cache = {1: 1, 2: 1}
def rec(n):
if n not in cache:
cache[n] = rec(n - 1) + rec(n - 2)
return cache[n]
return rec(n)
if __name__ == '__ma... | [
"algotimer.TimerPloter",
"algotimer.Timer"
] | [((644, 657), 'algotimer.TimerPloter', 'TimerPloter', ([], {}), '()\n', (655, 657), False, 'from algotimer import Timer, TimerPloter\n'), ((336, 352), 'algotimer.Timer', 'Timer', (['"""fib, 30"""'], {}), "('fib, 30')\n", (341, 352), False, 'from algotimer import Timer, TimerPloter\n'), ((406, 422), 'algotimer.Timer', '... |
# Generated by Django 2.2.6 on 2019-11-20 17:53
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('reservation', '0005_auto... | [
"django.db.models.ForeignKey",
"django.db.migrations.swappable_dependency"
] | [((227, 284), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (258, 284), False, 'from django.db import migrations, models\n'), ((468, 602), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'default': '"""1"""',... |
import os
import random
import torch
import numpy as np
from time import time
from tqdm import tqdm
from copy import deepcopy
from pathlib import Path
from prettytable import PrettyTable
from common.test import test_v2
from common.utils import early_stopping, print_dict
from common.config import parse_args
from comm... | [
"os.mkdir",
"numpy.random.seed",
"common.test.test_v2",
"random.sample",
"torch.cat",
"common.dataset.CKGData",
"pathlib.Path",
"prettytable.PrettyTable",
"common.utils.print_dict",
"torch.no_grad",
"common.utils.early_stopping",
"torch.load",
"random.seed",
"torch.zeros",
"torch.cuda.se... | [((761, 791), 'tqdm.tqdm', 'tqdm', (['train_loader'], {'ascii': '(True)'}), '(train_loader, ascii=True)\n', (765, 791), False, 'from tqdm import tqdm\n'), ((2927, 2940), 'prettytable.PrettyTable', 'PrettyTable', ([], {}), '()\n', (2938, 2940), False, 'from prettytable import PrettyTable\n'), ((3351, 3383), 'pathlib.Pat... |
import numpy as np
import copy
from scipy import optimize
from astropy.stats import median_absolute_deviation
from astropy.table import Column, Table, vstack
from numpy.polynomial import legendre
from scipy import interpolate
from xwavecal.images import Image
from xwavecal.stages import Stage, ApplyCalibration
from x... | [
"xwavecal.utils.wavelength_utils.pixel_order_as_array",
"numpy.sum",
"numpy.allclose",
"xwavecal.utils.misc_utils.minmax",
"xwavecal.utils.wavelength_utils._sigma_clip",
"numpy.argmin",
"numpy.ones",
"numpy.isclose",
"numpy.arange",
"scipy.interpolate.interp1d",
"xwavecal.utils.wavelength_utils.... | [((806, 833), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (823, 833), False, 'import logging\n'), ((41291, 41326), 'numpy.arange', 'np.arange', (['min_pixel', '(max_pixel + 1)'], {}), '(min_pixel, max_pixel + 1)\n', (41300, 41326), True, 'import numpy as np\n'), ((42242, 42393), 'xwave... |
#!/usr/bin/env python3
import scrape_common as sc
import sys
import re
# get latest from list with all press releases
d = sc.download('https://www.regierung.li/coronavirus', silent=True)
is_first = True
pdf_url = sc.find(r'<a.*?href="([^"]+\.pdf)[^"]*"[^>]*?>[^<]+?Situationsbericht[^<]+?<\/a>', d)
if pdf_url:
#... | [
"scrape_common.DayData",
"scrape_common.download",
"scrape_common.find",
"scrape_common.pdfdownload",
"re.search",
"re.sub"
] | [((125, 189), 'scrape_common.download', 'sc.download', (['"""https://www.regierung.li/coronavirus"""'], {'silent': '(True)'}), "('https://www.regierung.li/coronavirus', silent=True)\n", (136, 189), True, 'import scrape_common as sc\n'), ((217, 312), 'scrape_common.find', 'sc.find', (['"""<a.*?href="([^"]+\\\\.pdf)[^"]*... |