code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from django import forms
class ContactForm(forms.Form):
nama = forms.CharField()
alamat = forms.CharField()
| [
"django.forms.CharField"
] | [((66, 83), 'django.forms.CharField', 'forms.CharField', ([], {}), '()\n', (81, 83), False, 'from django import forms\n'), ((95, 112), 'django.forms.CharField', 'forms.CharField', ([], {}), '()\n', (110, 112), False, 'from django import forms\n')] |
import os
from glob import glob
from microbench.google_benchmark.gbench_run_result import GBenchRunResult
from microbench.google_benchmark.gbench_historical_results import GBenchHistoricalResults
from microbench.jenkins.jenkins import Jenkins
from microbench.constants import LOCAL_REPO_DIR, JENKINS_URL
from microbench... | [
"microbench.google_benchmark.gbench_run_result.GBenchRunResult.from_benchmark_file",
"microbench.google_benchmark.gbench_run_result.GBenchRunResult",
"microbench.google_benchmark.gbench_historical_results.GBenchHistoricalResults",
"os.path.join",
"util.constants.LOG.debug",
"os.path.basename",
"microben... | [((2102, 2122), 'microbench.jenkins.jenkins.Jenkins', 'Jenkins', (['JENKINS_URL'], {}), '(JENKINS_URL)\n', (2109, 2122), False, 'from microbench.jenkins.jenkins import Jenkins\n'), ((2527, 2552), 'microbench.google_benchmark.gbench_run_result.GBenchRunResult', 'GBenchRunResult', (['artifact'], {}), '(artifact)\n', (254... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from CTFd.utils.scores import get_standings
from tests.helpers import (
create_ctfd,
destroy_ctfd,
gen_award,
gen_challenge,
gen_hint,
gen_team,
gen_user,
login_as_user,
)
def test_hint_team_unlock():
"""Is a user's unlocked hint refle... | [
"tests.helpers.create_ctfd",
"tests.helpers.gen_award",
"tests.helpers.login_as_user",
"tests.helpers.gen_challenge",
"tests.helpers.gen_team",
"CTFd.utils.scores.get_standings",
"tests.helpers.gen_user",
"tests.helpers.destroy_ctfd",
"tests.helpers.gen_hint"
] | [((360, 390), 'tests.helpers.create_ctfd', 'create_ctfd', ([], {'user_mode': '"""teams"""'}), "(user_mode='teams')\n", (371, 390), False, 'from tests.helpers import create_ctfd, destroy_ctfd, gen_award, gen_challenge, gen_hint, gen_team, gen_user, login_as_user\n'), ((2499, 2516), 'tests.helpers.destroy_ctfd', 'destroy... |
"""
eep_functions.py
(C) <NAME>
Institute for Astronomy
University of Hawaiʻi
2019 July 1
Python utilities to convert stellar evolution tracks to downsampled tracks
based on Equivalent Evolutionary Phases (EEPs) according to the method of Dotter
(2016).
"""
from multiprocessing import Pool
import numpy as np
from sc... | [
"numpy.log10",
"numpy.sqrt",
"matplotlib.pyplot.gca",
"tqdm.tqdm",
"scipy.interpolate.interp1d",
"numpy.zeros",
"matplotlib.pyplot.figure",
"multiprocessing.Pool",
"pandas.DataFrame",
"matplotlib.pyplot.show"
] | [((2461, 2507), 'pandas.DataFrame', 'pd.DataFrame', (['eep_track'], {'columns': 'track.columns'}), '(eep_track, columns=track.columns)\n', (2473, 2507), True, 'import pandas as pd\n'), ((10987, 11012), 'numpy.log10', 'np.log10', (["track['L/Lsun']"], {}), "(track['L/Lsun'])\n", (10995, 11012), True, 'import numpy as np... |
import unittest
from src.graph import Graph
from src.breadth_first_search import bfs
class BreadthFirstSearchTest(unittest.TestCase):
def test_bfs_parses_the_graph_in_order(self):
"""
Correctly explore the following graph:
_(a)--(c)--(e)
/ | / \ |
... | [
"src.graph.Graph.build",
"src.breadth_first_search.bfs"
] | [((506, 530), 'src.graph.Graph.build', 'Graph.build', ([], {'edges': 'edges'}), '(edges=edges)\n', (517, 530), False, 'from src.graph import Graph\n'), ((598, 613), 'src.breadth_first_search.bfs', 'bfs', (['graph', '"""s"""'], {}), "(graph, 's')\n", (601, 613), False, 'from src.breadth_first_search import bfs\n')] |
#!/usr/bin/python3
"""flvlib3
======
A library for manipulating, parsing and verifying FLV files.
It includes three example scripts, debug-flv, index-flv ,retimestamp-flv
and cut-flv which demonstrate the possible applications of the library.
Provides an easy and extensible way of writing applications that parse
and... | [
"setuptools.setup"
] | [((2634, 3798), 'setuptools.setup', 'setup', ([], {'name': '"""flvlib3"""', 'version': '__version__', 'description': '"""Parsing, manipulating and indexing FLV files"""', 'long_description': '__doc__', 'classifiers': "['Development Status :: 4 - Beta', 'Environment :: Console',\n 'Intended Audience :: Developers',\n... |
"""WIP: to convert a zip file into a dictionary of directories as dictionaries of files."""
import os
import pprint
import zipfile as zip
pp = pprint.PrettyPrinter()
def zlistdir(zfile):
"""eturn a list of directories from zip file."""
return list(filter(lambda f: f.startswith("subdir"), zfile.namelist())... | [
"os.listdir",
"zipfile.ZipFile",
"os.path.join",
"os.path.split",
"os.path.dirname",
"pprint.PrettyPrinter"
] | [((147, 169), 'pprint.PrettyPrinter', 'pprint.PrettyPrinter', ([], {}), '()\n', (167, 169), False, 'import pprint\n'), ((3416, 3441), 'zipfile.ZipFile', 'zip.ZipFile', (['xl_file_path'], {}), '(xl_file_path)\n', (3427, 3441), True, 'import zipfile as zip\n'), ((1767, 1783), 'os.listdir', 'os.listdir', (['path'], {}), '... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'C:\Users\<NAME>\Desktop\myjarvis\jarvisUI.ui'
#
# Created by: PyQt5 UI code generator 5.15.4
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you ar... | [
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtWidgets.QTextBrowser",
"PyQt5.QtWidgets.QMainWindow",
"PyQt5.QtGui.QFont",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtCore.QRect",
"PyQt5.QtGui.QPixmap",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QApplication",
"PyQt5.QtWidgets.QPushButton"
] | [((3647, 3679), 'PyQt5.QtWidgets.QApplication', 'QtWidgets.QApplication', (['sys.argv'], {}), '(sys.argv)\n', (3669, 3679), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((3696, 3719), 'PyQt5.QtWidgets.QMainWindow', 'QtWidgets.QMainWindow', ([], {}), '()\n', (3717, 3719), False, 'from PyQt5 import QtCore, QtG... |
import json
import os
from datetime import datetime, timedelta, timezone
from decimal import Decimal
from unittest import mock
from django.contrib.auth import get_user_model
from django.test import override_settings
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APITe... | [
"wirecard.services._get_headers",
"orders.models.Buyer.objects.count",
"orders.models.Charge.objects.first",
"django.urls.reverse",
"datetime.timedelta",
"unittest.mock.patch",
"django.contrib.auth.get_user_model",
"orders.models.Order.objects.first",
"json.dumps",
"talents.models.Talent.objects.c... | [((648, 664), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (662, 664), False, 'from django.contrib.auth import get_user_model\n'), ((1476, 1591), 'django.test.override_settings', 'override_settings', ([], {'task_eager_propagates': '(True)', 'task_always_eager': '(True)', 'broker_url': '"""m... |
import math
class Factorial:
'''Factorial is the product of an integer and all the integers below. It is represented also by '!'
Example: Factorial of 5 or 5! = 5 * 4 * 3 * 2 * 1
= 120 '''
def __init__(self, number=5):
self.number... | [
"math.factorial"
] | [((915, 942), 'math.factorial', 'math.factorial', (['self.number'], {}), '(self.number)\n', (929, 942), False, 'import math\n')] |
# ================================= test_sensors_RGB ===============================
"""
@brief Test the functionality of the sensors/Image class on one
Image topic
@Author: <NAME> <EMAIL>
@Date: 07/13/2021
Apply... | [
"rospy.init_node",
"cv2.imshow",
"ROSWrapper.subscribers.Images_sub.Images_sub",
"rospy.spin",
"cv2.waitKey"
] | [((794, 837), 'cv2.imshow', 'cv2.imshow', (['"""test_sensors_RGB"""', 'img_list[0]'], {}), "('test_sensors_RGB', img_list[0])\n", (804, 837), False, 'import cv2\n'), ((842, 855), 'cv2.waitKey', 'cv2.waitKey', ([], {}), '()\n', (853, 855), False, 'import cv2\n'), ((921, 952), 'rospy.init_node', 'rospy.init_node', (['"""... |
from django import forms
from .models import SubscriptionInformation, PushInformation
class SubscriptionInformationform(forms.ModelForm):
class Meta:
model = SubscriptionInformation
fields = ('browser', 'endpoint', 'auth', 'p256dh')
def get_or_save(self):
subscription_obj, created = Su... | [
"django.forms.ChoiceField"
] | [((467, 558), 'django.forms.ChoiceField', 'forms.ChoiceField', ([], {'choices': "[('subscribe', 'subscribe'), ('unsubscribe', 'unsubscribe')]"}), "(choices=[('subscribe', 'subscribe'), ('unsubscribe',\n 'unsubscribe')])\n", (484, 558), False, 'from django import forms\n')] |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
s = []
for v in input().strip():
if v != 'B':
s.append(v)
else:
if s:
s.pop()
print(''.join(s))
| [
"sys.setrecursionlimit"
] | [((38, 68), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10 ** 7)'], {}), '(10 ** 7)\n', (59, 68), False, 'import sys\n')] |
import torch
from torch.serialization import normalize_storage_type, location_tag, _should_read_directly
import io
import pickle
import pickletools
from .find_file_dependencies import find_files_source_depends_on
from ._custom_import_pickler import CustomImportPickler
from ._importlib import _normalize_path
import type... | [
"pathlib.Path",
"torch.serialization._should_read_directly",
"io.BytesIO",
"pickle.Pickler",
"torch.serialization.location_tag",
"linecache.getlines",
"pickletools.genops",
"tempfile.NamedTemporaryFile",
"torch._C.PyTorchFileWriter",
"distutils.sysconfig.get_python_lib",
"torch.is_storage"
] | [((23677, 23710), 'distutils.sysconfig.get_python_lib', 'get_python_lib', ([], {'standard_lib': '(True)'}), '(standard_lib=True)\n', (23691, 23710), False, 'from distutils.sysconfig import get_python_lib\n'), ((23876, 23910), 'distutils.sysconfig.get_python_lib', 'get_python_lib', ([], {'standard_lib': '(False)'}), '(s... |
"""Requires requests.get() mock as currently it tests for remote services."""
import pytest
from django.test import TestCase
from mock import mock
from apps.movie.api.omdb import search_movie_by_title
VALID_MOVIE_RESPONSE = {
"Title": "The Matrix",
"Year": "1999",
"Rated": "R",
"Released": "31 Mar 199... | [
"mock.mock.patch",
"pytest.raises",
"apps.movie.api.omdb.search_movie_by_title"
] | [((2271, 2373), 'mock.mock.patch', 'mock.patch', ([], {'target': '"""apps.movie.api.omdb.search_movie_by_title"""', 'return_value': 'VALID_MOVIE_RESPONSE'}), "(target='apps.movie.api.omdb.search_movie_by_title', return_value\n =VALID_MOVIE_RESPONSE)\n", (2281, 2373), False, 'from mock import mock\n'), ((2574, 2694),... |
from urllib.parse import urlencode
from base64 import b64encode
from datetime import datetime
from functools import partial
import operator
import pickle
import unicodedata
import requests
from lxml import html
import redis
import config
FB_TOKEN = urlencode({"access_token": config.FB_ACCESS_TOKEN})
FB_API_ROOT = "... | [
"requests.post",
"datetime.datetime.strptime",
"pickle.loads",
"pickle.dumps",
"lxml.html.fromstring",
"unicodedata.combining",
"requests.head",
"functools.partial",
"redis.StrictRedis",
"unicodedata.normalize",
"urllib.parse.urlencode",
"operator.itemgetter"
] | [((253, 304), 'urllib.parse.urlencode', 'urlencode', (["{'access_token': config.FB_ACCESS_TOKEN}"], {}), "({'access_token': config.FB_ACCESS_TOKEN})\n", (262, 304), False, 'from urllib.parse import urlencode\n'), ((855, 945), 'functools.partial', 'partial', (['requests.get'], {'headers': 'headers', 'params': 'params', ... |
from django.urls import path
from rental_property import views
urlpatterns = [
path('', views.buildings, name='operational-buildings'),
path('building-units/<slug:building_slug>/', views.vacant_building_units, name='building-units'),
path('building/<slug:building_slug>/rental-units/', views.managed_buildi... | [
"django.urls.path"
] | [((85, 140), 'django.urls.path', 'path', (['""""""', 'views.buildings'], {'name': '"""operational-buildings"""'}), "('', views.buildings, name='operational-buildings')\n", (89, 140), False, 'from django.urls import path\n'), ((146, 246), 'django.urls.path', 'path', (['"""building-units/<slug:building_slug>/"""', 'views... |
import datetime
import json
import os
import time
import requests
from flask import render_template, redirect, request, session
from app import app
import CardReader
CONNECTED_NODE_ADDRESS = "http://169.254.62.57:8000"
posts = []
pk = None
def fetch_posts(isFiltered=True):
get_chain_address = "{}/chain".format... | [
"flask.render_template",
"flask.request.args.get",
"json.loads",
"datetime.datetime.fromtimestamp",
"CardReader.initCard",
"requests.post",
"CardReader.generateSignature",
"requests.get",
"flask.redirect",
"CardReader.auth",
"CardReader.verifyPub",
"CardReader.read_public_key",
"app.app.rout... | [((2854, 2875), 'app.app.route', 'app.route', (['"""/display"""'], {}), "('/display')\n", (2863, 2875), False, 'from app import app\n'), ((2995, 3017), 'app.app.route', 'app.route', (['"""/register"""'], {}), "('/register')\n", (3004, 3017), False, 'from app import app\n'), ((3147, 3166), 'app.app.route', 'app.route', ... |
from SCM.ensemble import Ensemble
class FinRechercheException(Exception):
pass
def filtrage(ensembles, contraintes):
# reduction des domaines
filtrage_ok = True
modif = True
while modif:
modif = False
for contrainte in contraintes:
# si filtre = 0 alors pas de changem... | [
"SCM.ensemble.Ensemble",
"copy.deepcopy"
] | [((806, 851), 'SCM.ensemble.Ensemble', 'Ensemble', (['to_split.nom'], {'domaine': 'd', 'const': '(True)'}), '(to_split.nom, domaine=d, const=True)\n', (814, 851), False, 'from SCM.ensemble import Ensemble\n'), ((4210, 4229), 'copy.deepcopy', 'deepcopy', (['ensembles'], {}), '(ensembles)\n', (4218, 4229), False, 'from c... |
import discord
from discord.ext import commands
import os
intents = discord.Intents.default()
intents.members = True
discord_key = (os.environ.get('BaruchCollegeKey'))
client = commands.Bot(command_prefix='!', intents=intents)
@client.command()
async def load(ctx, extention):
client.load_extension('cogs.{ex... | [
"os.listdir",
"discord.Game",
"discord.ext.commands.Bot",
"os.environ.get",
"os.path.join",
"discord.Intents.default"
] | [((71, 96), 'discord.Intents.default', 'discord.Intents.default', ([], {}), '()\n', (94, 96), False, 'import discord\n'), ((136, 170), 'os.environ.get', 'os.environ.get', (['"""BaruchCollegeKey"""'], {}), "('BaruchCollegeKey')\n", (150, 170), False, 'import os\n'), ((181, 230), 'discord.ext.commands.Bot', 'commands.Bot... |
from django.http import Http404
from django.shortcuts import get_object_or_404, render, redirect
from django.contrib.auth import login, authenticate
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import Group
from django.contrib.auth.password_validation import validate_passwor... | [
"django.shortcuts.render",
"django.contrib.auth.authenticate",
"django.contrib.auth.models.Group.objects.get",
"user.forms.ClientRegistrationForm",
"django.shortcuts.get_object_or_404",
"client.models.ClientSettings",
"django.contrib.auth.login",
"django.contrib.auth.password_validation.validate_passw... | [((896, 930), 'django.shortcuts.get_object_or_404', 'get_object_or_404', (['User'], {'pk': 'ria_id'}), '(User, pk=ria_id)\n', (913, 930), False, 'from django.shortcuts import get_object_or_404, render, redirect\n'), ((3303, 3360), 'django.shortcuts.render', 'render', (['request', '"""user/client_registration.html"""', ... |
# 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.getter",
"pulumi.set",
"pulumi.ResourceOptions",
"pulumi.get"
] | [((2098, 2137), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""resourceGroupName"""'}), "(name='resourceGroupName')\n", (2111, 2137), False, 'import pulumi\n'), ((3369, 3402), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""storageType"""'}), "(name='storageType')\n", (3382, 3402), False, 'import pulumi\n'), (... |
import tensorflow as tf
from groupy.gconv.make_gconv_indices import make_c4_z2_indices, make_c4_p4_indices,\
make_d4_z2_indices, make_d4_p4m_indices, flatten_indices
from groupy.gconv.tensorflow_gconv.transform_filter import transform_filter_2d_nchw, transform_filter_2d_nhwc
def gconv2d(input, filter, strides, ... | [
"tensorflow.nn.conv2d",
"groupy.gconv.make_gconv_indices.make_c4_z2_indices",
"groupy.gconv.tensorflow_gconv.transform_filter.transform_filter_2d_nhwc",
"groupy.gconv.make_gconv_indices.make_d4_p4m_indices",
"groupy.gconv.make_gconv_indices.make_d4_z2_indices",
"groupy.gconv.make_gconv_indices.make_c4_p4_... | [((2090, 2186), 'groupy.gconv.tensorflow_gconv.transform_filter.transform_filter_2d_nhwc', 'transform_filter_2d_nhwc', ([], {'w': 'filter', 'flat_indices': 'gconv_indices', 'shape_info': 'gconv_shape_info'}), '(w=filter, flat_indices=gconv_indices, shape_info=\n gconv_shape_info)\n', (2114, 2186), False, 'from group... |
from sqlalchemy.sql import (
select as sql_select,
update as sql_update,
delete as sql_delete,
join as sql_join,
)
from sanic.exceptions import ServerError
from app.database.psql.db import scoped_session, Session
from app.database.psql.models import (
Module1,
)
from app.database.memcache.db import ... | [
"sanic.exceptions.ServerError",
"sqlalchemy.sql.select",
"app.database.psql.db.scoped_session",
"app.database.memcache.db.mem_client.set",
"app.database.memcache.db.mem_client.get"
] | [((366, 392), 'app.database.memcache.db.mem_client.get', 'mem_client.get', (['"""some_key"""'], {}), "('some_key')\n", (380, 392), False, 'from app.database.memcache.db import mem_client\n'), ((485, 516), 'app.database.memcache.db.mem_client.set', 'mem_client.set', (['"""some_key"""', 'val'], {}), "('some_key', val)\n"... |
# Copyright 2020 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"dataclasses.dataclass"
] | [((913, 946), 'dataclasses.dataclass', 'dataclasses.dataclass', ([], {'repr': '(False)'}), '(repr=False)\n', (934, 946), False, 'import dataclasses\n'), ((1739, 1772), 'dataclasses.dataclass', 'dataclasses.dataclass', ([], {'repr': '(False)'}), '(repr=False)\n', (1760, 1772), False, 'import dataclasses\n')] |
# This is the training file for the DCNN paper,
# "Saliency-based deep convolutional neural network for no-reference image quality assessment".
#
# Author: <NAME>
#
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
from datetime import datetime
imp... | [
"tensorflow.reset_default_graph",
"tensorflow.Variable",
"tensorflow.train.MomentumOptimizer",
"tensorflow.clip_by_norm",
"tensorflow.Session",
"tensorflow.placeholder",
"tensorflow.train.Saver",
"tensorflow.global_variables_initializer",
"tensorflow.assign",
"os.path.isdir",
"os.mkdir",
"tens... | [((576, 600), 'os.path.isdir', 'os.path.isdir', (['MODEL_DIR'], {}), '(MODEL_DIR)\n', (589, 600), False, 'import os\n'), ((606, 625), 'os.mkdir', 'os.mkdir', (['MODEL_DIR'], {}), '(MODEL_DIR)\n', (614, 625), False, 'import os\n'), ((1227, 1251), 'tensorflow.reset_default_graph', 'tf.reset_default_graph', ([], {}), '()\... |
import click
def add_mngt_command(cli: click.core.Group) -> None:
@cli.command("quickstart", help="StarWhale Quickstart")
def _quickstart() -> None:
# TODO: init git repo, add some gitignore
pass
@cli.command("autocomplete", help="Generate zsh/bash command auto complete")
def _autocom... | [
"click.option"
] | [((405, 493), 'click.option', 'click.option', (['"""--dry-run"""'], {'is_flag': '(False)', 'help': '"""dry-run cleanup garbage collection"""'}), "('--dry-run', is_flag=False, help=\n 'dry-run cleanup garbage collection')\n", (417, 493), False, 'import click\n')] |
import math
import numpy as np
def quaternion_to_rotation_matrix(q):
# Original C++ Method defined in pba/src/pba/DataInterface.h
qq = math.sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3])
qw = qx = qy = qz = 0
if qq > 0: # NORMALIZE THE QUATERNION
qw = q[0] / qq
qx = q[1]... | [
"numpy.identity",
"numpy.isclose",
"numpy.ones",
"numpy.hstack",
"numpy.delete",
"math.sqrt",
"numpy.linalg.det",
"numpy.array",
"numpy.zeros",
"numpy.dot",
"numpy.zeros_like"
] | [((146, 210), 'math.sqrt', 'math.sqrt', (['(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3])'], {}), '(q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3])\n', (155, 210), False, 'import math\n'), ((431, 460), 'numpy.zeros', 'np.zeros', (['(3, 3)'], {'dtype': 'float'}), '((3, 3), dtype=float)\n', (439, 460), Tr... |
# Generated by Django 2.1.7 on 2019-03-14 01:12
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('qa', '0031_convert_null_mc_tols'),
]
operations = [
migrations.AlterField(
model_name='toleranc... | [
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((378, 559), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'default': '""""""', 'help_text': '"""Comma seperated list of choices that are considered passing"""', 'max_length': '(2048)', 'verbose_name': '"""Multiple Choice OK Values"""'}), "(blank=True, default='', help_text=\n 'Comma se... |
import numpy as np
import matplotlib.pyplot as plt
fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True, figsize=(8,12))
# Plot pow with different settings
t = 1e-2
rcut = 5
settings = [
[2, rcut/(1/t*(1-t)) ** (1 / 2), 1],
[4, rcut/(1/t*(1-t)) ** (1 / 4), 1],
[8, rcut/(1/t*(1-t)) ** (1 / 8), 1],
]
rmin... | [
"matplotlib.pyplot.subplots_adjust",
"numpy.log",
"numpy.exp",
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((76, 124), 'matplotlib.pyplot.subplots', 'plt.subplots', (['(3)', '(1)'], {'sharex': '(True)', 'figsize': '(8, 12)'}), '(3, 1, sharex=True, figsize=(8, 12))\n', (88, 124), True, 'import matplotlib.pyplot as plt\n'), ((2438, 2502), 'matplotlib.pyplot.subplots_adjust', 'plt.subplots_adjust', ([], {'left': '(0.1)', 'rig... |
#!/usr/bin/env python3
import asyncio
import json
import click
import websockets
from urwid import AsyncioEventLoop, Edit, ExitMainLoop, Filler, Frame, MainLoop, Text, connect_signal
COMMAND_READ, PASSWORD_READ = 0, 1
SEND_PASSWORD = '<PASSWORD>'
BAD_PASSWORD = '<PASSWORD>'
DISCONNECTING = 'disconnecting'
LIST_CHANNE... | [
"urwid.ExitMainLoop",
"click.option",
"asyncio.get_event_loop",
"json.dumps",
"urwid.AsyncioEventLoop",
"websockets.connect",
"urwid.Filler",
"urwid.Edit",
"click.command",
"urwid.MainLoop",
"urwid.Text"
] | [((545, 569), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (567, 569), False, 'import asyncio\n'), ((573, 588), 'click.command', 'click.command', ([], {}), '()\n', (586, 588), False, 'import click\n'), ((590, 663), 'click.option', 'click.option', (['"""--host"""'], {'prompt': '"""Command server... |
"""
@desc: Отримати поточну позицію.
"""
import json
def add_arguments(parser):
parser.add_argument(
'--get_my_position_output_filename', '-gmp_out',
default='./my_position.json',
type=str,
help='Розміщення та назва результуючого файлу команди get_my_position.')
def execute(clien... | [
"json.dump"
] | [((571, 606), 'json.dump', 'json.dump', (['response', 'file'], {'indent': '(2)'}), '(response, file, indent=2)\n', (580, 606), False, 'import json\n')] |
import os
import pickle
import pandas as pd
from flask import Flask, request, Response
from healthinsurance.HealthInsurance import HealthInsurance
# load model
model = pickle.load(open('models/model_lightgbm.pkl', 'rb'))
# Initialize API
app = Flask(__name__)
# create a route
@app.route('/predict', methods=['POST']... | [
"healthinsurance.HealthInsurance.HealthInsurance",
"flask.Flask",
"os.environ.get",
"flask.request.get_json",
"flask.Response",
"pandas.DataFrame"
] | [((247, 262), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (252, 262), False, 'from flask import Flask, request, Response\n'), ((390, 408), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (406, 408), False, 'from flask import Flask, request, Response\n'), ((1356, 1384), 'os.environ.get', ... |
import aftership
# aftership.api_key = 'PUT_YOUR_AFTERSHIP_KEY_HERE'
def create_tracking(slug, tracking_number, title):
"""Create tracking, return tracking ID
"""
tracking = {'slug': slug, 'tracking_number': tracking_number, 'title' : title}
result = aftership.tracking.create_tracking(tracking=track... | [
"aftership.tracking.update_tracking",
"aftership.tracking.delete_tracking",
"aftership.tracking.create_tracking"
] | [((271, 336), 'aftership.tracking.create_tracking', 'aftership.tracking.create_tracking', ([], {'tracking': 'tracking', 'timeout': '(10)'}), '(tracking=tracking, timeout=10)\n', (305, 336), False, 'import aftership\n'), ((423, 499), 'aftership.tracking.update_tracking', 'aftership.tracking.update_tracking', ([], {'trac... |
#!/usr/bin/env python
import os, sys
import subprocess
from glob import iglob, glob
'''print (folder_name, total_rst7, restrained_rst7, non_restrained_rst7)
'''
folders = [fn for fn in iglob('./*') if os.path.isdir(fn)]
folders_with_num = []
for fn in folders:
min_restraints = glob('{}/min*rst7'.format(fn))
... | [
"subprocess.check_output",
"os.path.getsize",
"glob.iglob",
"sys.argv.remove",
"os.path.isdir"
] | [((187, 199), 'glob.iglob', 'iglob', (['"""./*"""'], {}), "('./*')\n", (192, 199), False, 'from glob import iglob, glob\n'), ((203, 220), 'os.path.isdir', 'os.path.isdir', (['fn'], {}), '(fn)\n', (216, 220), False, 'import os, sys\n'), ((2288, 2315), 'glob.iglob', 'iglob', (["(folder + '/min*rst7')"], {}), "(folder + '... |
import pprint
import click
import numerapi
napi = numerapi.NumerAPI()
def prettify(stuff):
pp = pprint.PrettyPrinter(indent=4)
return pp.pformat(stuff)
@click.group()
def cli():
"""Wrapper around the Numerai API"""
pass
@cli.command()
@click.option('--tournament', default=1,
help='... | [
"click.argument",
"click.group",
"click.option",
"click.Path",
"pprint.PrettyPrinter",
"numerapi.NumerAPI"
] | [((52, 71), 'numerapi.NumerAPI', 'numerapi.NumerAPI', ([], {}), '()\n', (69, 71), False, 'import numerapi\n'), ((167, 180), 'click.group', 'click.group', ([], {}), '()\n', (178, 180), False, 'import click\n'), ((260, 352), 'click.option', 'click.option', (['"""--tournament"""'], {'default': '(1)', 'help': '"""The ID of... |
import kfp.dsl
import kubernetes.client
import mlrun
overridden_affinity = kubernetes.client.V1Affinity(
node_affinity=kubernetes.client.V1NodeAffinity(
required_during_scheduling_ignored_during_execution=kubernetes.client.V1NodeSelector(
node_selector_terms=[
kubernetes.client... | [
"mlrun.run_function"
] | [((758, 820), 'mlrun.run_function', 'mlrun.run_function', (['"""func1"""'], {'handler': '"""func1"""', 'params': "{'p1': 9}"}), "('func1', handler='func1', params={'p1': 9})\n", (776, 820), False, 'import mlrun\n'), ((903, 965), 'mlrun.run_function', 'mlrun.run_function', (['"""func2"""'], {'handler': '"""func1"""', 'p... |
# This File will contains Loss Function
# This File is to eable Package import, will mostly keep it blank
import os
import time
import torch
import torch.nn as nn
import torch.nn.functional as F
import warnings
warnings.simplefilter("ignore")
class DiceLoss(nn.Module):
"""Calculate dice loss."""
def __init_... | [
"warnings.simplefilter",
"torch.sigmoid",
"torch.nn.BCEWithLogitsLoss"
] | [((212, 243), 'warnings.simplefilter', 'warnings.simplefilter', (['"""ignore"""'], {}), "('ignore')\n", (233, 243), False, 'import warnings\n'), ((598, 619), 'torch.sigmoid', 'torch.sigmoid', (['logits'], {}), '(logits)\n', (611, 619), False, 'import torch\n'), ((1087, 1109), 'torch.nn.BCEWithLogitsLoss', 'nn.BCEWithLo... |
from driver_class import DataDriver
import mysql.connector
from mysql.connector import errorcode
from getpass import getpass
class MySQLDataDriver(DataDriver):
def load(self):
mysql_config = {
"connect": {
"host": self.config.get("host") or "localhost",
"port": ... | [
"getpass.getpass"
] | [((1008, 1062), 'getpass.getpass', 'getpass', (['"""Enter the password for your MySQL account: """'], {}), "('Enter the password for your MySQL account: ')\n", (1015, 1062), False, 'from getpass import getpass\n')] |
from flask import Flask, render_template, request
import sys
from .models import db_wrapper
from .views.token import token
from .common import JWT
try:
import config
except ImportError:
print("ERROR: El archivo de configuración no existe!")
sys.exit(1)
app = Flask(__name__)
app.config.from_object('confi... | [
"sys.exit",
"flask.Flask"
] | [((275, 290), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (280, 290), False, 'from flask import Flask, render_template, request\n'), ((256, 267), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (264, 267), False, 'import sys\n')] |
"""
File formats for reading/writing to/from DFs.
"""
from __future__ import annotations
import enum
from collections import defaultdict
from pathlib import Path
from typing import Mapping, MutableMapping, Optional, Set, Union
from typeddfs.df_errors import FilenameSuffixError
from typeddfs.utils._format_support impo... | [
"typeddfs.utils._format_support.DfFormatSupport.support_map.get",
"collections.defaultdict",
"typeddfs.df_errors.FilenameSuffixError",
"pathlib.Path"
] | [((3291, 3301), 'pathlib.Path', 'Path', (['path'], {}), '(path)\n', (3295, 3301), False, 'from pathlib import Path\n'), ((3662, 3672), 'pathlib.Path', 'Path', (['path'], {}), '(path)\n', (3666, 3672), False, 'from pathlib import Path\n'), ((4223, 4239), 'collections.defaultdict', 'defaultdict', (['set'], {}), '(set)\n'... |
# Generated by Django 3.1.8 on 2021-04-12 16:10
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import uuid
class Migration(migrations.Migration):
dependencies = [
('content', '0020_auto_20210302_1929'),
]
operations = [
migrati... | [
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.db.models.CharField",
"django.db.models.DateTimeField",
"django.db.models.UUIDField"
] | [((408, 502), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'auto_created': '(True)', 'default': 'uuid.uuid4', 'primary_key': '(True)', 'serialize': '(False)'}), '(auto_created=True, default=uuid.uuid4, primary_key=True,\n serialize=False)\n', (424, 502), False, 'from django.db import migrations, models\n'... |
import os
import json
import datetime
from collections import defaultdict
def get_frame_label_to_uri(frame_to_info_json, verbose=0):
"""
"""
frame_to_uri = {}
frame_to_info = json.load(open(frame_to_info_json))
for uri, info in frame_to_info.items():
frame_to_uri[info['frame_label']] = ur... | [
"datetime.datetime.utcfromtimestamp",
"os.stat",
"collections.defaultdict"
] | [((637, 650), 'os.stat', 'os.stat', (['path'], {}), '(path)\n', (644, 650), False, 'import os\n'), ((670, 724), 'datetime.datetime.utcfromtimestamp', 'datetime.datetime.utcfromtimestamp', (['file_info.st_ctime'], {}), '(file_info.st_ctime)\n', (704, 724), False, 'import datetime\n'), ((1711, 1728), 'collections.default... |
from __future__ import absolute_import, division, unicode_literals
import param
from .widgets import Widget
ipywidget_classes = {}
def param_value_if_widget(arg):
if isinstance(arg, Widget):
return arg.param.value
from .pane.ipywidget import IPyWidget
if IPyWidget.applies(arg) and hasattr(arg,... | [
"param.Parameter",
"param.depends"
] | [((964, 1010), 'param.depends', 'param.depends', (['*updated_args'], {}), '(*updated_args, **updated_kwargs)\n', (977, 1010), False, 'import param\n'), ((531, 548), 'param.Parameter', 'param.Parameter', ([], {}), '()\n', (546, 548), False, 'import param\n')] |
#! -*- coding:utf-8 -*-
'''
@Author: ZM
@Date and Time: 2021/6/18 6:18
@File: yolov3_model.py
'''
import torch
from torch import nn
class MakeLastLayer(nn.Module):
def __init__(self, in_channels, channels, out_channels):
super(MakeLastLayer, self).__init__()
nonlinea... | [
"torch.nn.BatchNorm2d",
"torch.nn.LeakyReLU",
"torch.sigmoid",
"torch.nn.Conv2d",
"torch.nn.Upsample",
"torch.cat"
] | [((324, 356), 'torch.nn.LeakyReLU', 'nn.LeakyReLU', ([], {'negative_slope': '(0.2)'}), '(negative_slope=0.2)\n', (336, 356), False, 'from torch import nn\n'), ((1814, 1846), 'torch.nn.LeakyReLU', 'nn.LeakyReLU', ([], {'negative_slope': '(0.2)'}), '(negative_slope=0.2)\n', (1826, 1846), False, 'from torch import nn\n'),... |
""" Basic Serialization Tests
"""
import unittest
import dataclasses
import json
from .dtos import *
from datetime import datetime, timedelta, timezone
from servicestack import JsonServiceClient, WebServiceException, to_json
from .config import create_test_client
def create_HelloAllTypes():
return HelloAllTypes... | [
"datetime.datetime",
"json.loads",
"dataclasses.asdict",
"servicestack.to_json",
"datetime.timedelta",
"servicestack.JsonServiceClient"
] | [((2681, 2722), 'datetime.datetime', 'datetime', (['(2001)', '(1)', '(1)'], {'tzinfo': 'timezone.utc'}), '(2001, 1, 1, tzinfo=timezone.utc)\n', (2689, 2722), False, 'from datetime import datetime, timedelta, timezone\n'), ((2767, 2808), 'datetime.datetime', 'datetime', (['(2001)', '(1)', '(1)'], {'tzinfo': 'timezone.ut... |
from inputs import get_gamepad
from threading import Thread, Event
from time import sleep
from PpmSignal import PpmSignal
class Receiver:
def __init__(self, parent):
self.recording_signal = Event()
self.send_delay = 0.0225
self.parent = parent
self.signal = PpmSignal()
# ... | [
"inputs.get_gamepad",
"PpmSignal.PpmSignal",
"time.sleep",
"threading.Event",
"threading.Thread"
] | [((204, 211), 'threading.Event', 'Event', ([], {}), '()\n', (209, 211), False, 'from threading import Thread, Event\n'), ((297, 308), 'PpmSignal.PpmSignal', 'PpmSignal', ([], {}), '()\n', (306, 308), False, 'from PpmSignal import PpmSignal\n'), ((1914, 1961), 'threading.Thread', 'Thread', ([], {'target': 'self.recordin... |
import numpy as np
import keras
from keras.models import Model
from keras.layers import Input, Dense, Activation, Dropout, BatchNormalization, LeakyReLU
from keras.optimizers import Adam
from keras import backend as K
# 今更きけないGAN
# https://qiita.com/triwave33/items/1890ccc71fab6cbca87e
# https://qiita.com/p... | [
"numpy.random.rand",
"keras.backend.gradients",
"numpy.array",
"keras.layers.Activation",
"keras.layers.Dense",
"keras.backend.square",
"keras.backend.placeholder",
"keras.models.Model",
"numpy.random.permutation",
"keras.optimizers.Adam",
"numpy.random.normal",
"numpy.ones",
"numpy.add",
... | [((1635, 1666), 'keras.layers.Input', 'Input', ([], {'shape': '(self.latent_dim,)'}), '(shape=(self.latent_dim,))\n', (1640, 1666), False, 'from keras.layers import Input, Dense, Activation, Dropout, BatchNormalization, LeakyReLU\n'), ((2075, 2115), 'keras.models.Model', 'Model', ([], {'input': 'latent_inputs', 'output... |
#!/usr/bin/env python3
import argparse
import logging
import os
import sys
import time
import youtube_dl
import xlsxwriter
import shutil
import re
from requests import get
import formats
logging.getLogger('requests.packages.urllib3.connectionpool').setLevel('WARNING')
logging.basicConfig(level=logging.INFO,
... | [
"logging.basicConfig",
"logging.getLogger",
"logging.StreamHandler",
"argparse.ArgumentParser",
"logging.Formatter",
"formats.DMAX",
"requests.get",
"time.sleep",
"os.path.isfile",
"youtube_dl.YoutubeDL",
"sys.exit",
"xlsxwriter.Workbook"
] | [((271, 448), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""[%(levelname)-7s] (%(asctime)s) %(filename)s::%(lineno)d %(message)s"""', 'datefmt': '"""%Y-%m-%d %H:%M:%S"""', 'filename': '"""main.log"""'}), "(level=logging.INFO, format=\n '[%(levelname)-7s] (%(asctime)s) %(f... |
import sys, random
string_keys = ['test','jason','asdf','defg','DEADBEEF']
opt = sys.argv
if(len(opt) != 5):
print("Expecting 4 values - length of a table, length of b table, file for a table and file for b table")
exit(-1)
# hardcoded values
# we let the probablility attribute b.x is equal to 3 to be 0.4 (arbitra... | [
"random.random"
] | [((864, 879), 'random.random', 'random.random', ([], {}), '()\n', (877, 879), False, 'import sys, random\n'), ((699, 714), 'random.random', 'random.random', ([], {}), '()\n', (712, 714), False, 'import sys, random\n'), ((1014, 1029), 'random.random', 'random.random', ([], {}), '()\n', (1027, 1029), False, 'import sys, ... |
#!/usr/bin/env python
"""CLI to make working with Advent of Code slightly simpler
"""
import argparse
import json
import os
import webbrowser
from datetime import datetime
import pkg_resources
import requests
HTTPIE_SESSION_PATH = os.path.join(os.path.expanduser("~"), ".config", "httpie", "sessions", "adventofcode.c... | [
"os.path.exists",
"argparse.ArgumentParser",
"pkg_resources.resource_filename",
"requests.get",
"json.load",
"datetime.datetime.now",
"os.path.dirname",
"webbrowser.open_new_tab",
"os.path.expanduser"
] | [((247, 270), 'os.path.expanduser', 'os.path.expanduser', (['"""~"""'], {}), "('~')\n", (265, 270), False, 'import os\n'), ((2349, 2456), 'pkg_resources.resource_filename', 'pkg_resources.resource_filename', (['f"""ibidem.advent_of_code.y{now.year}"""', 'f"""{prefix}dec{now.day:02}.{ext}"""'], {}), "(f'ibidem.advent_of... |
'''
Example super simple easy_gui application.
'''
import sys; sys.path.insert(1, '..') # Just enables below import of dev library as if normally installed
import easy_gui
class GUI(easy_gui.EasyGUI):
def __init__(self):
self.add_widget(type='label', text='Example Label')
self.add_widget(type='b... | [
"sys.path.insert"
] | [((63, 87), 'sys.path.insert', 'sys.path.insert', (['(1)', '""".."""'], {}), "(1, '..')\n", (78, 87), False, 'import sys\n')] |
import gi, logging, math
gi.require_version('Gtk', '3.0')
gi.require_version('PangoCairo', '1.0')
from gi.repository import Gtk, Gdk, GObject, Pango, PangoCairo
from . import RGBAfromString, AccountColors
class TransactionTagRenderer(Gtk.CellRenderer):
background = GObject.Property(type=str, default=None)
bac... | [
"gi.repository.GObject.Property",
"gi.repository.Gdk.RGBA",
"gi.require_version",
"gi.repository.Pango.FontDescription",
"gi.repository.PangoCairo.show_layout"
] | [((25, 57), 'gi.require_version', 'gi.require_version', (['"""Gtk"""', '"""3.0"""'], {}), "('Gtk', '3.0')\n", (43, 57), False, 'import gi, logging, math\n'), ((58, 97), 'gi.require_version', 'gi.require_version', (['"""PangoCairo"""', '"""1.0"""'], {}), "('PangoCairo', '1.0')\n", (76, 97), False, 'import gi, logging, m... |
import math
# phi - the golden ration
PHI = (1 + math.sqrt(5)) / 2
# the root of five, we need this a lot
ROOT5 = math.sqrt(5)
# returns the nth fibonacci number
def nth(n):
return round((PHI**n) / ROOT5)
| [
"math.sqrt"
] | [((116, 128), 'math.sqrt', 'math.sqrt', (['(5)'], {}), '(5)\n', (125, 128), False, 'import math\n'), ((50, 62), 'math.sqrt', 'math.sqrt', (['(5)'], {}), '(5)\n', (59, 62), False, 'import math\n')] |
import dash_labs as dl
from ..fixtures import app, test_template
import dash_core_components as dcc
def test_prevent_initial_callback_passed_through(app, test_template):
@app.callback(
inputs=[dl.Input(dcc.Slider(min=0, max=10))],
template=test_template,
prevent_initial_call=False,
)
... | [
"dash_core_components.Slider"
] | [((216, 241), 'dash_core_components.Slider', 'dcc.Slider', ([], {'min': '(0)', 'max': '(10)'}), '(min=0, max=10)\n', (226, 241), True, 'import dash_core_components as dcc\n'), ((482, 507), 'dash_core_components.Slider', 'dcc.Slider', ([], {'min': '(0)', 'max': '(10)'}), '(min=0, max=10)\n', (492, 507), True, 'import da... |
#
# 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
# ... | [
"yaml.safe_load",
"json.loads",
"magnum.i18n._",
"six.text_type"
] | [((1158, 1188), 'magnum.i18n._', '_', (['"""\'manifest\' can\'t be empty"""'], {}), '("\'manifest\' can\'t be empty")\n', (1159, 1188), False, 'from magnum.i18n import _\n'), ((1275, 1299), 'json.loads', 'json.loads', (['manifest_str'], {}), '(manifest_str)\n', (1285, 1299), False, 'import json\n'), ((1346, 1374), 'yam... |
__author__ = '<NAME>'
__copyright__ = 'Copyright 2017, Profactor GmbH'
__license__ = 'BSD'
import numpy as np
import pandas as pd
import os
import matplotlib.pyplot as plt
import cv2
def crop(img, border):
return img[border[1]:-border[1], border[0]:-border[0]]
if __name__ == '__main__':
import argparse
... | [
"numpy.mean",
"numpy.savez",
"argparse.ArgumentParser",
"pandas.DataFrame.from_csv",
"numpy.stack",
"os.path.dirname",
"cv2.imread"
] | [((329, 451), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Create mean depth images for RGB/IR by averaging over redundant captures."""'}), "(description=\n 'Create mean depth images for RGB/IR by averaging over redundant captures.'\n )\n", (352, 451), False, 'import argparse\n')... |
from datetime import timedelta
import os
from typing import Dict, List, Optional, Tuple
from urllib.parse import urlparse
from .base_config import BaseConfig, ConfigError, configfield, Lookup
class RegistryConfig(BaseConfig):
name: str
datasource: str
public_url: str
repositories: List[str] = []
... | [
"os.path.exists",
"os.path.isabs",
"urllib.parse.urlparse",
"os.path.join",
"os.path.dirname",
"datetime.timedelta"
] | [((2135, 2152), 'datetime.timedelta', 'timedelta', ([], {'days': '(1)'}), '(days=1)\n', (2144, 2152), False, 'from datetime import timedelta\n'), ((1119, 1150), 'datetime.timedelta', 'timedelta', ([], {'days': 'delta_keep_days'}), '(days=delta_keep_days)\n', (1128, 1150), False, 'from datetime import timedelta\n'), ((1... |
from flask_wtf import FlaskForm
from wtforms import StringField, DateTimeField, SelectField
from wtforms.validators import DataRequired, Length
from pytz import common_timezones
def _timezones():
return [(tz, tz) for tz in common_timezones][::-1]
# event_types = [('booked', 'Booked'),
# ('reschedu... | [
"wtforms.validators.Length",
"wtforms.validators.DataRequired"
] | [((1117, 1131), 'wtforms.validators.DataRequired', 'DataRequired', ([], {}), '()\n', (1129, 1131), False, 'from wtforms.validators import DataRequired, Length\n'), ((1199, 1213), 'wtforms.validators.DataRequired', 'DataRequired', ([], {}), '()\n', (1211, 1213), False, 'from wtforms.validators import DataRequired, Lengt... |
# Generated by Django 3.2.9 on 2022-02-13 22:29
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('main', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='sitesetting',
name='admin_logo',
... | [
"django.db.models.ImageField"
] | [((329, 382), 'django.db.models.ImageField', 'models.ImageField', ([], {'default': '"""0"""', 'upload_to': '"""main/logo"""'}), "(default='0', upload_to='main/logo')\n", (346, 382), False, 'from django.db import migrations, models\n')] |
"""
An alternative to wsgi.py to run with the werkzeug server for local development.
Run with :
$ python wg.py
"""
from werkzeug.serving import run_simple
from werkzeug.wsgi import DispatcherMiddleware
from flask_app import flask_app
from app1 import app as app1
from app2 import app as app2
application = Dispatc... | [
"werkzeug.serving.run_simple",
"werkzeug.wsgi.DispatcherMiddleware"
] | [((313, 390), 'werkzeug.wsgi.DispatcherMiddleware', 'DispatcherMiddleware', (['flask_app', "{'/app1': app1.server, '/app2': app2.server}"], {}), "(flask_app, {'/app1': app1.server, '/app2': app2.server})\n", (333, 390), False, 'from werkzeug.wsgi import DispatcherMiddleware\n'), ((402, 463), 'werkzeug.serving.run_simpl... |
import abc
import numpy as np
from sklearn.metrics import accuracy_score
class BaseMetric():
def __init__(self):
self.preds = []
self.targets = []
def append(self, preds, targets):
self.preds.extend(preds.data.cpu().numpy())
self.targets.extend(targets.data.cpu().numpy())
... | [
"sklearn.metrics.accuracy_score",
"numpy.argmax"
] | [((713, 742), 'numpy.argmax', 'np.argmax', (['self.preds'], {'axis': '(1)'}), '(self.preds, axis=1)\n', (722, 742), True, 'import numpy as np\n'), ((758, 793), 'sklearn.metrics.accuracy_score', 'accuracy_score', (['preds', 'self.targets'], {}), '(preds, self.targets)\n', (772, 793), False, 'from sklearn.metrics import ... |
# coding: utf-8
# Copyright (c) 2021 AkaiKKRteam.
# Distributed under the terms of the Apache License, Version 2.0.
from pymatgen.core import Structure
from pymatgen.symmetry.analyzer import SpacegroupAnalyzer
def _make_spcecies_shortname(label: str, species: list):
"""make secies short name
Args:
l... | [
"pymatgen.symmetry.analyzer.SpacegroupAnalyzer"
] | [((4161, 4186), 'pymatgen.symmetry.analyzer.SpacegroupAnalyzer', 'SpacegroupAnalyzer', (['struc'], {}), '(struc)\n', (4179, 4186), False, 'from pymatgen.symmetry.analyzer import SpacegroupAnalyzer\n'), ((5383, 5408), 'pymatgen.symmetry.analyzer.SpacegroupAnalyzer', 'SpacegroupAnalyzer', (['struc'], {}), '(struc)\n', (5... |
from fireworks import FiretaskBase, FWAction, explicit_serialize, Workflow
from atomate.utils.utils import env_chk
from atomate.vasp.database import VaspCalcDb
from atomate.vasp.fireworks.approx_neb import ImageFW
from atomate.common.powerups import powerup_by_kwargs
__author__ = "<NAME>"
__email__ = "<EMAIL>"
@expl... | [
"atomate.common.powerups.powerup_by_kwargs",
"atomate.utils.utils.env_chk",
"atomate.vasp.database.VaspCalcDb.from_db_file",
"fireworks.FWAction",
"fireworks.Workflow"
] | [((3169, 3202), 'atomate.utils.utils.env_chk', 'env_chk', (["self['db_file']", 'fw_spec'], {}), "(self['db_file'], fw_spec)\n", (3176, 3202), False, 'from atomate.utils.utils import env_chk\n'), ((3218, 3262), 'atomate.vasp.database.VaspCalcDb.from_db_file', 'VaspCalcDb.from_db_file', (['db_file'], {'admin': '(True)'})... |
import os
import tensorflow as tf
from object_detection.utils import label_map_util
from object_detection.utils import visualization_utils as viz_utils
from object_detection.builders import model_builder
from object_detection.utils import config_util
import cv2
import numpy as np
from matplotlib import pyplot as plt
f... | [
"imutils.video.VideoStream",
"object_detection.builders.model_builder.build",
"object_detection.utils.visualization_utils.visualize_boxes_and_labels_on_image_array",
"os.path.join",
"imutils.video.FPS",
"numpy.array",
"cv2.circle",
"cv2.destroyAllWindows",
"object_detection.utils.label_map_util.crea... | [((1681, 1766), 'object_detection.utils.config_util.get_configs_from_pipeline_file', 'config_util.get_configs_from_pipeline_file', (['"""detect_soldiers_v5/pipeline.config"""'], {}), "('detect_soldiers_v5/pipeline.config'\n )\n", (1723, 1766), False, 'from object_detection.utils import config_util\n'), ((1780, 1849)... |
from collections import deque
from csp.variable import Variable
from csp.constraint_problem import ConstraintProblem
def pc2(constraint_problem: ConstraintProblem) -> bool:
variable_diffvariable_neighbor_triplets = deque()
variables = constraint_problem.get_variables()
for var in variables:
for ne... | [
"collections.deque"
] | [((221, 228), 'collections.deque', 'deque', ([], {}), '()\n', (226, 228), False, 'from collections import deque\n')] |
import dataloader as dl
# Path to the ANI-1x data set
path_to_h5file = '/home/jujuman/Scratch/Research/ANI-1x1ccx/FINAL_CLEANED_DATA/ani1x-20190925_rz.h5'
# List of keys to point to requested data
data_keys = ['<KEY>','<KEY>'] # Original ANI-1x data (https://doi.org/10.1063/1.5023802)
#data_keys = ['<KEY>','<KEY>'] #... | [
"dataloader.iter_data_buckets"
] | [((730, 782), 'dataloader.iter_data_buckets', 'dl.iter_data_buckets', (['path_to_h5file'], {'keys': 'data_keys'}), '(path_to_h5file, keys=data_keys)\n', (750, 782), True, 'import dataloader as dl\n')] |
# -*- coding: utf-8 -*-
# ------------------------------------------------------------
# streamondemand-pureita / XBMC Plugin
# Canale guardaserieonline
# http://www.mimediacenter.info/foro/viewtopic.php?f=36&t=7808
# ------------------------------------------------------------
import re
from core import httptools
fr... | [
"core.scrapertools.decodeHtmlentities",
"re.compile",
"core.item.Item",
"core.httptools.downloadpage",
"core.scrapertools.get_match",
"sys.exc_info",
"core.servertools.find_video_items",
"core.scrapertools.find_single_match",
"core.logger.error",
"re.sub",
"core.logger.info"
] | [((615, 681), 'core.logger.info', 'logger.info', (['"""streamondemand-pureita [GuardaSerieOnline mainlist]"""'], {}), "('streamondemand-pureita [GuardaSerieOnline mainlist]')\n", (626, 681), False, 'from core import logger\n'), ((3007, 3083), 'core.logger.info', 'logger.info', (["('streamondemand-pureita [GuardaSerieOn... |
import itertools
def possible_permutations(elements):
for el in list(itertools.permutations(elements)):
yield list(el)
# def possible_permutations(elements):
# if len(elements) <= 1:
# yield elements
# else:
# for perm in possible_permutations(elements[1:]):
# for i i... | [
"itertools.permutations"
] | [((75, 107), 'itertools.permutations', 'itertools.permutations', (['elements'], {}), '(elements)\n', (97, 107), False, 'import itertools\n')] |
"""
LRGAN
-----
Implements the latent regressor GAN well described in the BicycleGAN paper[1].
It introduces an encoder network which maps the generator output back to the latent
input space. This should help to prevent mode collapse and improve image variety.
Losses:
- Generator: Binary cross-entropy + L1-latent... | [
"torch.zeros_like",
"torch.ones_like",
"torch.nn.L1Loss"
] | [((6574, 6629), 'torch.zeros_like', 'torch.zeros_like', (['fake_predictions'], {'requires_grad': '(False)'}), '(fake_predictions, requires_grad=False)\n', (6590, 6629), False, 'import torch\n'), ((6728, 6782), 'torch.ones_like', 'torch.ones_like', (['real_predictions'], {'requires_grad': '(False)'}), '(real_predictions... |
import torch
import torch.nn as nn
import torchvision
class HopeNet(nn.Module):
# Hopenet with 3 output layers for yaw, pitch and roll
# Predicts Euler angles by binning and regression with the expected value
def __init__(self, block, layers, num_bins):
super(HopeNet, self).__init__()
if b... | [
"torch.nn.BatchNorm2d",
"torch.nn.ReLU",
"torch.nn.Sequential",
"torch.exp",
"torch.nn.Conv2d",
"torch.nn.MaxPool2d",
"torch.sum",
"torch.nn.Linear",
"torch.nn.AvgPool2d",
"torch.arange"
] | [((443, 507), 'torch.nn.Conv2d', 'nn.Conv2d', (['(3)', '(64)'], {'kernel_size': '(7)', 'stride': '(2)', 'padding': '(3)', 'bias': '(False)'}), '(3, 64, kernel_size=7, stride=2, padding=3, bias=False)\n', (452, 507), True, 'import torch.nn as nn\n'), ((527, 545), 'torch.nn.BatchNorm2d', 'nn.BatchNorm2d', (['(64)'], {}),... |
# coding: utf8
from skimage.io import imread
from skimage.measure import label
from openslide import OpenSlide
import numpy
import sys
from skimage.morphology import dilation
import os
import pickle
slidename = str(sys.argv[1])
probapath = str(sys.argv[2])
offsetx = 0
offsety = 0
slide = OpenSlide(slidename)
prob... | [
"os.path.exists",
"pickle.dump",
"numpy.where",
"skimage.io.imread",
"numpy.zeros",
"openslide.OpenSlide"
] | [((294, 314), 'openslide.OpenSlide', 'OpenSlide', (['slidename'], {}), '(slidename)\n', (303, 314), False, 'from openslide import OpenSlide\n'), ((329, 346), 'skimage.io.imread', 'imread', (['probapath'], {}), '(probapath)\n', (335, 346), False, 'from skimage.io import imread\n'), ((424, 452), 'numpy.where', 'numpy.whe... |
import requests
import os
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
from src.utils import general as gen
import re
import random
import time
from functools import partial
from multiprocessing.dummy import Pool as ThreadPool
from multiprocessing import cpu_count
from src.utils.txtDat... | [
"requests.Session",
"multiprocessing.cpu_count",
"time.sleep",
"src.utils.general.make_directory",
"src.utils.general.ext_finder",
"re.search",
"os.path.exists",
"src.utils.general.WebDriverChrome",
"src.utils.general.cookies_expiry_check",
"src.utils.general.successful_download_dict.append",
"o... | [((915, 933), 'requests.Session', 'requests.Session', ([], {}), '()\n', (931, 933), False, 'import requests\n'), ((950, 1024), 'urllib3.util.retry.Retry', 'Retry', ([], {'total': '(10)', 'backoff_factor': '(0.3)', 'status_forcelist': '[500, 502, 503, 504]'}), '(total=10, backoff_factor=0.3, status_forcelist=[500, 502, ... |
# -*- coding: utf-8 -*-
# Copyright (c) 2018-2021, earthobservations developers.
# Distributed under the MIT License. See LICENSE for more info.
import logging
from datetime import datetime, timezone
from itertools import repeat
from typing import Dict, List, Optional, Union
import pandas as pd
from pandas import Time... | [
"logging.getLogger",
"pandas.Interval",
"wetterdienst.provider.dwd.index._create_file_index_for_dwd_server",
"wetterdienst.provider.dwd.observation.metaindex.create_meta_index_for_climate_observations",
"pandas.to_datetime",
"itertools.repeat",
"datetime.datetime",
"wetterdienst.provider.dwd.observati... | [((2477, 2504), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (2494, 2504), False, 'import logging\n'), ((3202, 3278), 'wetterdienst.provider.dwd.observation.metadata.resolution.RESOLUTION_TO_DATETIME_FORMAT_MAPPING.get', 'RESOLUTION_TO_DATETIME_FORMAT_MAPPING.get', (['self.stations.stat... |
###Hand Evaluation Class
import card_deck
class HandEvaluation:
#this method will determine the makeup of the dealer hand
def dealer_upcard(dealer_hand):
card_deck_dict = card_deck.CardBuilder.card_builder_dict()
dealer_show = dealer_hand[1]
dealer_up_value = card_deck_dict[dealer_show... | [
"card_deck.CardBuilder.card_builder_dict"
] | [((189, 230), 'card_deck.CardBuilder.card_builder_dict', 'card_deck.CardBuilder.card_builder_dict', ([], {}), '()\n', (228, 230), False, 'import card_deck\n'), ((436, 477), 'card_deck.CardBuilder.card_builder_dict', 'card_deck.CardBuilder.card_builder_dict', ([], {}), '()\n', (475, 477), False, 'import card_deck\n'), (... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# *********************************************************************
# @FILE setup.py
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import sys
from setuptools import find_packages, setup
from covera... | [
"sys.stderr.write",
"setuptools.find_packages",
"sys.exit"
] | [((1302, 1313), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1310, 1313), False, 'import sys\n'), ((1939, 1954), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1952, 1954), False, 'from setuptools import find_packages, setup\n'), ((1115, 1256), 'sys.stderr.write', 'sys.stderr.write', (['"""\n Th... |
import sys
sys.path.append("environments")
from environment_c8y import EnvironmentC8y
"""
Run connection test while being connected (positive case):
Given a configured system with configured certificate
When we setup EnvironmentC8y
When we execute `sudo tedge connect c8y --test`
When we validate stdout
When we clean... | [
"sys.path.append"
] | [((12, 43), 'sys.path.append', 'sys.path.append', (['"""environments"""'], {}), "('environments')\n", (27, 43), False, 'import sys\n')] |
# Standard libaries
from math import log, floor
import datetime
# Third party libraries
import pandas as pd
import discord
def human_format(number: float) -> str:
"""
Takes a number and returns a human readable string.
Taken from: https://stackoverflow.com/questions/579310/formatting-long-numbers-as-stri... | [
"math.log",
"datetime.datetime.utcnow"
] | [((3249, 3275), 'datetime.datetime.utcnow', 'datetime.datetime.utcnow', ([], {}), '()\n', (3273, 3275), False, 'import datetime\n'), ((681, 695), 'math.log', 'log', (['number', 'k'], {}), '(number, k)\n', (684, 695), False, 'from math import log, floor\n')] |
from requests import Request
from backend.database.objects import Game
from backend.blueprints.spa_api.service_layers.replay.json_tag import JsonTag
from backend.database.wrapper.tag_wrapper import TagWrapper
from tests.utils.location_utils import LOCAL_URL
from tests.utils.test_utils import check_array_equal
class ... | [
"backend.blueprints.spa_api.service_layers.replay.json_tag.JsonTag.get_encoded_private_key",
"backend.blueprints.spa_api.service_layers.replay.json_tag.JsonTag.encode_tag",
"tests.utils.test_utils.check_array_equal",
"requests.Request"
] | [((413, 465), 'requests.Request', 'Request', (['"""GET"""', "(LOCAL_URL + '/api/replay')"], {'params': '{}'}), "('GET', LOCAL_URL + '/api/replay', params={})\n", (420, 465), False, 'from requests import Request\n'), ((666, 767), 'requests.Request', 'Request', (['"""GET"""', "(LOCAL_URL + '/api/replay')"], {'params': "{... |
from __future__ import annotations
import yaml
from importlib.resources import read_text
from ...config.junos import JunosMetricConfiguration
from ...devices import junosdevice
from ...utitlities import create_list_from_dict
from .. import junos
from ..base import Collector
from . import base
class BGPCollector(Col... | [
"importlib.resources.read_text",
"yaml.load"
] | [((354, 382), 'importlib.resources.read_text', 'read_text', (['junos', '"""bgp.yaml"""'], {}), "(junos, 'bgp.yaml')\n", (363, 382), False, 'from importlib.resources import read_text\n'), ((734, 773), 'yaml.load', 'yaml.load', (['file'], {'Loader': 'yaml.SafeLoader'}), '(file, Loader=yaml.SafeLoader)\n', (743, 773), Fal... |
# Copyright 2014 OpenStack Foundation
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless requ... | [
"tempest.lib.common.utils.data_utils.rand_name",
"testtools.testcase.attr"
] | [((1161, 1201), 'testtools.testcase.attr', 'tc.attr', (['base.TAG_NEGATIVE', 'base.TAG_API'], {}), '(base.TAG_NEGATIVE, base.TAG_API)\n', (1168, 1201), True, 'from testtools import testcase as tc\n'), ((1451, 1491), 'testtools.testcase.attr', 'tc.attr', (['base.TAG_NEGATIVE', 'base.TAG_API'], {}), '(base.TAG_NEGATIVE, ... |
# This code is licensed under the New BSD License
# 2009, <NAME> <<EMAIL>>
# For other contacts, visit http://aartemenko.com
"""
This is a helper to work with MongoDB's documents.
Author: <NAME> <<EMAIL>>
"""
import types
from pymongo.dbref import DBRef
from mongobongo.attributed import AttributedDict
_DEFAULT_OPTI... | [
"mongobongo.attributed.AttributedDict"
] | [((7479, 7500), 'mongobongo.attributed.AttributedDict', 'AttributedDict', (['value'], {}), '(value)\n', (7493, 7500), False, 'from mongobongo.attributed import AttributedDict\n')] |
import face_recognition as fc
import cv2 as cv
import time
import json
test_pic_path = "data_pic/jordan_web_2.jpg"
# img = cv.imread(test_pic_path)
# cv.resize(img,(),)
fs = open("data_pic/1871_pic_list.json",'r+')
pic_dict = json.load(fs)
pic_num = pic_dict['num']
pic_list = pic_dict['path']
distance_list = []
nam... | [
"time.ctime",
"json.dumps",
"face_recognition.face_distance",
"face_recognition.load_image_file",
"face_recognition.face_encodings",
"json.load"
] | [((228, 241), 'json.load', 'json.load', (['fs'], {}), '(fs)\n', (237, 241), False, 'import json\n'), ((347, 380), 'face_recognition.load_image_file', 'fc.load_image_file', (['test_pic_path'], {}), '(test_pic_path)\n', (365, 380), True, 'import face_recognition as fc\n'), ((982, 1017), 'json.dumps', 'json.dumps', (['res... |
"""
Author: <NAME>
Construct paper sequence for papers/authors predict_paper.
"""
import sys
import os
BASE_PATH = os.path.abspath(os.path.join(os.getcwd()))
sys.path.append(BASE_PATH)
import pickle
import random
import numpy as np
import config
dataset_ids = dict()
min_citations = config.min_citations
seed = 1234
#... | [
"pickle.dump",
"random.shuffle",
"pickle.load",
"random.seed",
"os.getcwd",
"numpy.concatenate",
"sys.path.append"
] | [((158, 184), 'sys.path.append', 'sys.path.append', (['BASE_PATH'], {}), '(BASE_PATH)\n', (173, 184), False, 'import sys\n'), ((785, 802), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (796, 802), False, 'import random\n'), ((803, 820), 'random.shuffle', 'random.shuffle', (['l'], {}), '(l)\n', (817, 820), F... |
from django_viewset import URLView
from ..backend import BaseBackend
from .views import AdministrationView, PasswordChangeView
class AdministrationBackend(BaseBackend):
index = URLView(r'^$', AdministrationView)
password_change = URLView(r'^password_change/$', PasswordChangeView)
| [
"django_viewset.URLView"
] | [((183, 216), 'django_viewset.URLView', 'URLView', (['"""^$"""', 'AdministrationView'], {}), "('^$', AdministrationView)\n", (190, 216), False, 'from django_viewset import URLView\n'), ((240, 289), 'django_viewset.URLView', 'URLView', (['"""^password_change/$"""', 'PasswordChangeView'], {}), "('^password_change/$', Pas... |
# coding: utf8
from __future__ import unicode_literals
import csv
import logging
from six import BytesIO
from django.db import connection
DATASET_SHORT = {'Binford': 'B'}
def delete_all(model):
model.objects.all().delete()
with connection.cursor() as c:
c.execute(
"ALTER SEQUENCE %s_id_... | [
"logging.getLogger",
"logging.StreamHandler",
"logging.warn",
"logging.Formatter",
"django.db.connection.cursor",
"logging.FileHandler"
] | [((543, 562), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (560, 562), False, 'import logging\n'), ((672, 703), 'logging.FileHandler', 'logging.FileHandler', (['"""load.log"""'], {}), "('load.log')\n", (691, 703), False, 'import logging\n'), ((826, 849), 'logging.StreamHandler', 'logging.StreamHandler', ... |
import unittest
import transaction
from pyramid import testing
from dbas.database import DBDiscussionSession
from dbas.database.discussion_model import StatementReference, Statement
from dbas.tests.utils import construct_dummy_request
from dbas.views import set_references, get_reference
class AjaxReferencesTest(uni... | [
"dbas.tests.utils.construct_dummy_request",
"dbas.views.get_reference",
"dbas.database.DBDiscussionSession.query",
"pyramid.testing.setUp",
"transaction.commit",
"dbas.views.set_references"
] | [((381, 396), 'pyramid.testing.setUp', 'testing.setUp', ([], {}), '()\n', (394, 396), False, 'from pyramid import testing\n'), ((653, 724), 'dbas.tests.utils.construct_dummy_request', 'construct_dummy_request', ([], {'json_body': "{'uids': [14], 'is_argument': False}"}), "(json_body={'uids': [14], 'is_argument': False}... |
from pyscf import gto, scf
import pyqmc
import parsl
import logging
import pandas as pd
from pyqmc.parsltools import (
clean_pyscf_objects,
distvmc,
line_minimization,
distdmc_propagate
)
from pyqmc import rundmc, EnergyAccumulator
#############################
# Set up the parallelization
############... | [
"pyqmc.initial_guess",
"random.choice",
"pyqmc.parsltools.clean_pyscf_objects",
"pyscf.gto.M",
"parsl.launchers.SimpleLauncher",
"pyqmc.EnergyAccumulator",
"parsl.channels.LocalChannel",
"pyqmc.parsltools.line_minimization",
"pyqmc.slater_jastrow",
"pandas.DataFrame",
"pyscf.scf.RHF",
"parsl.l... | [((1515, 1603), 'pyscf.gto.M', 'gto.M', ([], {'atom': '"""O 0 0 0; H 0 -2.757 2.587; H 0 2.757 2.587"""', 'basis': '"""bfd_vtz"""', 'ecp': '"""bfd"""'}), "(atom='O 0 0 0; H 0 -2.757 2.587; H 0 2.757 2.587', basis='bfd_vtz',\n ecp='bfd')\n", (1520, 1603), False, 'from pyscf import gto, scf\n'), ((1727, 1755), 'pyqmc.... |
import importlib
import os
import schumt.builder
builder = schumt.builder.Builder()
for _filename in os.listdir(os.path.dirname(__file__)):
if not _filename.endswith('.py') or '__' in _filename:
continue
importlib.import_module(__package__ + '.' + _filename[:-3])
| [
"os.path.dirname",
"importlib.import_module"
] | [((115, 140), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (130, 140), False, 'import os\n'), ((223, 282), 'importlib.import_module', 'importlib.import_module', (["(__package__ + '.' + _filename[:-3])"], {}), "(__package__ + '.' + _filename[:-3])\n", (246, 282), False, 'import importlib\n')... |
import os
path = input("Enter Path to list: ")
os.system('ls -lrt ' + path)
| [
"os.system"
] | [((48, 76), 'os.system', 'os.system', (["('ls -lrt ' + path)"], {}), "('ls -lrt ' + path)\n", (57, 76), False, 'import os\n')] |
'''Container module that instantiate classes to accomplish IoC role'''
from templatizator.domain.repository import ConfigurationRepository, \
VariableRepository, TemplateRepository, TemplateFileRepository, \
ConfigurableRepository, ConfigurableFileRepository
from templatizator.domain.service import ProjectS... | [
"templatizator.domain.application.ConfigurableFileApplication",
"templatizator.domain.helper.Event",
"templatizator.domain.service.ProjectService",
"templatizator.domain.repository.ConfigurableRepository",
"templatizator.domain.repository.TemplateFileRepository",
"templatizator.domain.application.Variable... | [((1008, 1015), 'templatizator.domain.helper.Event', 'Event', ([], {}), '()\n', (1013, 1015), False, 'from templatizator.domain.helper import Event\n'), ((1055, 1062), 'templatizator.domain.helper.Event', 'Event', ([], {}), '()\n', (1060, 1062), False, 'from templatizator.domain.helper import Event\n'), ((1129, 1154), ... |
import numpy as np
import pandas as pd
from collections import Counter
from skmultilearn.model_selection.measures import get_combination_wise_output_matrix
from skmultilearn.model_selection import iterative_train_test_split
from tqdm import tqdm
def get_section(report, section_name, section_status = False):
if rep... | [
"pandas.read_csv",
"numpy.where",
"numpy.squeeze",
"numpy.count_nonzero",
"numpy.array",
"skmultilearn.model_selection.measures.get_combination_wise_output_matrix",
"skmultilearn.model_selection.iterative_train_test_split",
"numpy.expand_dims",
"pandas.DataFrame",
"numpy.nan_to_num"
] | [((2700, 2788), 'pandas.read_csv', 'pd.read_csv', (['"""physionet.org/files/mimic-cxr-jpg/2.0.0/mimic-cxr-2.0.0-chexpert.csv"""'], {}), "(\n 'physionet.org/files/mimic-cxr-jpg/2.0.0/mimic-cxr-2.0.0-chexpert.csv')\n", (2711, 2788), True, 'import pandas as pd\n'), ((2793, 2881), 'pandas.read_csv', 'pd.read_csv', (['""... |
import sys
from os import path
sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) )
from lib.Tasks import ManualTask
from lib.Tasks import TaskMaster
import random
def test_register():
sched = TaskMaster()
init_name = '_'
n = 100
t = []
for i in range(n):
init_name = in... | [
"os.path.abspath",
"lib.Tasks.TaskMaster",
"random.choice",
"lib.Tasks.ManualTask"
] | [((219, 231), 'lib.Tasks.TaskMaster', 'TaskMaster', ([], {}), '()\n', (229, 231), False, 'from lib.Tasks import TaskMaster\n'), ((493, 505), 'lib.Tasks.TaskMaster', 'TaskMaster', ([], {}), '()\n', (503, 505), False, 'from lib.Tasks import TaskMaster\n'), ((724, 736), 'lib.Tasks.TaskMaster', 'TaskMaster', ([], {}), '()\... |
import pytest
from tagbot.web import app
@pytest.fixture
def client():
with app.test_client() as client:
yield client
@app.route("/die")
def die():
raise Exception("!")
| [
"tagbot.web.app.test_client",
"tagbot.web.app.route"
] | [((136, 153), 'tagbot.web.app.route', 'app.route', (['"""/die"""'], {}), "('/die')\n", (145, 153), False, 'from tagbot.web import app\n'), ((83, 100), 'tagbot.web.app.test_client', 'app.test_client', ([], {}), '()\n', (98, 100), False, 'from tagbot.web import app\n')] |
import sys
from ctypes import *
sys.path.append('../')
from vscp import *
# GUID conversion
gg = vscp.guid()
print("After creation:", gg.getAsString())
gg.setFromString("00:11:22:33:44:55:66:77:88:99:AA:BB:CC:DD:EE:FF")
print("guid = ", gg.getAsString())
gg.reverse()
print("reverse guid = ", gg.getAsString())
print... | [
"sys.path.append"
] | [((33, 55), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (48, 55), False, 'import sys\n')] |
# Copyright 2020 Ford Motor Company
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or ag... | [
"cookiecutterassert.test_coordinator.runAllTestsInAllFolders",
"click.argument",
"traceback.format_exc",
"click.option",
"cookiecutterassert.options_parser.create_cli_options",
"cookiecutterassert.test_coordinator.runSpecificTestFolder",
"sys.exit",
"click.command"
] | [((1147, 1162), 'click.command', 'click.command', ([], {}), '()\n', (1160, 1162), False, 'import click\n'), ((1164, 1276), 'click.option', 'click.option', (['"""--templatefolder"""'], {'default': '"""."""', 'help': '"""path of cookiecutter project directory, defaults to ."""'}), "('--templatefolder', default='.', help=... |
import torch
import torch.nn as nn
import torch.sparse
from torch.autograd import Variable
import numpy as np
import sys
from torch.autograd import Function
import math
import h5py
import json
# from . import resnet1
import matplotlib.pyplot as plt
from skimage.transform import resize
#################################... | [
"torch.mul",
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.nn.Sequential",
"torch.pow",
"torch.exp",
"numpy.array",
"torch.cuda.is_available",
"torch.sum",
"torch.squeeze",
"sys.exit",
"numpy.arange",
"torch.nn.Sigmoid",
"torch.nn.parallel.data_parallel",
"torch.mean",
"torch.floor",
"... | [((1208, 1233), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (1231, 1233), False, 'import torch\n'), ((3377, 3402), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (3400, 3402), False, 'import torch\n'), ((4437, 4455), 'torch.mm', 'torch.mm', (['S', 'input'], {}), '(S,... |
from CybORG.Agents.Wrappers import BaseWrapper, OpenAIGymWrapper, BlueTableWrapper,RedTableWrapper,EnumActionWrapper
class ChallengeWrapper(BaseWrapper):
def __init__(self, agent_name: str, env, agent=None):
super().__init__(env, agent)
self.agent_name = agent_name
if agent_name.lower() ==... | [
"CybORG.Agents.Wrappers.EnumActionWrapper",
"CybORG.Agents.Wrappers.OpenAIGymWrapper"
] | [((595, 617), 'CybORG.Agents.Wrappers.EnumActionWrapper', 'EnumActionWrapper', (['env'], {}), '(env)\n', (612, 617), False, 'from CybORG.Agents.Wrappers import BaseWrapper, OpenAIGymWrapper, BlueTableWrapper, RedTableWrapper, EnumActionWrapper\n'), ((632, 680), 'CybORG.Agents.Wrappers.OpenAIGymWrapper', 'OpenAIGymWrapp... |
"""
MutatePDB
=========
"""
import argparse
import tempfile
from Bio import PDB
from Bio.PDB.Polypeptide import aa1
from Bio.PDB.Polypeptide import aa3
from Bio.PDB.Polypeptide import one_to_three
from ssbio.protein.structure.utils.cleanpdb import CleanPDB
from ssbio.protein.structure.utils.structureio import Struct... | [
"argparse.ArgumentParser",
"ssbio.protein.structure.utils.cleanpdb.CleanPDB",
"tempfile.gettempdir",
"Bio.PDB.Polypeptide.one_to_three",
"ssbio.protein.structure.utils.structureio.StructureIO"
] | [((2464, 2521), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Mutates a PDB file"""'}), "(description='Mutates a PDB file')\n", (2487, 2521), False, 'import argparse\n'), ((3027, 3051), 'ssbio.protein.structure.utils.structureio.StructureIO', 'StructureIO', (['args.infile'], {}), '(args... |
import gym
import numpy as np
import tensorflow as tf
from tensorflow import saved_model as sm
from easy_rl.utils.window_stat import WindowStat
from easy_rl.utils.gym_wrapper.atari_wrapper import make_atari, wrap_deepmind
import time
def main():
gym_env = gym.make("CartPole-v0")
atari_env = make_atari("PongN... | [
"tensorflow.Session",
"numpy.asarray",
"easy_rl.utils.gym_wrapper.atari_wrapper.wrap_deepmind",
"tensorflow.saved_model.loader.load",
"tensorflow.saved_model.utils.get_tensor_from_tensor_info",
"time.sleep",
"easy_rl.utils.gym_wrapper.atari_wrapper.make_atari",
"easy_rl.utils.window_stat.WindowStat",
... | [((262, 285), 'gym.make', 'gym.make', (['"""CartPole-v0"""'], {}), "('CartPole-v0')\n", (270, 285), False, 'import gym\n'), ((303, 335), 'easy_rl.utils.gym_wrapper.atari_wrapper.make_atari', 'make_atari', (['"""PongNoFrameskip-v4"""'], {}), "('PongNoFrameskip-v4')\n", (313, 335), False, 'from easy_rl.utils.gym_wrapper.... |