code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from django import forms
from django.conf import settings
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Div, Layout, Row, Field
from crispy_forms.bootstrap import PrependedText
from .models import *
class PaymentStatusForm(forms.ModelForm):
id = forms.IntegerField(initial=0)
de... | [
"django.forms.HiddenInput",
"django.forms.DateInput",
"crispy_forms.helper.FormHelper",
"crispy_forms.bootstrap.PrependedText",
"crispy_forms.layout.Field",
"django.forms.IntegerField"
] | [((283, 312), 'django.forms.IntegerField', 'forms.IntegerField', ([], {'initial': '(0)'}), '(initial=0)\n', (301, 312), False, 'from django import forms\n'), ((700, 729), 'django.forms.IntegerField', 'forms.IntegerField', ([], {'initial': '(0)'}), '(initial=0)\n', (718, 729), False, 'from django import forms\n'), ((111... |
from flask import request, jsonify
from . import api
from app.models import Comment, MessageBoard, PostView, History, Post
import datetime
from sqlalchemy import func
from collections import OrderedDict
def get_certain_day_sum_visit_count(visit_date):
certain_day_visit_res = PostView.query.filter_by(
visi... | [
"collections.OrderedDict",
"sqlalchemy.func.count",
"sqlalchemy.func.sum",
"app.models.MessageBoard.query.count",
"app.models.Comment.query.count",
"datetime.datetime.now",
"app.models.History.visit_time.like",
"datetime.datetime.today",
"datetime.timedelta",
"sqlalchemy.func.date_format",
"app.... | [((617, 638), 'app.models.Comment.query.count', 'Comment.query.count', ([], {}), '()\n', (636, 638), False, 'from app.models import Comment, MessageBoard, PostView, History, Post\n'), ((723, 749), 'app.models.MessageBoard.query.count', 'MessageBoard.query.count', ([], {}), '()\n', (747, 749), False, 'from app.models im... |
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-1, 1, 50)
y = np.cos(np.linspace(0, 0.5 * np.pi))
plt.title("curve")
plt.grid()
plt.xlim(-1, 1)
plt.ylim(-1.05, +1.05)
plt.plot(x, y)
plt.show()
| [
"matplotlib.pyplot.grid",
"matplotlib.pyplot.plot",
"numpy.linspace",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.show"
] | [((56, 78), 'numpy.linspace', 'np.linspace', (['(-1)', '(1)', '(50)'], {}), '(-1, 1, 50)\n', (67, 78), True, 'import numpy as np\n'), ((120, 138), 'matplotlib.pyplot.title', 'plt.title', (['"""curve"""'], {}), "('curve')\n", (129, 138), True, 'import matplotlib.pyplot as plt\n'), ((139, 149), 'matplotlib.pyplot.grid', ... |
'''Application Exceptions'''
import logging
from fastapi import HTTPException, status
class ApplicationExceptions:
"""Application Exceptons"""
@staticmethod
def too_many_rquests():
"""Too Many Requests"""
logging.info('🛑 Request is limited')
raise HTTPException(
status... | [
"logging.info",
"fastapi.HTTPException"
] | [((235, 271), 'logging.info', 'logging.info', (['"""🛑 Request is limited"""'], {}), "('🛑 Request is limited')\n", (247, 271), False, 'import logging\n'), ((286, 381), 'fastapi.HTTPException', 'HTTPException', ([], {'status_code': 'status.HTTP_429_TOO_MANY_REQUESTS', 'detail': '"""Rate limit Exceeded"""'}), "(status_c... |
"""
Tests shelflist-app classes derived from `export.exporter.Exporter`.
"""
import pytest
import importlib
import random
# FIXTURES AND TEST DATA
# Fixtures used in the below tests can be found in ...
# django/sierra/base/tests/conftest.py:
# derive_exporter_class, new_exporter, record_sets,
# sierra_full_obj... | [
"pytest.mark.parametrize",
"random.choice"
] | [((1142, 1227), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""et_code"""', "['ItemsBibsToSolr', 'BibsAndAttachedToSolr']"], {}), "('et_code', ['ItemsBibsToSolr', 'BibsAndAttachedToSolr']\n )\n", (1165, 1227), False, 'import pytest\n'), ((7557, 7582), 'random.choice', 'random.choice', (['lcode_opts'], {... |
from typing import List, Tuple
from unittest import TestCase
import jsons
from jsons.exceptions import SerializationError
class TestIterable(TestCase):
def test_dump_list_with_cls(self):
class A:
__slots__ = ['a']
def __init__(self, a):
self.a = a
class B... | [
"jsons.dump"
] | [((521, 556), 'jsons.dump', 'jsons.dump', (['l', 'List[A]'], {'strict': '(True)'}), '(l, List[A], strict=True)\n', (531, 556), False, 'import jsons\n'), ((575, 610), 'jsons.dump', 'jsons.dump', (['l', 'List[B]'], {'strict': '(True)'}), '(l, List[B], strict=True)\n', (585, 610), False, 'import jsons\n'), ((897, 950), 'j... |
import smtplib
import creds as config
class EmailSender:
def send_email(self,subject, msg):
try:
#Using SMTP Client For Sending Messaged Via Gmail.
server = smtplib.SMTP('smtp.gmail.com:587')
server.ehlo()
server.starttls()
server.login(config.FROM... | [
"smtplib.SMTP"
] | [((193, 227), 'smtplib.SMTP', 'smtplib.SMTP', (['"""smtp.gmail.com:587"""'], {}), "('smtp.gmail.com:587')\n", (205, 227), False, 'import smtplib\n')] |
from django.forms import Form, CharField, ValidationError
from django.contrib.auth.models import User
class UserChangeForm(Form):
username = CharField(max_length=30, label='New username')
def clean(self):
cleaned_data = super(UserChangeForm, self).clean()
if User.objects.filter(username=clea... | [
"django.contrib.auth.models.User.objects.filter",
"django.forms.CharField",
"django.forms.ValidationError"
] | [((147, 193), 'django.forms.CharField', 'CharField', ([], {'max_length': '(30)', 'label': '"""New username"""'}), "(max_length=30, label='New username')\n", (156, 193), False, 'from django.forms import Form, CharField, ValidationError\n'), ((369, 411), 'django.forms.ValidationError', 'ValidationError', (['"""Username a... |
try:
from urllib.parse import urljoin
except ImportError: # Python 2
from urlparse import urljoin
from coffin.template import Library
from jinja2.ext import Extension
from jinja2 import nodes
from django.utils.encoding import iri_to_uri
register = Library()
class PrefixExtension(Extension):
def pa... | [
"coffin.template.Library",
"jinja2.nodes.Assign",
"jinja2.nodes.Output"
] | [((263, 272), 'coffin.template.Library', 'Library', ([], {}), '()\n', (270, 272), False, 'from coffin.template import Library\n'), ((581, 609), 'jinja2.nodes.Assign', 'nodes.Assign', (['var', 'call_node'], {}), '(var, call_node)\n', (593, 609), False, 'from jinja2 import nodes\n'), ((662, 687), 'jinja2.nodes.Output', '... |
from setuptools import setup, find_packages
from setuptools.command.develop import develop
from setuptools.command.install import install
from subprocess import check_call
with open("README.md", "r") as fh:
long_description = fh.read()
with open('./requirements.txt', 'r') as f:
requirements = []
for line ... | [
"setuptools.command.install.install.run",
"setuptools.find_packages",
"setuptools.command.develop.develop.run"
] | [((482, 499), 'setuptools.command.develop.develop.run', 'develop.run', (['self'], {}), '(self)\n', (493, 499), False, 'from setuptools.command.develop import develop\n'), ((687, 704), 'setuptools.command.install.install.run', 'install.run', (['self'], {}), '(self)\n', (698, 704), False, 'from setuptools.command.install... |
import click
from click.testing import CliRunner
from cthulhu.bin.cli import main
def test_cthulhu():
runner = CliRunner()
results = runner.invoke(main, ['--help'])
assert results.exit_code == 0
assert "Create a distributed test fixture for use on a Unix-like system." in results.output
| [
"click.testing.CliRunner"
] | [((115, 126), 'click.testing.CliRunner', 'CliRunner', ([], {}), '()\n', (124, 126), False, 'from click.testing import CliRunner\n')] |
import sys
import os
import logging
sys.path.insert(0, os.getcwd())
# from sachima.log import logger
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
PROJ_DIR = "./"
# ---------------------------------------------------------
# Superset API
# ---------------------------------------------------------
SUPERSET_W... | [
"os.path.dirname",
"os.getcwd"
] | [((55, 66), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (64, 66), False, 'import os\n'), ((131, 156), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (146, 156), False, 'import os\n')] |
# flake8: noqa
import json
import logging
import os
import re
import shlex
import xml.etree.ElementTree as ET
from xml.dom import minidom
from .. import exception
from . import process_provider, util
logger = logging.getLogger(__name__)
# TODO: NCL-3503: Finish implementation once the other components are figured o... | [
"logging.getLogger",
"os.path.exists",
"json.loads",
"xml.etree.ElementTree.parse",
"os.makedirs",
"shlex.split",
"os.path.join",
"os.path.isfile",
"json.dump"
] | [((211, 238), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (228, 238), False, 'import logging\n'), ((6113, 6135), 'xml.etree.ElementTree.parse', 'ET.parse', (['pom_xml_file'], {}), '(pom_xml_file)\n', (6121, 6135), True, 'import xml.etree.ElementTree as ET\n'), ((8982, 9009), 'json.load... |
"""Tests for Container."""
import asyncio
from unittest.mock import patch
import aiohttp
import pytest
from pyuptimerobot import (
UptimeRobot,
UptimeRobotAuthenticationException,
UptimeRobotConnectionException,
)
from pyuptimerobot.exceptions import UptimeRobotException
from tests.common import TEST_API... | [
"aiohttp.ClientSession",
"pytest.raises",
"tests.common.fixture",
"pyuptimerobot.UptimeRobot",
"unittest.mock.patch"
] | [((984, 1007), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (1005, 1007), False, 'import aiohttp\n'), ((1037, 1089), 'pyuptimerobot.UptimeRobot', 'UptimeRobot', ([], {'session': 'session', 'api_key': 'TEST_API_TOKEN'}), '(session=session, api_key=TEST_API_TOKEN)\n', (1048, 1089), False, 'from pyu... |
#!/usr/bin/env python2
"""
Generates a Purchase Order / Commercial Invoice.
All known products are included. If you are never ordering a product
again, then just don't order it. Or use the --exclude-sku option.
"""
from __future__ import print_function
import ConfigParser
import argparse
import datetime
import ite... | [
"logging.basicConfig",
"logging.getLogger",
"itertools.groupby",
"argparse.ArgumentParser",
"re.compile",
"ConfigParser.RawConfigParser",
"openpyxl.workbook.Workbook",
"openpyxl.styles.Font",
"datetime.datetime.now",
"openpyxl.styles.Alignment",
"os.path.basename",
"cctools.html_to_plain_text"... | [((590, 619), 're.compile', 're.compile', (['"""^(Length|Size)$"""'], {}), "('^(Length|Size)$')\n", (600, 619), False, 'import re\n'), ((1117, 1169), 'openpyxl.styles.Font', 'openpyxl.styles.Font', ([], {'bold': 'font_bold', 'size': 'font_size'}), '(bold=font_bold, size=font_size)\n', (1137, 1169), False, 'import openp... |
"""Convenience functions for writing netcdf files."""
import fnmatch
import logging
import os
import iris
import numpy as np
from .iris_helpers import unify_1d_cubes
logger = logging.getLogger(__name__)
VAR_KEYS = [
'long_name',
'units',
]
NECESSARY_KEYS = VAR_KEYS + [
'dataset',
'filename',
'pr... | [
"logging.getLogger",
"numpy.ma.array",
"iris.save",
"iris.coords.AuxCoord",
"os.path.join",
"iris.load_cube",
"fnmatch.filter",
"os.walk"
] | [((178, 205), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (195, 205), False, 'import logging\n'), ((3416, 3449), 'fnmatch.filter', 'fnmatch.filter', (['all_files', '"""*.nc"""'], {}), "(all_files, '*.nc')\n", (3430, 3449), False, 'import fnmatch\n'), ((6529, 6580), 'iris.coords.AuxCoor... |
"""
Sniper Bot - Python edition
Created by sheepy0125, inspired by DankMemer
02/10/2021
"""
#############
### Setup ###
#############
# Import
from utils.tools import Logger
from discord import Embed, Game, Message, User, Intents, Embed
from discord.ext import commands
from discord_slash import SlashCommand, SlashCont... | [
"utils.tools.Logger.log",
"discord.Game",
"utils.tools.Logger.log_error",
"utils.tools.Logger.warn",
"utils.tools.Logger.fatal",
"discord_slash.SlashCommand",
"json.load",
"discord.Embed",
"discord.Intents.default"
] | [((1693, 1733), 'discord_slash.SlashCommand', 'SlashCommand', (['client'], {'sync_commands': '(True)'}), '(client, sync_commands=True)\n', (1705, 1733), False, 'from discord_slash import SlashCommand, SlashContext\n'), ((2468, 2530), 'utils.tools.Logger.log', 'Logger.log', (['f"""Bot is online and is logged in as {clie... |
from src_code.lib.funcs import multi_five,add_five
print(add_five(33))
print(multi_five(33)) | [
"src_code.lib.funcs.multi_five",
"src_code.lib.funcs.add_five"
] | [((57, 69), 'src_code.lib.funcs.add_five', 'add_five', (['(33)'], {}), '(33)\n', (65, 69), False, 'from src_code.lib.funcs import multi_five, add_five\n'), ((77, 91), 'src_code.lib.funcs.multi_five', 'multi_five', (['(33)'], {}), '(33)\n', (87, 91), False, 'from src_code.lib.funcs import multi_five, add_five\n')] |
import nltk
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()
import pickle
import numpy as np
from keras.models import load_model
model = load_model('chatbot_model\chatbot_model.h5')
import json
import random
import cgi
import cgitb
from datetime import datetime
intents = json.loads(open('chat... | [
"cgi.FieldStorage",
"keras.models.load_model",
"random.choice",
"nltk.word_tokenize",
"nltk.stem.WordNetLemmatizer",
"numpy.array",
"datetime.datetime.now",
"cgitb.enable"
] | [((65, 84), 'nltk.stem.WordNetLemmatizer', 'WordNetLemmatizer', ([], {}), '()\n', (82, 84), False, 'from nltk.stem import WordNetLemmatizer\n'), ((163, 208), 'keras.models.load_model', 'load_model', (['"""chatbot_model\\\\chatbot_model.h5"""'], {}), "('chatbot_model\\\\chatbot_model.h5')\n", (173, 208), False, 'from ke... |
import csv
from pathlib import Path
equity_funding = [
{"Company": "CryptoVisors", "Amount": 200000, "Series": "A"},
{"Company": "Flutterwave", "Amount": 65000000, "Series": "D"},
{"Company": "nCino", "Amount": 80000000, "Series": "D"},
{"Company": "Privacy.com", "Amount": 10000000, "Series": "B"},
]
... | [
"csv.writer",
"pathlib.Path"
] | [((645, 676), 'pathlib.Path', 'Path', (['"""large_equity_rounds.csv"""'], {}), "('large_equity_rounds.csv')\n", (649, 676), False, 'from pathlib import Path\n'), ((773, 807), 'csv.writer', 'csv.writer', (['csvfile'], {'delimiter': '""","""'}), "(csvfile, delimiter=',')\n", (783, 807), False, 'import csv\n')] |
# Download the Python helper library from twilio.com/docs/python/install
from twilio.rest import Client
# Your Account Sid and Auth Token from twilio.com/user/account
account_sid = "<KEY>"
auth_token = "<PASSWORD>"
client = Client(account_sid, auth_token)
streams = client.sync \
.services("ISXXXXXXXXXXXXXXXXXXXXX... | [
"twilio.rest.Client"
] | [((225, 256), 'twilio.rest.Client', 'Client', (['account_sid', 'auth_token'], {}), '(account_sid, auth_token)\n', (231, 256), False, 'from twilio.rest import Client\n')] |
# Copyright 2021 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to... | [
"numpy.fromfile",
"argparse.ArgumentParser",
"mindspore.context.set_context",
"sklearn.preprocessing.StandardScaler",
"numpy.array",
"numpy.load",
"time.time",
"sklearn.svm.SVC"
] | [((1079, 1123), 'numpy.load', 'np.load', (['label_path_train'], {'allow_pickle': '(True)'}), '(label_path_train, allow_pickle=True)\n', (1086, 1123), True, 'import numpy as np\n'), ((1145, 1188), 'numpy.load', 'np.load', (['label_path_test'], {'allow_pickle': '(True)'}), '(label_path_test, allow_pickle=True)\n', (1152,... |
# This work developed by NOAA/NWS/EMC under the Apache 2.0 license.
import cartopy.crs as ccrs
class Domain:
def __init__(self, domain='global', dd=dict()):
"""
Class constructor that stores extent, xticks, and
yticks for the domain given.
Args:
domain : (str; default=... | [
"cartopy.crs.Orthographic",
"cartopy.crs.Miller",
"cartopy.crs.PlateCarree",
"cartopy.crs.LambertConformal"
] | [((11706, 11771), 'cartopy.crs.PlateCarree', 'ccrs.PlateCarree', ([], {'central_longitude': 'self.cenlon', 'globe': 'self.globe'}), '(central_longitude=self.cenlon, globe=self.globe)\n', (11722, 11771), True, 'import cartopy.crs as ccrs\n'), ((11990, 12050), 'cartopy.crs.Miller', 'ccrs.Miller', ([], {'central_longitude... |
import requests
import os
API_KEY = os.environ.get('API_KEY')
headers = {'Authorization': API_KEY, 'Accept':'application/vnd.api+json'}
def get_player_elo(player_info):
return player_info.json()['data'][0]['attributes']['stats']['rankPoints']
def retrieve_player_info(player_name):
if ''.join(list(filter(lambda x... | [
"requests.Response",
"os.environ.get"
] | [((37, 62), 'os.environ.get', 'os.environ.get', (['"""API_KEY"""'], {}), "('API_KEY')\n", (51, 62), False, 'import os\n'), ((397, 416), 'requests.Response', 'requests.Response', ([], {}), '()\n', (414, 416), False, 'import requests\n')] |
from aiogram.utils.callback_data import CallbackData
some_callback = CallbackData("new")
| [
"aiogram.utils.callback_data.CallbackData"
] | [((70, 89), 'aiogram.utils.callback_data.CallbackData', 'CallbackData', (['"""new"""'], {}), "('new')\n", (82, 89), False, 'from aiogram.utils.callback_data import CallbackData\n')] |
"""
all decorators used in moviepy go there
"""
import decorator
from moviepy.tools import cvsecs
@decorator.decorator
def outplace(f, clip, *a, **k):
""" Enables to make operations outplace """
newclip = clip.copy()
f(newclip, *a, **k)
return newclip
@decorator.decorator
def apply_to_mask(f,... | [
"moviepy.tools.cvsecs"
] | [((2184, 2194), 'moviepy.tools.cvsecs', 'cvsecs', (['*e'], {}), '(*e)\n', (2190, 2194), False, 'from moviepy.tools import cvsecs\n')] |
'''
Program: SCoUT
Version: 1.0
Author : <NAME>
Github : github.com/megz15/SC0UT
'''
search_db = ('sarrusophone:double-reeded musical instrument resembling the bassoon',
'vermigerous:bearing, containing or infested with worms',
'metrology:science of weights and measur... | [
"PySimpleGUI.Listbox",
"PySimpleGUI.popup",
"PySimpleGUI.Text",
"PySimpleGUI.Multiline",
"PySimpleGUI.theme",
"PySimpleGUI.InputText",
"PySimpleGUI.theme_background_color",
"PySimpleGUI.Image",
"PySimpleGUI.Menu",
"PySimpleGUI.Window",
"PySimpleGUI.Frame"
] | [((1019, 1041), 'PySimpleGUI.theme', 'sg.theme', (['"""DarkBlack1"""'], {}), "('DarkBlack1')\n", (1027, 1041), True, 'import PySimpleGUI as sg\n'), ((1774, 1825), 'PySimpleGUI.Window', 'sg.Window', (['"""Search"""', 'layout'], {'font': "('Helvetica', 14)"}), "('Search', layout, font=('Helvetica', 14))\n", (1783, 1825),... |
import sys
from pathlib import Path
import torch as th
import torchaudio as ta
from demucs.separate import load_track, encode_mp3
from demucs.audio import AudioFile, convert_audio_channels
from demucs.pretrained import is_pretrained, load_pretrained
from demucs.utils import apply_model, load_model
from typing import Li... | [
"demucs.separate.load_track",
"tempfile.TemporaryDirectory",
"demucs.pretrained.load_pretrained",
"pathlib.Path",
"zipfile.ZipFile",
"demucs.separate.encode_mp3",
"demucs.utils.load_model",
"torch.cuda.is_available",
"tempfile.NamedTemporaryFile",
"demucs.utils.apply_model",
"torchaudio.save",
... | [((551, 568), 'pathlib.Path', 'Path', (['"""separated"""'], {}), "('separated')\n", (555, 568), False, 'from pathlib import Path\n'), ((588, 602), 'pathlib.Path', 'Path', (['"""models"""'], {}), "('models')\n", (592, 602), False, 'from pathlib import Path\n'), ((631, 653), 'torch.cuda.is_available', 'th.cuda.is_availab... |
import logging
from pymongo import MongoClient
from pymongo.errors import ServerSelectionTimeoutError
import subprocess
import traceback
class MongoUtil:
def _start_service(self):
logging.info('starting mongod service')
logging.info('running sudo service mongodb start')
pipe = subproces... | [
"logging.basicConfig",
"subprocess.Popen",
"traceback.format_exception",
"pymongo.MongoClient",
"logging.info"
] | [((196, 235), 'logging.info', 'logging.info', (['"""starting mongod service"""'], {}), "('starting mongod service')\n", (208, 235), False, 'import logging\n'), ((245, 295), 'logging.info', 'logging.info', (['"""running sudo service mongodb start"""'], {}), "('running sudo service mongodb start')\n", (257, 295), False, ... |
from ndfinance.brokers.backtest import *
from ndfinance.core import BacktestEngine
from ndfinance.analysis.backtest.analyzer import BacktestAnalyzer
from ndfinance.analysis.technical import RateOfChange
from ndfinance.visualizers.backtest_visualizer import BasicVisualizer
from ndfinance.strategies.trend import ActualMo... | [
"ndfinance.analysis.technical.RateOfChange",
"ndfinance.reporters.make_html",
"ndfinance.strategies.trend.ActualMomentumStratagy",
"ndfinance.core.BacktestEngine"
] | [((954, 1081), 'ndfinance.strategies.trend.ActualMomentumStratagy', 'ActualMomentumStratagy', ([], {'momentum_threshold': 'momentum_threshold', 'rebalance_period': 'rebalance_period', 'momentum_label': 'f"""ROCR{n}"""'}), "(momentum_threshold=momentum_threshold,\n rebalance_period=rebalance_period, momentum_label=f'... |
import socket
import numpy as np
from select import select
import threading
import time
def clamp(x,min,max):
"Clamps the value x between `min` and `max` "
if x < min:
return min
elif x > max:
return max
else:
return x
def check_server(ip='192.168.127.12', port=23, timeout=3)... | [
"threading.Thread.__init__",
"select.select",
"socket.socket",
"time.monotonic",
"time.sleep",
"numpy.zeros"
] | [((785, 834), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (798, 834), False, 'import socket\n'), ((1773, 1812), 'numpy.zeros', 'np.zeros', (['(fps, self.packlen)', 'np.uint8'], {}), '((fps, self.packlen), np.uint8)\n', (1781, 1812), True, '... |
# -*- coding: utf-8 -*-
from django import forms
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
from django.utils.translation import ugettext as _
from django.contrib.auth.hashers import check_password
from usuario.models import Usuario
#from usuario.models import NuevoU... | [
"django.contrib.auth.models.User",
"django.forms.CharField",
"django.contrib.auth.hashers.check_password",
"django.forms.PasswordInput",
"django.contrib.auth.models.User.objects.filter",
"django.utils.translation.ugettext"
] | [((1307, 1324), 'django.forms.CharField', 'forms.CharField', ([], {}), '()\n', (1322, 1324), False, 'from django import forms\n'), ((1346, 1403), 'django.forms.CharField', 'forms.CharField', ([], {'widget': 'forms.HiddenInput', 'required': '(False)'}), '(widget=forms.HiddenInput, required=False)\n', (1361, 1403), False... |
import datetime
from nose.tools import eq_
import webhelpers.feedgenerator as fg
def test_simple_feed():
pubdate = datetime.datetime(2009, 12, 18, 23, 45, 12)
feed = fg.Rss201rev2Feed(
title="Poynter E-Media Tidbits",
link="http://www.poynter.org/column.asp?id=31",
description="A grou... | [
"datetime.datetime",
"webhelpers.feedgenerator.Rss201rev2Feed",
"nose.tools.eq_",
"webhelpers.feedgenerator.GeoAtom1Feed"
] | [((122, 165), 'datetime.datetime', 'datetime.datetime', (['(2009)', '(12)', '(18)', '(23)', '(45)', '(12)'], {}), '(2009, 12, 18, 23, 45, 12)\n', (139, 165), False, 'import datetime\n'), ((177, 396), 'webhelpers.feedgenerator.Rss201rev2Feed', 'fg.Rss201rev2Feed', ([], {'title': '"""Poynter E-Media Tidbits"""', 'link': ... |
from flask import Flask
from .config import app_config
from .controllers.HomeController import home_api
def create_app(env_name):
"""
param: env_name
Create app
"""
# app initiliazation
app = Flask(__name__)
app.config.from_object(app_config[env_name])
app.register_blueprint(home... | [
"flask.Flask"
] | [((224, 239), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (229, 239), False, 'from flask import Flask\n')] |
import os
import sys
import json
import traceback
import argparse
import time
import multiprocessing
import ray
from ray import tune
from ray.tune.schedulers import AsyncHyperBandScheduler
from ray.tune.suggest.hyperopt import HyperOptSearch
from ray.tune.suggest import ConcurrencyLimiter
from hyperopt import hp
fro... | [
"generator.Generator",
"logger.get_logger",
"ray.tune.suggest.ConcurrencyLimiter",
"multiprocessing.cpu_count",
"time.sleep",
"tensorflow.config.list_physical_devices",
"ray.init",
"ray.tune.schedulers.AsyncHyperBandScheduler",
"tensorflow.keras.optimizers.Nadam",
"argparse.ArgumentParser",
"hyp... | [((474, 523), 'logger.get_logger', 'Logger.get_logger', (['"""hyper_fcn"""', '"""./logs/training"""'], {}), "('hyper_fcn', './logs/training')\n", (491, 523), True, 'import logger as Logger\n'), ((5568, 5646), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Optimize RetinaNet anchor config... |
import numpy as np
import matplotlib.pyplot as plt
import uncertainties
from scipy.signal import find_peaks
from scipy.optimize import curve_fit
import scipy.constants as sc
import scipy.integrate as integrate
from uncertainties import ufloat
from uncertainties import unumpy as unp
from uncertainties.unumpy import nomi... | [
"numpy.sqrt",
"matplotlib.pyplot.ylabel",
"numpy.array",
"uncertainties.ufloat",
"numpy.genfromtxt",
"numpy.arange",
"matplotlib.pyplot.xlabel",
"numpy.asarray",
"numpy.exp",
"numpy.linspace",
"uncertainties.unumpy.nominal_values",
"scipy.signal.find_peaks",
"uncertainties.unumpy.std_devs",
... | [((547, 614), 'numpy.genfromtxt', 'np.genfromtxt', (['"""2018-12-10_Nitschke_Pape/Probe_21.Spe"""'], {'unpack': '(True)'}), "('2018-12-10_Nitschke_Pape/Probe_21.Spe', unpack=True)\n", (560, 614), True, 'import numpy as np\n'), ((634, 677), 'numpy.genfromtxt', 'np.genfromtxt', (['"""EuropiumQ.txt"""'], {'unpack': '(True... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# sum-words.py
# Description: Using Constraint Processing for solving a simple sum-words brain teaser
# -----------------------------------------------------------------------------
#
# Login <<EMAIL>>
#
"""
Using Constraint Processing for solving a simple sum-words br... | [
"constraint.AllDifferentConstraint",
"constraint.Problem"
] | [((1035, 1055), 'constraint.Problem', 'constraint.Problem', ([], {}), '()\n', (1053, 1055), False, 'import constraint\n'), ((1836, 1871), 'constraint.AllDifferentConstraint', 'constraint.AllDifferentConstraint', ([], {}), '()\n', (1869, 1871), False, 'import constraint\n')] |
import scipy.stats as ss
import numpy as np
def read_data(path):
file = open(path)
lines = file.readlines()
file.close()
dic = {}
for line in lines[1:]:
sl = line.split(',')
pid = int(sl[0].split('_')[0])
data_len = float(sl[1])
dic[pid] = data_len
return dic
def main():
no_data = read_... | [
"BCI.gen_kv_idx",
"numpy.transpose",
"matplotlib.pyplot.savefig",
"sklearn.discriminant_analysis.LinearDiscriminantAnalysis",
"numpy.ones",
"numpy.log",
"scipy.signal.butter",
"numpy.array",
"numpy.zeros",
"scipy.stats.ttest_rel",
"matplotlib.pyplot.bar",
"scipy.signal.lfilter",
"numpy.conca... | [((1094, 1115), 'scipy.stats.mannwhitneyu', 'ss.mannwhitneyu', (['x', 'y'], {}), '(x, y)\n', (1109, 1115), True, 'import scipy.stats as ss\n'), ((1149, 1167), 'scipy.stats.ttest_rel', 'ss.ttest_rel', (['x', 'y'], {}), '(x, y)\n', (1161, 1167), True, 'import scipy.stats as ss\n'), ((1873, 1905), 'numpy.concatenate', 'np... |
import sys
import threading
import logging
import os
import datetime
import time
import socket
import SerialPortController
class TcpSerialPortClient:
def __init__(self, server, client_socket, client_address):
self.logger = logging.getLogger("TcpSerialPortClient-{}".format(client_address))
self.se... | [
"logging.basicConfig",
"logging.getLogger",
"logging.debug",
"socket.socket",
"threading.current_thread",
"threading.Lock",
"time.sleep",
"datetime.datetime.now",
"socket.gethostname",
"threading.Thread",
"SerialPortController.SerialPortController",
"logging.info",
"SerialPortController.Seri... | [((5397, 5498), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(process)d-%(name)s-%(levelname)s-%(message)s"""', 'level': 'logging.DEBUG'}), "(format='%(process)d-%(name)s-%(levelname)s-%(message)s',\n level=logging.DEBUG)\n", (5416, 5498), False, 'import logging\n'), ((5592, 5646), 'SerialPortC... |
from django.test import SimpleTestCase
from zentral.contrib.jamf.api_client import APIClient, APIClientError
class JamfAPIClientTestCase(SimpleTestCase):
def test_base_url(self):
api_client = APIClient("host", 443, "/JSSResource", "user", "pwd", "sec")
self.assertEqual(api_client.base_url, "https:... | [
"zentral.contrib.jamf.api_client.APIClient"
] | [((206, 266), 'zentral.contrib.jamf.api_client.APIClient', 'APIClient', (['"""host"""', '(443)', '"""/JSSResource"""', '"""user"""', '"""pwd"""', '"""sec"""'], {}), "('host', 443, '/JSSResource', 'user', 'pwd', 'sec')\n", (215, 266), False, 'from zentral.contrib.jamf.api_client import APIClient, APIClientError\n'), ((3... |
import numpy as np
from bp.Model import Model
# ANN 经典 2 -> 3 -> 6 -> 1
# x = np.linspace(-1,1,20)
x = np.array([[1, 2], [2, 3], [3, 3], [1, 4], [-1, -2], [-1, -1], [-2, -3], [-3, -2]]).T
y = np.array([[0, 0, 0, 0, 1, 1, 1, 1]])
model = Model(x, y,inputType='normal')
model.addLayer(3, 'sigmoid', False)
model.addLayer(... | [
"numpy.array",
"bp.Model.Model"
] | [((193, 229), 'numpy.array', 'np.array', (['[[0, 0, 0, 0, 1, 1, 1, 1]]'], {}), '([[0, 0, 0, 0, 1, 1, 1, 1]])\n', (201, 229), True, 'import numpy as np\n'), ((238, 269), 'bp.Model.Model', 'Model', (['x', 'y'], {'inputType': '"""normal"""'}), "(x, y, inputType='normal')\n", (243, 269), False, 'from bp.Model import Model\... |
import logging
import difflib
from telegram.ext import BaseFilter
from typing import *
MINIMAL_KEYWORD_LENGTH = 7
class State:
CANCEL = 0
GENERAL_CHOOSING = 1
ORDER_CERTIFICATE_PROMPT = 20
ORDER_CERTIFICATE_AWAIT_CHOICE = 21
ORDER_CERTIFICATE_CHOICER = 30
ORDER_CERTIFICATE_NAME = 31
OR... | [
"logging.log"
] | [((835, 865), 'logging.log', 'logging.log', (['logging.INFO', 'msg'], {}), '(logging.INFO, msg)\n', (846, 865), False, 'import logging\n')] |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('profiles', '0002_auto_20151025_1127'),
]
operations = [
migrations.RenameField(
model_name='profile',
... | [
"django.db.migrations.RenameField"
] | [((252, 342), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""profile"""', 'old_name': '"""alloted"""', 'new_name': '"""allotted"""'}), "(model_name='profile', old_name='alloted', new_name=\n 'allotted')\n", (274, 342), False, 'from django.db import migrations, models\n'), ((394... |
import ezsheets
import os
import shutil
os.chdir('../credentials')
s = ezsheets.Spreadsheet('https://docs.google.com/spreadsheets/d/1buZrczeSuU_B9Nv7aLDia8wUnsa4sbNXiv6oALm2Hr8/edit#gid=0')
s.downloadAsExcel()
## Convert to xml
os.system('xls2xform saintperu.xlsx saintperu.xml ')
# Move
shutil.move('saintperu.xlsx',... | [
"os.chdir",
"os.system",
"ezsheets.Spreadsheet",
"shutil.move"
] | [((40, 66), 'os.chdir', 'os.chdir', (['"""../credentials"""'], {}), "('../credentials')\n", (48, 66), False, 'import os\n'), ((72, 200), 'ezsheets.Spreadsheet', 'ezsheets.Spreadsheet', (['"""https://docs.google.com/spreadsheets/d/1buZrczeSuU_B9Nv7aLDia8wUnsa4sbNXiv6oALm2Hr8/edit#gid=0"""'], {}), "(\n 'https://docs.g... |
import math
import numpy as np
import matplotlib.pyplot as plt
from control.timeresp import step_info
from control.matlab import tf, series, feedback, step
class RF:
def calculo(mp, ta, u, tempo, numerador, denominador, flag):
var = (math.log(mp)/-math.pi) ** 2
qsi = math.sqrt(var/(1+var))... | [
"numpy.radians",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.title",
"control.timeresp.step_info",
"control.matlab.series",
"matplotlib.pyplot.ylabel",
"numpy.absolute",
"matplotlib.pyplot.plot",
"control.matlab.tf",
"math.sqrt",
"control.matlab.step",
"matplotlib.pyplot.xlabel",
"math.log"... | [((298, 324), 'math.sqrt', 'math.sqrt', (['(var / (1 + var))'], {}), '(var / (1 + var))\n', (307, 324), False, 'import math\n'), ((549, 568), 'numpy.absolute', 'np.absolute', (['g_jwcg'], {}), '(g_jwcg)\n', (560, 568), True, 'import numpy as np\n'), ((823, 851), 'control.matlab.tf', 'tf', (['[kp[-1], ki[-1]]', '[1, 0]'... |
import os
import uuid
import time
import numpy as np
import tensorflow as tf
import external.luodong.Model2bin as mem_to_bin
mod_uuid = uuid.uuid4()
TODAY = time.strftime("%Y%m%d")
model_ids = list(np.arange(22))
mem_path = r'/home/hangz/TF_graphs/unit_test/DTLN_keras/converted_model/'
os.makedirs(os.path.join(mem_pa... | [
"external.luodong.Model2bin.auto_create_bin",
"time.strftime",
"os.path.join",
"uuid.uuid4",
"numpy.arange"
] | [((138, 150), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (148, 150), False, 'import uuid\n'), ((159, 182), 'time.strftime', 'time.strftime', (['"""%Y%m%d"""'], {}), "('%Y%m%d')\n", (172, 182), False, 'import time\n'), ((350, 472), 'external.luodong.Model2bin.auto_create_bin', 'mem_to_bin.auto_create_bin', ([], {'mem... |
from keras.models import Model
from keras.layers import Layer, Input, Dense, Activation, Bidirectional, TimeDistributed, Embedding
from keras.layers.recurrent import LSTM
from keras.layers.normalization import BatchNormalization
from self_attention import SDPA, SDPA_Q_S, SASA, SDPA_QS_KS, SDPA_Mul_S
ATTENTION_NAME_TY... | [
"keras.layers.normalization.BatchNormalization",
"keras.layers.Input",
"keras.models.Model",
"keras.layers.Activation",
"keras.layers.Dense",
"keras.layers.Embedding",
"self_attention.SDPA",
"keras.layers.recurrent.LSTM"
] | [((1032, 1056), 'keras.layers.Input', 'Input', ([], {'shape': 'input_shape'}), '(shape=input_shape)\n', (1037, 1056), False, 'from keras.layers import Layer, Input, Dense, Activation, Bidirectional, TimeDistributed, Embedding\n'), ((1322, 1345), 'keras.layers.Input', 'Input', ([], {'shape': '(max_len,)'}), '(shape=(max... |
# _*_ coding:utf-8 _*_
'''
MultilayerPerceptronClassifier
'''
from pyspark.sql import SparkSession
from pyspark.ml.classification import MultilayerPerceptronClassifier
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
spark = SparkSession.builder.appName("DecisionTree").getOrCreate()
p... | [
"pyspark.ml.evaluation.MulticlassClassificationEvaluator",
"pyspark.sql.SparkSession.builder.appName",
"pyspark.ml.classification.MultilayerPerceptronClassifier"
] | [((775, 863), 'pyspark.ml.classification.MultilayerPerceptronClassifier', 'MultilayerPerceptronClassifier', ([], {'maxIter': '(100)', 'layers': 'layers', 'blockSize': '(128)', 'seed': '(1234)'}), '(maxIter=100, layers=layers, blockSize=128,\n seed=1234)\n', (805, 863), False, 'from pyspark.ml.classification import M... |
# Generated by Django 3.0.8 on 2020-08-31 20:09
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('backend', '0022_auto_20200831_2003'),
]
operations = [
migrations.AlterField(
model_name='group',
name='firstPlaceme... | [
"django.db.models.CharField"
] | [((349, 822), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'choices': "[('Osterinsel', 'Osterinsel'), ('Prismanien', 'Prismanien'), ('Wasteland',\n 'Wasteland'), ('Erde Feuer Wasser Luft', 'Erde Feuer Wasser Luft'), (\n 'Brownsea Island', 'Brownsea Island'), ('Atlantis', 'Atlantis'),... |
import torch
import torchvision
import os
from torch import optim
from torch.autograd import Variable
from model import Discriminator
from model import Generator
class Solver(object):
def __init__(self, config, data_loader):
self.generator = None
self.discriminator = None
self.g_optimizer ... | [
"model.Discriminator",
"torch.mean",
"torch.load",
"os.path.join",
"torch.cuda.is_available",
"model.Generator",
"torch.autograd.Variable",
"torch.randn"
] | [((1107, 1193), 'model.Generator', 'Generator', ([], {'z_dim': 'self.z_dim', 'image_size': 'self.image_size', 'conv_dim': 'self.g_conv_dim'}), '(z_dim=self.z_dim, image_size=self.image_size, conv_dim=self.\n g_conv_dim)\n', (1116, 1193), False, 'from model import Generator\n'), ((1288, 1355), 'model.Discriminator', ... |
import asyncio
import os
import re
import subprocess
import sys
import traceback
from tempfile import TemporaryDirectory
from typing import List
import aiohttp
from aiohttp import web
import cachetools
from gidgethub import aiohttp as gh_aiohttp
from gidgethub import routing, sansio
import git
from config import GH_A... | [
"aiohttp.web.run_app",
"aiohttp.ClientSession",
"tempfile.TemporaryDirectory",
"cachetools.LRUCache",
"gidgethub.aiohttp.GitHubAPI",
"gidgethub.routing.Router",
"subprocess.run",
"aiohttp.web.Application",
"aiohttp.web.Response",
"os.getcwd",
"os.chdir",
"gidgethub.sansio.Event.from_http",
"... | [((378, 394), 'gidgethub.routing.Router', 'routing.Router', ([], {}), '()\n', (392, 394), False, 'from gidgethub import routing, sansio\n'), ((403, 435), 'cachetools.LRUCache', 'cachetools.LRUCache', ([], {'maxsize': '(500)'}), '(maxsize=500)\n', (422, 435), False, 'import cachetools\n'), ((1204, 1298), 're.search', 'r... |
import json
import random
from collections import defaultdict
import heapq
import pymysql.cursors
import os
# Connect to the database
import sys
connection = pymysql.connect(host=os.getenv("DB_HOST", "localhost"),
user=os.getenv("DB_USER", "root"),
password=os.... | [
"json.load",
"json.dumps",
"collections.defaultdict",
"os.getenv"
] | [((891, 915), 'collections.defaultdict', 'defaultdict', (['(lambda : [])'], {}), '(lambda : [])\n', (902, 915), False, 'from collections import defaultdict\n'), ((4084, 4096), 'json.load', 'json.load', (['f'], {}), '(f)\n', (4093, 4096), False, 'import json\n'), ((4206, 4218), 'json.load', 'json.load', (['f'], {}), '(f... |
import json
import time
import websocket
import pyrebase
from configFiles.config import config
ws = websocket.WebSocket()
ws.connect('ws://127.0.0.1:8000/ws/dashboard')
firebase = pyrebase.initialize_app(config)
authe = firebase.auth()
database = firebase.database()
def stream_handler(message):
if(message['da... | [
"pyrebase.initialize_app",
"json.dumps",
"websocket.WebSocket"
] | [((101, 122), 'websocket.WebSocket', 'websocket.WebSocket', ([], {}), '()\n', (120, 122), False, 'import websocket\n'), ((184, 215), 'pyrebase.initialize_app', 'pyrebase.initialize_app', (['config'], {}), '(config)\n', (207, 215), False, 'import pyrebase\n'), ((714, 740), 'json.dumps', 'json.dumps', (['updated_values']... |
#!/usr/bin/env python3
# coding: utf-8
from setuptools import setup
import subprocess
import os
def pipen(cmd):
# It's a popen, but with pipes.
return subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
def out_to_str(out):
return out.decode('utf-8', 'replace').strip()
def get_git_ta... | [
"os.path.exists",
"setuptools.setup",
"subprocess.Popen"
] | [((1594, 1616), 'os.path.exists', 'os.path.exists', (['""".git"""'], {}), "('.git')\n", (1608, 1616), False, 'import os\n'), ((1674, 2193), 'setuptools.setup', 'setup', ([], {'name': "version['SHORTNAME']", 'version': 'version_string', 'description': '"""ADF On-The-Go - convert your RPi Zero to Gotek-ready USB disk"""'... |
import os
import bs4
import responses
import requests
from bs4 import BeautifulSoup
from django.test import TestCase, override_settings
from wagtail.images import get_image_model
from wagtail_wordpress_import.block_builder import BlockBuilder, conf_promote_child_tags
from wagtail_wordpress_import.block_builder_default... | [
"wagtail_wordpress_import.block_builder_defaults.fetch_url",
"wagtail_wordpress_import.test.tests.utility_functions.mock_image",
"wagtail_wordpress_import.block_builder_defaults.get_absolute_src",
"wagtail_wordpress_import.block_builder_defaults.get_image_alt",
"wagtail.images.get_image_model",
"wagtail_w... | [((6419, 6508), 'django.test.override_settings', 'override_settings', ([], {'WAGTAIL_WORDPRESS_IMPORTER_SOURCE_DOMAIN': '"""http://www.example.com"""'}), "(WAGTAIL_WORDPRESS_IMPORTER_SOURCE_DOMAIN=\n 'http://www.example.com')\n", (6436, 6508), False, 'from django.test import TestCase, override_settings\n'), ((8540, ... |
from pathlib import Path
from copy import deepcopy
# Get the puzzle input data
input_file = Path(__file__).parent / "input.txt"
puzzle_data = input_file.read_text()
# ------------------------- Part 1/2 -------------------------
""" Puzzle Rules:
byr (Birth Year)
iyr (Issue Year)
eyr (Expiration Year)
hgt (Height)
hcl... | [
"pathlib.Path",
"copy.deepcopy"
] | [((649, 672), 'copy.deepcopy', 'deepcopy', (['passport_data'], {}), '(passport_data)\n', (657, 672), False, 'from copy import deepcopy\n'), ((1184, 1207), 'copy.deepcopy', 'deepcopy', (['passport_data'], {}), '(passport_data)\n', (1192, 1207), False, 'from copy import deepcopy\n'), ((93, 107), 'pathlib.Path', 'Path', (... |
import sys
sys.path.append("Z:\\Control\\PythonPackages\\")#uncomment for ph-photonbec
#sys.path.append("D:\\People\\Vianez\\Fianium\\")#uncomment for ph-photonbec3
import pbec_ipc
port, host = pbec_ipc.PORT_NUMBERS["fianium_controller"], "localhost"
#Notes on how best to interface with the fianium_main server (... | [
"pbec_ipc.ipc_exec",
"sys.path.append",
"pbec_ipc.ipc_eval"
] | [((12, 60), 'sys.path.append', 'sys.path.append', (['"""Z:\\\\Control\\\\PythonPackages\\\\"""'], {}), "('Z:\\\\Control\\\\PythonPackages\\\\')\n", (27, 60), False, 'import sys\n'), ((510, 561), 'pbec_ipc.ipc_exec', 'pbec_ipc.ipc_exec', (['"""enableUpdate(True)"""', 'port', 'host'], {}), "('enableUpdate(True)', port, h... |
import argparse
from checker.checker import Checker
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('filePath', help='Enter the path or file want to code readable check.')
parser.add_argument('-T', '--text', help='Output the result to text file.', action='store', default=... | [
"checker.checker.Checker",
"argparse.ArgumentParser"
] | [((93, 118), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (116, 118), False, 'import argparse\n'), ((485, 530), 'checker.checker.Checker', 'Checker', (['args.filePath', 'args.text', 'args.excel'], {}), '(args.filePath, args.text, args.excel)\n', (492, 530), False, 'from checker.checker import... |
# <NAME> <<<EMAIL>>>.
# A DataProjector is an object that projects data object to a latent space
# At the moment we will use LSI types of methdos to do this
import numpy
from gensim import corpora, models, similarities,matutils
import numpy as np
import os.path
import time
import scipy.sparse
from pathlib import Path
... | [
"gensim.models.LsiModel",
"numpy.dot",
"numpy.zeros",
"gensim.matutils.corpus2csc",
"time.time",
"gensim.models.TfidfModel"
] | [((7676, 7700), 'numpy.zeros', 'np.zeros', (['self.num_terms'], {}), '(self.num_terms)\n', (7684, 7700), True, 'import numpy as np\n'), ((8069, 8115), 'numpy.dot', 'np.dot', (['new_doc_fv_normalized', 'self.term_f_mat'], {}), '(new_doc_fv_normalized, self.term_f_mat)\n', (8075, 8115), True, 'import numpy as np\n'), ((2... |
from flask_unchained import unchained
from flask_unchained.cli import cli, click
from flask_unchained.commands.utils import print_table
from .utils import _query_to_role
from ..services import RoleManager
role_manager: RoleManager = unchained.services.role_manager
@cli.group()
def roles():
"""
Role commands... | [
"flask_unchained.cli.click.echo",
"flask_unchained.commands.utils.print_table",
"flask_unchained.cli.click.confirm",
"flask_unchained.cli.cli.group",
"flask_unchained.cli.click.argument",
"flask_unchained.cli.click.option"
] | [((270, 281), 'flask_unchained.cli.cli.group', 'cli.group', ([], {}), '()\n', (279, 281), False, 'from flask_unchained.cli import cli, click\n'), ((619, 722), 'flask_unchained.cli.click.option', 'click.option', (['"""--name"""'], {'prompt': '"""Role name"""', 'help': '"""The name of the role to create, eg `ROLE_USER`."... |
from django.db import models
from django.contrib.auth.models import User
# Create your models here.
class category(models.Model):
name = models.CharField(max_length=250)
def __str__(self):
return self.name
class post(models.Model):
image = models.ImageField(upload_to='blog/', default='blog/deful... | [
"django.db.models.DateField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.db.models.ManyToManyField",
"django.db.models.DateTimeField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((143, 175), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(250)'}), '(max_length=250)\n', (159, 175), False, 'from django.db import models\n'), ((264, 327), 'django.db.models.ImageField', 'models.ImageField', ([], {'upload_to': '"""blog/"""', 'default': '"""blog/defult.jpg"""'}), "(upload_to=... |
#!/usr/bin/env python
# encoding: utf-8
import requests
import json
from fuzzywuzzy import fuzz, process
from conf import *
BASE_URL = 'http://pokeapi.co'
species_names = []
item_names = []
move_names = []
ability_names = []
colours = {
'normal': 0xA8A878,
'fire': 0xEE8130,
'water': 0x6390F0,
'electric': 0xF7D02... | [
"fuzzywuzzy.process.extractOne",
"json.loads",
"requests.get"
] | [((1313, 1330), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (1325, 1330), False, 'import requests\n'), ((1170, 1209), 'fuzzywuzzy.process.extractOne', 'process.extractOne', (['arg', 'indices[index]'], {}), '(arg, indices[index])\n', (1188, 1209), False, 'from fuzzywuzzy import fuzz, process\n'), ((1384, 1... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# logalyzer:
# Parses your bloated HTTP access logs to extract the info you want
# about hits from (hopefully) real people instead of just the endless
# stream of hackers and bots that passes for web traffic
# nowadays. Stores the info in a relational database where you c... | [
"database.Transactor",
"sift.IPMatcher",
"asynqueue.util.DeferredTracker",
"zope.interface.implements",
"twisted.internet.defer.Deferred",
"twisted.internet.defer.succeed"
] | [((1566, 1587), 'zope.interface.implements', 'implements', (['IConsumer'], {}), '(IConsumer)\n', (1576, 1587), False, 'from zope.interface import implements\n'), ((1923, 1940), 'asynqueue.util.DeferredTracker', 'DeferredTracker', ([], {}), '()\n', (1938, 1940), False, 'from asynqueue.util import DeferredTracker\n'), ((... |
import numpy as np
import cv2
import time
import datetime
from datetime import datetime, timedelta
from gazepoint import GazePoint
import multiprocessing
import os
class Webcam:
def __init__(self, base_dir):
self.base_dir = base_dir
# self.csv_filename = 'screenshot_list.csv'
self.cap0 = c... | [
"os.path.exists",
"cv2.imwrite",
"os.makedirs",
"multiprocessing.Process",
"os.path.join",
"os.getcwd",
"gazepoint.GazePoint",
"datetime.datetime.now",
"cv2.VideoCapture",
"cv2.CascadeClassifier",
"datetime.timedelta",
"time.time"
] | [((2203, 2214), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2212, 2214), False, 'import os\n'), ((2274, 2330), 'multiprocessing.Process', 'multiprocessing.Process', ([], {'target': 'Webcam.run_gaze', 'args': '()'}), '(target=Webcam.run_gaze, args=())\n', (2297, 2330), False, 'import multiprocessing\n'), ((319, 338), '... |
import getpass
import os
import platform
from loguru import logger
def logger_init() -> None:
"""Configure loguru logger."""
logger.remove() # remove stdout/stderr logging since this is a CLI
is_travis = "TRAVIS" in os.environ # running in travis ci
usrname = getpass.getuser()
if platform.sys... | [
"getpass.getuser",
"loguru.logger.add",
"platform.system",
"loguru.logger.remove"
] | [((136, 151), 'loguru.logger.remove', 'logger.remove', ([], {}), '()\n', (149, 151), False, 'from loguru import logger\n'), ((282, 299), 'getpass.getuser', 'getpass.getuser', ([], {}), '()\n', (297, 299), False, 'import getpass\n'), ((801, 878), 'loguru.logger.add', 'logger.add', (['log_path'], {'format': 'log_format',... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# https://docs.python.org/3/library/tkinter.html
import tkinter as tk
from tkinter import messagebox
def center_window(root, width=300, height=200):
# get screen width and height
screen_width = root.winfo_screenwidth()
screen_heig... | [
"tkinter.messagebox.showwarning",
"tkinter.messagebox.showerror",
"tkinter.Button",
"tkinter.Tk",
"tkinter.Label",
"tkinter.messagebox.showinfo"
] | [((764, 771), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (769, 771), True, 'import tkinter as tk\n'), ((831, 892), 'tkinter.Label', 'tk.Label', (['app'], {'text': '"""Hello World!"""', 'font': '"""Arial 16"""', 'fg': '"""red"""'}), "(app, text='Hello World!', font='Arial 16', fg='red')\n", (839, 892), True, 'import tkint... |
# Copyright 2020 Xilinx Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"logging.getLogger",
"os.path.exists",
"os.makedirs",
"subprocess.Popen",
"os.getcwd",
"os.path.realpath",
"os.path.isfile",
"pyxir.graph.partitioning.xgraph_partitioner.XGraphPartitioner",
"pyxir.graph.xgraph_factory.XGraphFactory"
] | [((964, 990), 'logging.getLogger', 'logging.getLogger', (['"""pyxir"""'], {}), "('pyxir')\n", (981, 990), False, 'import logging\n'), ((1020, 1046), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (1036, 1046), False, 'import os\n'), ((1168, 1187), 'pyxir.graph.partitioning.xgraph_partitione... |
import os
import nltk
import numpy as np
from nltk.sentiment.util import mark_negation
def lol2str(doc):
"""Transforms a document in the list-of-lists format into
a block of text (str type)."""
return " ".join([word for sent in doc for word in sent])
def mr2str(dataset):
"""Transforms the Movie Revi... | [
"nltk.download",
"os.path.join",
"nltk.corpus.movie_reviews.paras",
"numpy.ndarray",
"nltk.sentiment.util.mark_negation"
] | [((602, 632), 'nltk.download', 'nltk.download', (['"""movie_reviews"""'], {}), "('movie_reviews')\n", (615, 632), False, 'import nltk\n'), ((685, 722), 'nltk.corpus.movie_reviews.paras', 'movie_reviews.paras', ([], {'categories': '"""neg"""'}), "(categories='neg')\n", (704, 722), False, 'from nltk.corpus import movie_r... |
from logging import addLevelName
from multiprocessing import Event
# Our custom log severity. We need this because we want to see some special messages and on node the default log level
# of workers is set to WARNING (INFO would be too much noise). These messages are not errors nor warnings, but can help
# in some sit... | [
"multiprocessing.Event",
"logging.addLevelName"
] | [((365, 401), 'logging.addLevelName', 'addLevelName', (['IMPORTANT', '"""IMPORTANT"""'], {}), "(IMPORTANT, 'IMPORTANT')\n", (377, 401), False, 'from logging import addLevelName\n'), ((429, 436), 'multiprocessing.Event', 'Event', ([], {}), '()\n', (434, 436), False, 'from multiprocessing import Event\n')] |
import sys, os, itertools
import numpy as np
import matplotlib.tri as tri
from glbase3 import *
import shared_conservation
# collect three things:
# 1. The total PhyloP score of the transcript
# 2. score for TE-containing bits
# 3. score for non-TE containign bits;
gl = glload('phyloP_conservation_table.glb')
print(... | [
"shared_conservation.scat",
"numpy.array",
"shared_conservation.contour",
"shared_conservation.hist"
] | [((325, 473), 'shared_conservation.scat', 'shared_conservation.scat', (['"""scat_te_vs_not_tes.pdf"""', "gl['phyloP_tes']", "gl['phyloP_nottes']", '"""TE"""', '"""not-TE"""'], {'xlims': '[-0.6, 0.7]', 'ylims': '[-0.6, 0.7]'}), "('scat_te_vs_not_tes.pdf', gl['phyloP_tes'], gl[\n 'phyloP_nottes'], 'TE', 'not-TE', xlim... |
import torch
import torchvision.models as models
from CrossConv import CrossConv2d
class TBResNet(models.ResNet):
def __init__(self,
block,
layers,
zero_init_residual=False,
groups=1,
width_per_group=64,
replace_stride... | [
"torch.nn.BatchNorm2d",
"torch.nn.Dropout2d",
"torch.flatten",
"torch.nn.Conv2d"
] | [((806, 892), 'torch.nn.Conv2d', 'torch.nn.Conv2d', (['inplane', 'inplane'], {'kernel_size': '(3)', 'stride': '(1)', 'padding': '(1)', 'bias': '(False)'}), '(inplane, inplane, kernel_size=3, stride=1, padding=1, bias=\n False)\n', (821, 892), False, 'import torch\n'), ((1556, 1585), 'torch.nn.BatchNorm2d', 'torch.nn... |
# SQLite 접속하기.
import pymysql
con = pymysql.connect(host='192.168.174.129', user='root',
password='<PASSWORD>', db='userDB', charset='utf8') # 데이터베이스 지정(또는 연결)
cur = con.cursor() # 연결 통로 생성 (쿼리문을 날릴 통로)
sql = "SELECT * FROM userTable2"
cur.execute(sql)
print(' 사용자아이디 사용자이름 사용자나이')
print(' --... | [
"pymysql.connect"
] | [((36, 144), 'pymysql.connect', 'pymysql.connect', ([], {'host': '"""192.168.174.129"""', 'user': '"""root"""', 'password': '"""<PASSWORD>"""', 'db': '"""userDB"""', 'charset': '"""utf8"""'}), "(host='192.168.174.129', user='root', password='<PASSWORD>',\n db='userDB', charset='utf8')\n", (51, 144), False, 'import p... |
import csv
from pymongo import MongoClient
client = MongoClient()
db = client.gallery
collection_collection = db.collections
nft_collection = db.nfts
gallery_collection = db.galleries
user_collection = db.users
with open("users.csv", "w", newline="") as csvfile:
fieldnames = ["username", "url", "nfts", "collecti... | [
"csv.DictWriter",
"pymongo.MongoClient"
] | [((53, 66), 'pymongo.MongoClient', 'MongoClient', ([], {}), '()\n', (64, 66), False, 'from pymongo import MongoClient\n'), ((339, 385), 'csv.DictWriter', 'csv.DictWriter', (['csvfile'], {'fieldnames': 'fieldnames'}), '(csvfile, fieldnames=fieldnames)\n', (353, 385), False, 'import csv\n')] |
import torch
import torch.nn.functional as F
from utils import prepare_cifar
import tqdm
import radam
from vgg import vgg13_bn
from models import PreActResNet18
from aegleseeker import AegleSeeker
from eval_model import eval_model_pgd
device = 'cuda:0'
model = vgg13_bn()
model = AegleSeeker(model).to(device)
train_lo... | [
"vgg.vgg13_bn",
"eval_model.eval_model_pgd",
"utils.prepare_cifar",
"tqdm.tqdm",
"torch.randn_like",
"aegleseeker.AegleSeeker",
"torch.nn.functional.cross_entropy"
] | [((263, 273), 'vgg.vgg13_bn', 'vgg13_bn', ([], {}), '()\n', (271, 273), False, 'from vgg import vgg13_bn\n'), ((340, 363), 'utils.prepare_cifar', 'prepare_cifar', (['(100)', '(100)'], {}), '(100, 100)\n', (353, 363), False, 'from utils import prepare_cifar\n'), ((282, 300), 'aegleseeker.AegleSeeker', 'AegleSeeker', (['... |
from __future__ import unicode_literals
from mayan.apps.storage.utils import get_storage_subclass
from .settings import (
setting_staging_file_image_cache_storage,
setting_staging_file_image_cache_storage_arguments,
)
storage_staging_file_image_cache = get_storage_subclass(
dotted_path=setting_staging_fi... | [
"mayan.apps.storage.utils.get_storage_subclass"
] | [((264, 349), 'mayan.apps.storage.utils.get_storage_subclass', 'get_storage_subclass', ([], {'dotted_path': 'setting_staging_file_image_cache_storage.value'}), '(dotted_path=setting_staging_file_image_cache_storage.value\n )\n', (284, 349), False, 'from mayan.apps.storage.utils import get_storage_subclass\n')] |
from django.conf import settings
from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils.text import slugify
from rest_framework.authtoken.models import Token
from django.contrib.postgres.fields import JSONField
from ulid2 import generate_ulid_a... | [
"django.utils.text.slugify",
"django.contrib.postgres.fields.JSONField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.DateTimeField",
"django.db.models.SlugField",
"django.db.models.CharField",
"django.dispatch.receiver",
"djang... | [((2739, 2791), 'django.dispatch.receiver', 'receiver', (['post_save'], {'sender': 'settings.AUTH_USER_MODEL'}), '(post_save, sender=settings.AUTH_USER_MODEL)\n', (2747, 2791), False, 'from django.dispatch import receiver\n'), ((394, 459), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'default': 'generate_uli... |
from django.shortcuts import render
# Create your views here.
from Karat.settings import RequestHost
def SchoolHistoryMuseum(request):
return render(request, 'test.html',{"RequestHost":RequestHost}) | [
"django.shortcuts.render"
] | [((149, 207), 'django.shortcuts.render', 'render', (['request', '"""test.html"""', "{'RequestHost': RequestHost}"], {}), "(request, 'test.html', {'RequestHost': RequestHost})\n", (155, 207), False, 'from django.shortcuts import render\n')] |
import os
from time import perf_counter
from microsoft.submaintenance.utils import CmdUtils
from microsoft.submaintenance.utils import PathUtils
scripts = [
{
"description" : "CLEANUP: Check for required tags, see configuration.json groupCompliance",
"script" : "./task_rg_compliance.py"
},
... | [
"microsoft.submaintenance.utils.CmdUtils.get_command_output",
"microsoft.submaintenance.utils.PathUtils.ensure_path",
"time.perf_counter",
"os.getcwd",
"microsoft.submaintenance.utils.CmdUtils.get_last_errors"
] | [((1070, 1081), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1079, 1081), False, 'import os\n'), ((1144, 1158), 'time.perf_counter', 'perf_counter', ([], {}), '()\n', (1156, 1158), False, 'from time import perf_counter\n'), ((1203, 1267), 'microsoft.submaintenance.utils.CmdUtils.get_command_output', 'CmdUtils.get_comma... |
"""
Upload handlers to test the upload API.
"""
from django.core.files.uploadedfile import InMemoryUploadedFile
from django.core.files.uploadhandler import (FileUploadHandler, StopUpload,
StopFutureHandlers)
from StringIO import StringIO
class QuotaUploadHandler(FileUploadHandler):
"""
This test upload ha... | [
"StringIO.StringIO",
"django.core.files.uploadedfile.InMemoryUploadedFile",
"django.core.files.uploadhandler.StopUpload",
"django.core.files.uploadhandler.StopFutureHandlers"
] | [((1433, 1443), 'StringIO.StringIO', 'StringIO', ([], {}), '()\n', (1441, 1443), False, 'from StringIO import StringIO\n'), ((1897, 2062), 'django.core.files.uploadedfile.InMemoryUploadedFile', 'InMemoryUploadedFile', ([], {'file': 'self.file', 'field_name': 'self.field_name', 'name': 'self.file_name', 'content_type': ... |
"""Package containing pyleus implementation of major Storm entities.
"""
from __future__ import absolute_import
from collections import namedtuple
DEFAULT_STREAM = "default"
StormTuple = namedtuple('StormTuple', "id comp stream task values")
"""Namedtuple representing a Storm tuple.
* **id**\(``str`` or ``long``): ... | [
"collections.namedtuple"
] | [((190, 244), 'collections.namedtuple', 'namedtuple', (['"""StormTuple"""', '"""id comp stream task values"""'], {}), "('StormTuple', 'id comp stream task values')\n", (200, 244), False, 'from collections import namedtuple\n')] |
from django.test import TestCase
from mock import patch
from digest.management.commands.import_importpython import ImportPythonParser
from digest.utils import MockResponse, read_fixture
class ImportPythonWeeklyTest(TestCase):
def setUp(self):
self.url = "http://importpython.com/newsletter/no/60/"
... | [
"digest.utils.read_fixture",
"mock.patch",
"digest.management.commands.import_importpython.ImportPythonParser",
"digest.management.commands.import_importpython.ImportPythonParser.get_issue_url"
] | [((415, 478), 'mock.patch', 'patch', (['"""digest.management.commands.import_importpython.urlopen"""'], {}), "('digest.management.commands.import_importpython.urlopen')\n", (420, 478), False, 'from mock import patch\n'), ((658, 678), 'digest.management.commands.import_importpython.ImportPythonParser', 'ImportPythonPars... |
#!/usr/bin/env python
#####################################################
# This file is a component of ClusterGB #
# Copyright (c) 2018 <NAME> #
# Released under the MIT License (see distribution) #
#####################################################
"""
For each grain boundary, cal... | [
"clustergb.bond_orientational_order.bond_orientational_order_parameter",
"argparse.ArgumentParser",
"os.path.join",
"clustergb.osio.tee",
"time.time",
"numpy.arange"
] | [((1418, 1429), 'time.time', 'time.time', ([], {}), '()\n', (1427, 1429), False, 'import time\n'), ((1435, 1511), 'clustergb.osio.tee', 'cgb.osio.tee', (['job.log_loc', "('Starting bond-order calculation for ' + job.name)"], {}), "(job.log_loc, 'Starting bond-order calculation for ' + job.name)\n", (1447, 1511), True, ... |
import os
import random
from collections import defaultdict
import boto3
import pytest
from xoto3.dynamodb.update import versioned_diffed_update_item
from xoto3.dynamodb.utils.expressions import add_variables_to_expression
from xoto3.dynamodb.utils.table import extract_key_from_item, table_primary_keys
_TEST_TABLE_N... | [
"xoto3.dynamodb.update.versioned_diffed_update_item",
"xoto3.dynamodb.utils.table.extract_key_from_item",
"os.environ.get",
"boto3.resource",
"collections.defaultdict",
"pytest.raises",
"xoto3.dynamodb.utils.table.table_primary_keys",
"xoto3.dynamodb.utils.expressions.add_variables_to_expression",
"... | [((326, 378), 'os.environ.get', 'os.environ.get', (['"""XOTO3_TEST_DYNAMODB_TABLE_NAME"""', '""""""'], {}), "('XOTO3_TEST_DYNAMODB_TABLE_NAME', '')\n", (340, 378), False, 'import os\n'), ((2204, 2221), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (2215, 2221), False, 'from collections import de... |
import pygame, sys
from pygame.locals import *
from pygame import *
# Initialisation de la bibliothèque Pygame
pygame.init()
wait = 0
# Ouverture de la fenêtre Pygame
larg_fenetre = 1419
haut_fenetre = 731
fenetre = pygame.display.set_mode((larg_fenetre, haut_fenetre))
# Chargement et collage du fond
fond = pygame.... | [
"pygame.init",
"pygame.quit",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.display.flip",
"pygame.draw.rect",
"pygame.image.load"
] | [((112, 125), 'pygame.init', 'pygame.init', ([], {}), '()\n', (123, 125), False, 'import pygame, sys\n'), ((219, 272), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(larg_fenetre, haut_fenetre)'], {}), '((larg_fenetre, haut_fenetre))\n', (242, 272), False, 'import pygame, sys\n'), ((989, 1038), 'pygame.draw.... |
import argparse
import logging
import os
import sys
import requests
from colorama import Fore, Style, init
from colorama.ansi import clear_screen
import grayskull
from grayskull.base.factory import GrayskullFactory
from grayskull.cli import CLIConfig
from grayskull.cli.parser import parse_pkg_name_version
from graysk... | [
"logging.basicConfig",
"grayskull.cli.CLIConfig",
"logging.debug",
"argparse.ArgumentParser",
"grayskull.cli.parser.parse_pkg_name_version",
"grayskull.utils.origin_is_github",
"colorama.ansi.clear_screen",
"os.path.realpath",
"grayskull.base.factory.GrayskullFactory.create_recipe",
"colorama.init... | [((398, 418), 'colorama.init', 'init', ([], {'autoreset': '(True)'}), '(autoreset=True)\n', (402, 418), False, 'from colorama import Fore, Style, init\n'), ((419, 474), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s:%(message)s"""'}), "(format='%(levelname)s:%(message)s')\n", (438, 474)... |
from django.contrib import admin
from .models import Enquiry
class EnquiryAdmin(admin.ModelAdmin):
list_display = ["name", "email", "phone_number", "message"]
admin.site.register(Enquiry, EnquiryAdmin)
| [
"django.contrib.admin.site.register"
] | [((168, 210), 'django.contrib.admin.site.register', 'admin.site.register', (['Enquiry', 'EnquiryAdmin'], {}), '(Enquiry, EnquiryAdmin)\n', (187, 210), False, 'from django.contrib import admin\n')] |
"""
demosaic bayer filter of type 'grbg' using nearest neighbor interpolation
input:
assumes uint8 or uint16 raw bayer filtered grbg input
assumes 2-D I x J pixels, where a single image is I x J pixels,
where I and J are both even numbers
output:
same uint8 or uint16 shape as inpout
Note: If you're on Windo... | [
"numpy.dstack",
"logging.warning",
"numpy.empty",
"scipy.ndimage.interpolation.zoom",
"logging.info",
"numpy.round"
] | [((2359, 2379), 'numpy.dstack', 'np.dstack', (['(r, g, b)'], {}), '((r, g, b))\n', (2368, 2379), True, 'import numpy as np\n'), ((2623, 2656), 'scipy.ndimage.interpolation.zoom', 'zoom', (['rgb', '(2, 2, 1)'], {'order': 'order'}), '(rgb, (2, 2, 1), order=order)\n', (2627, 2656), False, 'from scipy.ndimage.interpolation... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"urlparse.urljoin"
] | [((1522, 1554), 'urlparse.urljoin', 'urlparse.urljoin', (['self.host', 'url'], {}), '(self.host, url)\n', (1538, 1554), False, 'import urlparse\n')] |
import logging
import sys
from typing import Tuple
from backee.model.max_level_filter import MaxLevelFilter
log = logging.getLogger(__name__)
def setup_default_loggers() -> None:
__setup_global_logging_levels()
formatter = logging.Formatter(
"%(asctime)s [%(threadName)18s][%(module)14s][%(levelna... | [
"logging.getLogger",
"backee.model.max_level_filter.MaxLevelFilter",
"logging.StreamHandler",
"logging.Formatter",
"sys.__excepthook__"
] | [((118, 145), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (135, 145), False, 'import logging\n'), ((238, 336), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s [%(threadName)18s][%(module)14s][%(levelname)8s] %(message)s"""'], {}), "(\n '%(asctime)s [%(threadName)18s][%(m... |
import datetime
import decimal
from django.contrib.auth.models import AnonymousUser
from django.core.exceptions import ImproperlyConfigured
from django.test import TestCase
from django.utils import timezone
from djstripe.settings import User
from djstripe.models import convert_tstamp, Customer, CurrentSubscription
fr... | [
"datetime.datetime",
"djstripe.models.Customer.objects.create",
"django.contrib.auth.models.AnonymousUser",
"djstripe.settings.User.objects.create_user",
"djstripe.models.convert_tstamp",
"djstripe.utils.user_has_active_subscription",
"decimal.Decimal"
] | [((484, 510), 'djstripe.models.convert_tstamp', 'convert_tstamp', (['(1365567407)'], {}), '(1365567407)\n', (498, 510), False, 'from djstripe.models import convert_tstamp, Customer, CurrentSubscription\n'), ((706, 756), 'djstripe.models.convert_tstamp', 'convert_tstamp', (["{'my_date': 1365567407}", '"""my_date"""'], {... |
import os
import sys
import subprocess
import traceback
sys.path.append(snakemake.config['args']['mcc_path'])
import scripts.mccutils as mccutils
import config.tepid.tepid_post as config
def main():
insertions_bed = snakemake.input.insertions_bed
deletions_bed = snakemake.input.deletions_bed
insertions_su... | [
"scripts.mccutils.Insertion",
"scripts.mccutils.run_command",
"scripts.mccutils.make_redundant_bed",
"scripts.mccutils.log",
"scripts.mccutils.make_nonredundant_bed",
"sys.path.append"
] | [((56, 109), 'sys.path.append', 'sys.path.append', (["snakemake.config['args']['mcc_path']"], {}), "(snakemake.config['args']['mcc_path'])\n", (71, 109), False, 'import sys\n'), ((653, 707), 'scripts.mccutils.log', 'mccutils.log', (['"""tepid"""', '"""running TEPID post processing"""'], {}), "('tepid', 'running TEPID p... |
from oeis import A000142
from hypothesis import given
from hypothesis.strategies import integers
def test_sequence():
assert A000142() == [
1,
1,
2,
6,
24,
120,
720,
5040,
40320,
362880,
3628800,
3991... | [
"oeis.A000142",
"hypothesis.strategies.integers"
] | [((539, 574), 'hypothesis.strategies.integers', 'integers', ([], {'min_value': '(0)', 'max_value': '(20)'}), '(min_value=0, max_value=20)\n', (547, 574), False, 'from hypothesis.strategies import integers\n'), ((576, 611), 'hypothesis.strategies.integers', 'integers', ([], {'min_value': '(1)', 'max_value': '(20)'}), '(... |
#!/usr/bin/env python3
import os
import psutil
import sys
# Check if upgrade is running.
def isrunning():
count = 0
for pid in psutil.pids():
p = psutil.Process(pid) # TODO: Race condition bug here when program exits when called, then the pid does not exists anymore.
if p.name() == "upgrade.py"... | [
"psutil.pids",
"psutil.Process",
"os.path.isfile",
"sys.exit",
"os.system"
] | [((804, 846), 'os.system', 'os.system', (['"""yaourt -Syu --aur --noconfirm"""'], {}), "('yaourt -Syu --aur --noconfirm')\n", (813, 846), False, 'import os\n'), ((136, 149), 'psutil.pids', 'psutil.pids', ([], {}), '()\n', (147, 149), False, 'import psutil\n'), ((489, 529), 'os.path.isfile', 'os.path.isfile', (['"""/var... |
# -*- coding: utf-8 -*-
###################################################################################
# Copyright (C) 2019 SuXueFeng
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software ... | [
"logging.getLogger",
"odoo.fields.Many2one",
"odoo.fields.Integer",
"odoo.fields.Text",
"odoo.fields.Char",
"odoo.fields.Boolean"
] | [((970, 997), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (987, 997), False, 'import logging\n'), ((1189, 1235), 'odoo.fields.Boolean', 'fields.Boolean', ([], {'string': 'u"""Active"""', 'default': '(True)'}), "(string=u'Active', default=True)\n", (1203, 1235), False, 'from odoo import... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import csv
import numpy as np
import os
import sys
from observations.util import maybe_download_and_extract
def duncan(path):
"""Duncan's Occupational Prestige Data
The `Duncan` ... | [
"observations.util.maybe_download_and_extract",
"os.path.join",
"os.path.expanduser"
] | [((1418, 1442), 'os.path.expanduser', 'os.path.expanduser', (['path'], {}), '(path)\n', (1436, 1442), False, 'import os\n'), ((1584, 1669), 'observations.util.maybe_download_and_extract', 'maybe_download_and_extract', (['path', 'url'], {'save_file_name': '"""duncan.csv"""', 'resume': '(False)'}), "(path, url, save_file... |
import threading
import SocketServer
import sys
from lust import log, server
RUN_DIR="/var/run/threadserver"
class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
allow_reuse_address = True
def handle(self):
log.info("Connection %r:%r" % self.client_address)
self.request.sendall(... | [
"lust.log.info",
"lust.log.error",
"sys.exit",
"lust.log.debug",
"threading.Thread",
"lust.server.run"
] | [((1608, 1628), 'lust.server.run', 'server.run', (['sys.argv'], {}), '(sys.argv)\n', (1618, 1628), False, 'from lust import log, server\n'), ((240, 290), 'lust.log.info', 'log.info', (["('Connection %r:%r' % self.client_address)"], {}), "('Connection %r:%r' % self.client_address)\n", (248, 290), False, 'from lust impor... |
from pmg import app
from pmg.tasks import StartScheduler
from pmg.models.soundcloud_track import SoundcloudTrack
from flask_script import Server, Manager
from flask_migrate import MigrateCommand
app.debug = True
manager = Manager(app)
manager.add_command("runserver", Server(port=5000, threaded=True, host="0.0.0.0"))
... | [
"pmg.models.soundcloud_track.SoundcloudTrack.sync",
"flask_script.Server",
"flask_script.Manager"
] | [((224, 236), 'flask_script.Manager', 'Manager', (['app'], {}), '(app)\n', (231, 236), False, 'from flask_script import Server, Manager\n'), ((270, 318), 'flask_script.Server', 'Server', ([], {'port': '(5000)', 'threaded': '(True)', 'host': '"""0.0.0.0"""'}), "(port=5000, threaded=True, host='0.0.0.0')\n", (276, 318), ... |
# FIXME[hack]: this is just using a specific keras network as proof of
# concept. It has to be modularized and integrated into the framework
import os
import logging
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
import tensorflow as tf
from tensorflow import keras
import numpy as np
print(f"nu... | [
"logging.getLogger",
"cleverhans.attacks.FastGradientMethod",
"cleverhans.utils.AccuracyReport",
"tensorflow.set_random_seed",
"logging.info",
"numpy.random.RandomState",
"os.path.exists",
"cleverhans.utils_tf.model_eval",
"numpy.asarray",
"os.mkdir",
"tensorflow.keras.backend.backend",
"cleve... | [((177, 204), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (194, 204), False, 'import logging\n'), ((974, 1007), 'tensorflow.keras.backend.image_data_format', 'keras.backend.image_data_format', ([], {}), '()\n', (1005, 1007), False, 'from tensorflow import keras\n'), ((2699, 2715), 'cle... |
from naolution.vrep import vrep
from naolution.consts import VREP_IP_1, VREP_PORT_1, NAOQI_BIN_IP, NAOQI_BIN_PORT
import sys
from naolution.managers import simulation_manager as simulation
from naoqi import ALProxy
from naolution.utils.checker import check_client_ID
"""
Streams moving of NAO's joints from Choreograph... | [
"naolution.vrep.vrep.simxSetJointTargetPosition",
"naolution.managers.simulation_manager.start_connection",
"naolution.vrep.vrep.simxGetObjectHandle",
"naolution.vrep.vrep.simxFinish",
"naolution.vrep.vrep.simxStart",
"naolution.vrep.vrep.simxGetConnectionId",
"naoqi.ALProxy"
] | [((8022, 8041), 'naolution.vrep.vrep.simxFinish', 'vrep.simxFinish', (['(-1)'], {}), '(-1)\n', (8037, 8041), False, 'from naolution.vrep import vrep\n'), ((8058, 8109), 'naolution.managers.simulation_manager.start_connection', 'simulation.start_connection', (['VREP_IP_1', 'VREP_PORT_1'], {}), '(VREP_IP_1, VREP_PORT_1)\... |
# Copyright 2015 Huawei Technologies Co.,LTD.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agree... | [
"magnum.common.clients.OpenStackClients",
"magnum.objects.BayModel.get_by_uuid",
"magnum.objects.Bay.get_by_uuid"
] | [((699, 745), 'magnum.objects.Bay.get_by_uuid', 'objects.Bay.get_by_uuid', (['context', 'obj.bay_uuid'], {}), '(context, obj.bay_uuid)\n', (722, 745), False, 'from magnum import objects\n'), ((796, 850), 'magnum.objects.BayModel.get_by_uuid', 'objects.BayModel.get_by_uuid', (['context', 'bay.baymodel_id'], {}), '(conte... |