code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""SentencePiece Tokenization for Wiki Dataset
Example:
* python scripts/wiki_sp_tokenize_json.py --word --unigram
"""
import gzip
import json
import subprocess
from pathlib import Path
import sentencepiece as spm
import joblib
import numpy as np
import click
from tqdm import tqdm
from opencc import OpenCC
from wi... | [
"subprocess.run",
"gzip.open",
"sentencepiece.SentencePieceProcessor",
"json.loads",
"wiki_tokenize_json.clean_text",
"click.option",
"click.command",
"opencc.OpenCC",
"pathlib.Path",
"numpy.array",
"wiki_tokenize_json.filter_texts"
] | [((564, 577), 'opencc.OpenCC', 'OpenCC', (['"""t2s"""'], {}), "('t2s')\n", (570, 577), False, 'from opencc import OpenCC\n'), ((2890, 2905), 'click.command', 'click.command', ([], {}), '()\n', (2903, 2905), False, 'import click\n'), ((2907, 2943), 'click.option', 'click.option', (['"""--word"""'], {'is_flag': '(True)'}... |
from django.conf.urls import url, include
from django.contrib import admin
from django.views.generic import TemplateView
urlpatterns = [
url(r'^admin/', admin.site.urls),
url(r'^', include('server.urls'), name='server'),
]
| [
"django.conf.urls.include",
"django.conf.urls.url"
] | [((143, 174), 'django.conf.urls.url', 'url', (['"""^admin/"""', 'admin.site.urls'], {}), "('^admin/', admin.site.urls)\n", (146, 174), False, 'from django.conf.urls import url, include\n'), ((191, 213), 'django.conf.urls.include', 'include', (['"""server.urls"""'], {}), "('server.urls')\n", (198, 213), False, 'from dja... |
# Adapted for numpy/ma/cdms2 by convertcdms.py
# Import the modules needed for the tuturial
import vcs, cdms2 as cdms, cdutil, time, os, sys
# Open data file:
filepath = os.path.join(vcs.sample_data, 'clt.nc')
cdmsfile = cdms.open( filepath )
# Extract a 3 dimensional data set and get a subset of the time dimension
d... | [
"cdms2.open",
"os.path.join",
"vcs.init"
] | [((171, 210), 'os.path.join', 'os.path.join', (['vcs.sample_data', '"""clt.nc"""'], {}), "(vcs.sample_data, 'clt.nc')\n", (183, 210), False, 'import vcs, cdms2 as cdms, cdutil, time, os, sys\n'), ((222, 241), 'cdms2.open', 'cdms.open', (['filepath'], {}), '(filepath)\n', (231, 241), True, 'import vcs, cdms2 as cdms, cd... |
"""Install or upgrade a bcbio-nextgen installation.
"""
from __future__ import print_function
import os
import subprocess
import sys
import yaml
from bcbiovm.docker import manage, mounts
DEFAULT_IMAGE = "chapmanb/bcbio-nextgen-devel"
def full(args, dockerconf):
"""Full installaction of docker image and data.
... | [
"yaml.load",
"os.makedirs",
"os.path.getsize",
"bcbiovm.docker.manage.run_bcbio_cmd",
"yaml.dump",
"os.path.exists",
"os.path.realpath",
"subprocess.check_output",
"bcbiovm.docker.mounts.prepare_system",
"sys.exit",
"os.path.join",
"subprocess.check_call"
] | [((486, 548), 'bcbiovm.docker.mounts.prepare_system', 'mounts.prepare_system', (['args.datadir', "dockerconf['biodata_dir']"], {}), "(args.datadir, dockerconf['biodata_dir'])\n", (507, 548), False, 'from bcbiovm.docker import manage, mounts\n'), ((2802, 2887), 'subprocess.check_call', 'subprocess.check_call', (["['dock... |
import enum
from pandas.io.pytables import DuplicateWarning
from py2neo import Node, Relationship, Graph, NodeMatcher
import pandas as pd
from operator import itemgetter
from typing import List, Dict
import random
graph = Graph("http://localhost:7474", username="neo4j", password='<PASSWORD>')
main_ingr = set(['apple'... | [
"py2neo.Graph",
"pandas.DataFrame"
] | [((223, 294), 'py2neo.Graph', 'Graph', (['"""http://localhost:7474"""'], {'username': '"""neo4j"""', 'password': '"""<PASSWORD>"""'}), "('http://localhost:7474', username='neo4j', password='<PASSWORD>')\n", (228, 294), False, 'from py2neo import Node, Relationship, Graph, NodeMatcher\n'), ((1890, 1907), 'pandas.DataFra... |
import cwgen
import os
import sys
import PySimpleGUI as sg
class CwGenUI:
# General
# GUI - window config
WINDOW_DESCRIPTION = 'CW training material generator by SP6HFE'
# GUI - text config
E2CW_VER_LOCAL_KEY = '-E2CW VER LOCAL-'
E2CW_VER_ONLINE_KEY = '-E2CW VER ONLINE-'
... | [
"PySimpleGUI.Button",
"PySimpleGUI.Input",
"PySimpleGUI.theme",
"cwgen.CwGen",
"PySimpleGUI.Frame",
"PySimpleGUI.Slider",
"PySimpleGUI.FileBrowse",
"PySimpleGUI.Table",
"PySimpleGUI.Text",
"PySimpleGUI.Window",
"os.path.normpath",
"os.path.isfile",
"PySimpleGUI.Column",
"PySimpleGUI.VSepar... | [((21381, 21401), 'PySimpleGUI.theme', 'sg.theme', (['"""Default1"""'], {}), "('Default1')\n", (21389, 21401), True, 'import PySimpleGUI as sg\n'), ((2063, 2076), 'cwgen.CwGen', 'cwgen.CwGen', ([], {}), '()\n', (2074, 2076), False, 'import cwgen\n'), ((10656, 10698), 'PySimpleGUI.Window', 'sg.Window', (['self.WINDOW_DE... |
# TODO: use sliding windows instead of chunking.
# the chunking method fails when part of a dupe string
# crosses the border between chunks
import colorama
from colorama import Fore
from tqdm import trange, tqdm
import os
colorama.init(autoreset=True)
DEFAULT_MIN = 5
DEFAULT_MAX = 10
def striplist(l):
# clean ... | [
"colorama.init",
"tqdm.trange"
] | [((224, 253), 'colorama.init', 'colorama.init', ([], {'autoreset': '(True)'}), '(autoreset=True)\n', (237, 253), False, 'import colorama\n'), ((1951, 1971), 'tqdm.trange', 'trange', (['max', 'min', '(-1)'], {}), '(max, min, -1)\n', (1957, 1971), False, 'from tqdm import trange, tqdm\n')] |
import boto3
from botocore.exceptions import ClientError
import json
import os
import time
import datetime
from dateutil import tz
from lib.account import *
from lib.common import *
import logging
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logging.getLogger('botocore').setLevel(logging.WARNING)
log... | [
"dateutil.tz.gettz",
"json.loads",
"logging.getLogger",
"json.dumps"
] | [((210, 229), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (227, 229), False, 'import logging\n'), ((523, 572), 'json.loads', 'json.loads', (["event['Records'][0]['Sns']['Message']"], {}), "(event['Records'][0]['Sns']['Message'])\n", (533, 572), False, 'import json\n'), ((261, 290), 'logging.getLogger', ... |
#!/usr/bin/python3
from PyQt5.QtGui import QBrush, QColor, QPainter
from PyQt5.QtChart import QChartView, QChart, QPieSeries
from portfolio.utils import confighandler
from portfolio.db.fdbhandler import balances
from portfolio.db.cdbhandler import cbalances
from portfolio.gui.ui_components.fonts import ChartTitleFont... | [
"PyQt5.QtGui.QColor",
"portfolio.db.fdbhandler.balances.get_total_balance_all_accounts",
"PyQt5.QtChart.QPieSeries",
"portfolio.db.cdbhandler.cbalances.get_all_accounts_with_amount_fiat",
"portfolio.gui.ui_components.fonts.ChartTitleFont",
"portfolio.db.cdbhandler.cbalances.get_total_balance_all_accounts_... | [((590, 598), 'PyQt5.QtChart.QChart', 'QChart', ([], {}), '()\n', (596, 598), False, 'from PyQt5.QtChart import QChartView, QChart, QPieSeries\n'), ((1618, 1630), 'PyQt5.QtChart.QPieSeries', 'QPieSeries', ([], {}), '()\n', (1628, 1630), False, 'from PyQt5.QtChart import QChartView, QChart, QPieSeries\n'), ((2903, 2919)... |
#coding=utf8
import re
import itchat
from itchat.content import *
'''
0.0.1版本
功能：
1.匹配群聊关键字 说 ，然后回复接受到的消息
'''
# 群聊监控
@itchat.msg_register(TEXT, isGroupChat = True)
def groupchat_reply(msg):
room_name = itchat.search_chatrooms(userName=msg[u'FromUserName'])
print(u"来自-%s-群聊消息|%s:%s"%(room_name[ u'NickName'],ms... | [
"itchat.msg_register",
"re.match",
"itchat.search_chatrooms",
"itchat.send_msg",
"itchat.auto_login",
"itchat.run"
] | [((120, 163), 'itchat.msg_register', 'itchat.msg_register', (['TEXT'], {'isGroupChat': '(True)'}), '(TEXT, isGroupChat=True)\n', (139, 163), False, 'import itchat\n'), ((578, 629), 'itchat.auto_login', 'itchat.auto_login', ([], {'hotReload': '(True)', 'enableCmdQR': '(True)'}), '(hotReload=True, enableCmdQR=True)\n', (... |
#! /usr/bin/python3
# -*- coding: utf-8 -*-
####################################################################################################
import io
####################################################################################################
def TailFile(p_FileName, p_BufferSize=io.DEFAULT_BUFFER_SIZE,... | [
"os.remove",
"sys.exit",
"time.time"
] | [((2399, 2410), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (2407, 2410), False, 'import sys\n'), ((2461, 2472), 'time.time', 'time.time', ([], {}), '()\n', (2470, 2472), False, 'import time\n'), ((2631, 2642), 'time.time', 'time.time', ([], {}), '()\n', (2640, 2642), False, 'import time\n'), ((2796, 2807), 'time.t... |
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import textwrap
from typing import Dict, Optional
import libcst as cst
from libcst.codemod import CodemodContext, VisitorBa... | [
"textwrap.dedent",
"libcst.Comma"
] | [((634, 1244), 'textwrap.dedent', 'textwrap.dedent', (['"""\n Codemod that adds trailing commas to arguments in function\n headers and function calls.\n\n The idea is that both the black and yapf autoformatters will\n tend to split headers and function calls so that there\n is one par... |
"""
Tests with the Izhikevich neuron model.
"""
import numpy as np
import matplotlib.pyplot as plt
import pyNN.nest as sim
from pyNN.utility.plotting import Figure, Panel
# === Configure the simulator ================================================
duration = 100
dt = 0.01
sim.setup(timestep=dt, min_delay=0.1)
... | [
"pyNN.nest.run",
"numpy.count_nonzero",
"pyNN.nest.setup",
"pyNN.nest.end",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.legend",
"numpy.logspace",
"numpy.array",
"pyNN.utility.plotting.Panel",
"matplotlib.pyplot.savefig",
"pyNN.nest.Izhikevich"
] | [((281, 318), 'pyNN.nest.setup', 'sim.setup', ([], {'timestep': 'dt', 'min_delay': '(0.1)'}), '(timestep=dt, min_delay=0.1)\n', (290, 318), True, 'import pyNN.nest as sim\n'), ((857, 874), 'pyNN.nest.run', 'sim.run', (['duration'], {}), '(duration)\n', (864, 874), True, 'import pyNN.nest as sim\n'), ((1345, 1402), 'mat... |
import sys
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--indexes', dest='inFile', required=True,
help='Path to indexes file, one per line.')
parser.add_argument('--config', dest='config', required=True)
o=parser.parse_args()
outFile = open(f"{o.config}.summa... | [
"sys.stderr.write",
"argparse.ArgumentParser"
] | [((57, 73), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (71, 73), False, 'from argparse import ArgumentParser\n'), ((4423, 4533), 'sys.stderr.write', 'sys.stderr.write', (['f"""{index}/{runID}.dcs.filt.no_overlap.region.c{c}-{C}.d{d}.unique.countmuts.txt\n"""'], {}), "(\n f'{index}/{runID}.dcs.fil... |
from pathlib import Path
from setuptools import find_packages, setup
long_description: str = (Path(__file__).parent.resolve() / "README.md").read_text(
encoding="utf-8"
)
setup(
name="crawler",
version="0.0.0",
description="A Web Crawler",
long_description=long_description,
long_description_co... | [
"pathlib.Path",
"setuptools.find_packages"
] | [((831, 857), 'setuptools.find_packages', 'find_packages', ([], {'where': '"""src"""'}), "(where='src')\n", (844, 857), False, 'from setuptools import find_packages, setup\n'), ((96, 110), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (100, 110), False, 'from pathlib import Path\n')] |
import json
import os
import requests
data_file = './description.json'
with open(data_file) as f:
data = json.load(f)
home_page = data['homepage']
seqs = data['sequences']
for v in seqs:
link = '%s%s' % (home_page,v['annotations']['url'])
print('download %s' % link)
os.system('wget %s -O %s_ann.zip' %... | [
"json.load",
"os.system"
] | [((109, 121), 'json.load', 'json.load', (['f'], {}), '(f)\n', (118, 121), False, 'import json\n'), ((285, 339), 'os.system', 'os.system', (["('wget %s -O %s_ann.zip' % (link, v['name']))"], {}), "('wget %s -O %s_ann.zip' % (link, v['name']))\n", (294, 339), False, 'import os\n'), ((438, 492), 'os.system', 'os.system', ... |
import hyperion
import time
import colorsys
# Get the parameters
rotationTime = float(hyperion.args.get('rotation-time', 2.0))
colorOne = hyperion.args.get('color_one', (255,0,0))
colorTwo = hyperion.args.get('color_two', (0,0,255))
colorsCount = hyperion.args.get('colors_count', hyperion.ledCount/2)
reverse = bool(hy... | [
"colorsys.rgb_to_hsv",
"colorsys.hsv_to_rgb",
"hyperion.abort",
"hyperion.setColor",
"time.sleep",
"hyperion.args.get"
] | [((139, 182), 'hyperion.args.get', 'hyperion.args.get', (['"""color_one"""', '(255, 0, 0)'], {}), "('color_one', (255, 0, 0))\n", (156, 182), False, 'import hyperion\n'), ((192, 235), 'hyperion.args.get', 'hyperion.args.get', (['"""color_two"""', '(0, 0, 255)'], {}), "('color_two', (0, 0, 255))\n", (209, 235), False, '... |
"""
---
title: Attention with Linear Biases (ALiBi) Experiment
summary: This experiment trains an Attention with Linear Biases (ALiBi) based model on Tiny Shakespeare dataset.
---
# [Attention with Linear Biases (ALiBi)](index.html) Experiment
This is an annotated PyTorch experiment to train a [ALiBi model](index.htm... | [
"labml.configs.option",
"labml_nn.transformers.TransformerConfigs",
"labml_nn.transformers.alibi.AlibiMultiHeadAttention",
"labml.experiment.create",
"labml.experiment.configs",
"labml.experiment.add_pytorch_models",
"labml_helpers.datasets.text.SequentialUnBatchedDataset",
"labml.experiment.start",
... | [((2260, 2327), 'labml.configs.calculate', 'calculate', (['TransformerConfigs.encoder_attn', '"""alibi_mha"""', '_alibi_mha'], {}), "(TransformerConfigs.encoder_attn, 'alibi_mha', _alibi_mha)\n", (2269, 2327), False, 'from labml.configs import option, calculate\n'), ((2328, 2395), 'labml.configs.calculate', 'calculate'... |
#coding=utf-8
'''
Created on 2015-9-24
@author: Devuser
'''
from doraemon.ci.pagefactory.ci_pageworker import CIPageWorker
from doraemon.ci.viewmodels.ci_left_nav_bar import CIServiceLeftNavBar
from doraemon.ci.viewmodels.ci_sub_nav_bar import CIServiceSubNavBar
from doraemon.ci.viewmodels.vm_ci_deploy_service import ... | [
"business.ci.ci_service.CIService.get_products_include_me",
"doraemon.ci.pagefactory.ci_pageworker.CIPageWorker.__init__",
"doraemon.project.pagefactory.project_common_pageworker.ProjectCommonControllPageWorker.get_myproject_dropdown_list",
"business.ci.ci_service.CIService.get_product_ci_services",
"doraem... | [((754, 790), 'doraemon.ci.pagefactory.ci_pageworker.CIPageWorker.__init__', 'CIPageWorker.__init__', (['self', 'request'], {}), '(self, request)\n', (775, 790), False, 'from doraemon.ci.pagefactory.ci_pageworker import CIPageWorker\n'), ((974, 1016), 'business.ci.ci_service.CIService.get_products_include_me', 'CIServi... |
# Code generated by lark_sdk_gen. DO NOT EDIT.
import unittest
import pylark
import pytest
from tests.test_conf import app_all_permission, app_no_permission
from tests.test_helper import mock_get_tenant_access_token_failed
def mock(*args, **kwargs):
raise pylark.PyLarkError(scope="scope", func="func", code=1, ms... | [
"pylark.GetBitableViewListReq",
"pylark.PyLarkError",
"pylark.CreateBitableViewReq",
"pylark.GetBitableRecordReq",
"pylark.DeleteBitableRecordReq",
"pylark.GetBitableTableListReq",
"pytest.raises",
"pylark.UpdateBitableFieldReq",
"pylark.DeleteBitableFieldReq",
"pylark.GetBitableMetaReq",
"pylar... | [((263, 336), 'pylark.PyLarkError', 'pylark.PyLarkError', ([], {'scope': '"""scope"""', 'func': '"""func"""', 'code': '(1)', 'msg': '"""mock-failed"""'}), "(scope='scope', func='func', code=1, msg='mock-failed')\n", (281, 336), False, 'import pylark\n'), ((388, 478), 'pylark.PyLarkError', 'pylark.PyLarkError', ([], {'s... |
import angr
from taint import is_tainted, taintedUnconstrainedBits
import logging
l = logging.getLogger(__name__)
class IROpHook(angr.SimStatePlugin):
"""
Allows hooking the computation of operations performed in the symbolic execution.
(requires our fork of angr to actually respect the hook)
"""
... | [
"taint.taintedUnconstrainedBits",
"taint.is_tainted",
"logging.getLogger"
] | [((87, 114), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (104, 114), False, 'import logging\n'), ((843, 908), 'taint.taintedUnconstrainedBits', 'taintedUnconstrainedBits', (['state', '"""secret"""', 'irop._output_size_bits'], {}), "(state, 'secret', irop._output_size_bits)\n", (867, 90... |
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity
def get_title_from_index(index):
return df[df.index == index]["title"].values[0]
def get_index_from_title(title):
return df[df.title.str.lower() == title.lower()... | [
"pandas.read_csv",
"sklearn.feature_extraction.text.CountVectorizer",
"sklearn.metrics.pairwise.cosine_similarity"
] | [((990, 1029), 'pandas.read_csv', 'pd.read_csv', (['"""./data/movie_dataset.csv"""'], {}), "('./data/movie_dataset.csv')\n", (1001, 1029), True, 'import pandas as pd\n'), ((1264, 1281), 'sklearn.feature_extraction.text.CountVectorizer', 'CountVectorizer', ([], {}), '()\n', (1279, 1281), False, 'from sklearn.feature_ext... |
import django_filters
from django_filters import CharFilter
from .models import *
class FoodFilter(django_filters.FilterSet):
food_name = CharFilter(field_name = 'name' , lookup_expr = 'icontains',label='search food items')
class Meta:
model = Food
fields = ['food_name']
| [
"django_filters.CharFilter"
] | [((140, 226), 'django_filters.CharFilter', 'CharFilter', ([], {'field_name': '"""name"""', 'lookup_expr': '"""icontains"""', 'label': '"""search food items"""'}), "(field_name='name', lookup_expr='icontains', label=\n 'search food items')\n", (150, 226), False, 'from django_filters import CharFilter\n')] |
# -*- coding: utf-8 -*-
import os
from config import Config
from flask import Flask, send_from_directory
from werkzeug.contrib.fixers import ProxyFix
import logging
from gtts import gTTS
from pydub import AudioSegment
import hashlib
try:
from urllib.parse import unquote_plus
except:
from urllib import unquote_p... | [
"werkzeug.contrib.fixers.ProxyFix",
"config.Config",
"gtts.gTTS",
"flask.Flask",
"os.environ.get",
"os.path.isfile",
"pydub.AudioSegment.from_file",
"flask.send_from_directory",
"urllib.unquote_plus",
"logging.getLogger"
] | [((334, 342), 'config.Config', 'Config', ([], {}), '()\n', (340, 342), False, 'from config import Config\n'), ((350, 365), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (355, 365), False, 'from flask import Flask, send_from_directory\n'), ((563, 581), 'urllib.unquote_plus', 'unquote_plus', (['text'], {}),... |
import ctypes
import sys
from pathlib import Path
from .space import SpaceClient
_known_tokens = 'ap cons nil neg c b s isnil car eq mul add lt div i t f cdr SCAN number FUN DEF galaxy GG'
_Tokens = {s:i for i, s in enumerate(_known_tokens.split(), 1)}
class AlienProxy:
def __init__(self):
pass
class ... | [
"pathlib.Path",
"ctypes.cdll.LoadLibrary",
"ctypes.POINTER"
] | [((4013, 4040), 'ctypes.cdll.LoadLibrary', 'ctypes.cdll.LoadLibrary', (['fn'], {}), '(fn)\n', (4036, 4040), False, 'import ctypes\n'), ((4055, 4085), 'ctypes.POINTER', 'ctypes.POINTER', (['ctypes.c_int64'], {}), '(ctypes.c_int64)\n', (4069, 4085), False, 'import ctypes\n'), ((3890, 3904), 'pathlib.Path', 'Path', (['__f... |
# Augur: A Step Towards Realistic Drift Detection in Production MLSystems - Code
# Copyright 2022 Carnegie Mellon University.
#
# NO WARRANTY. THIS CARNEGIE MELLON UNIVERSITY AND SOFTWARE ENGINEERING INSTITUTE MATERIAL IS FURNISHED ON AN "AS-IS" BASIS. CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITH... | [
"sklearn.model_selection.KFold",
"utils.logging.print_and_log",
"tensorflow.keras.callbacks.EarlyStopping",
"tensorflow.keras.callbacks.ModelCheckpoint"
] | [((2726, 2787), 'tensorflow.keras.callbacks.EarlyStopping', 'tfcb.EarlyStopping', (['"""val_loss"""'], {'patience': 'patience', 'mode': '"""min"""'}), "('val_loss', patience=patience, mode='min')\n", (2744, 2787), True, 'import tensorflow.keras.callbacks as tfcb\n'), ((2804, 2856), 'tensorflow.keras.callbacks.ModelChec... |
'''
utility functions
'''
__author__ = '<NAME>'
import os
from os.path import join
from os.path import abspath
import json
import pandas as pd
import numpy as np
from configs import config as cf
def is_available(filename):
'''
[filename] : str
'''
return os.path.isfile(filename)
def chunks(lst,... | [
"json.load",
"pandas.read_csv",
"os.path.isfile",
"os.path.join",
"pandas.concat",
"numpy.vstack"
] | [((278, 302), 'os.path.isfile', 'os.path.isfile', (['filename'], {}), '(filename)\n', (292, 302), False, 'import os\n'), ((965, 980), 'pandas.concat', 'pd.concat', (['data'], {}), '(data)\n', (974, 980), True, 'import pandas as pd\n'), ((1598, 1669), 'pandas.read_csv', 'pd.read_csv', (['data_path'], {'delimiter': '""",... |
from django.contrib import admin
from .models import Order
# Register your models here.
class OrderAdmin(admin.ModelAdmin):
list_display = ('id', 'name', 'phone_number', 'submitted')
list_filter = ('name', 'submitted')
readonly_fields = ('submitted',)
fieldsets = (
(None, {'fields': ('name', ... | [
"django.contrib.admin.site.register"
] | [((810, 848), 'django.contrib.admin.site.register', 'admin.site.register', (['Order', 'OrderAdmin'], {}), '(Order, OrderAdmin)\n', (829, 848), False, 'from django.contrib import admin\n')] |
import click
from rapt.connection import get_vr
from rapt.models import query, models
from rapt.util import edit_yaml, dump_yaml
from pprint import pformat
@click.command()
def buildpack():
tmpl = {
'repo_url': '',
'repo_type': ['git', 'hg'],
'description': '',
'order': 0,
}
... | [
"pprint.pformat",
"rapt.models.models.Buildpack",
"click.confirm",
"rapt.connection.get_vr",
"click.echo",
"click.command",
"rapt.util.dump_yaml",
"rapt.models.query"
] | [((161, 176), 'click.command', 'click.command', ([], {}), '()\n', (174, 176), False, 'import click\n'), ((330, 338), 'rapt.connection.get_vr', 'get_vr', ([], {}), '()\n', (336, 338), False, 'from rapt.connection import get_vr\n'), ((546, 603), 'click.echo', 'click.echo', (['"""Creating buildpack with following config:\... |
# -*- coding: utf-8 -*-
from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from geoprisma import views as geoprisma_views
@login_required
def maprender(request, *args, **kwargs):
wsName = kwargs.get('wsName')
viewId = kwargs.get('viewId')
if not viewId:
... | [
"django.shortcuts.render",
"geoprisma.views.maprender"
] | [((353, 403), 'geoprisma.views.maprender', 'geoprisma_views.maprender', (['request', 'wsName', 'viewId'], {}), '(request, wsName, viewId)\n', (378, 403), True, 'from geoprisma import views as geoprisma_views\n'), ((516, 581), 'django.shortcuts.render', 'render', (['request', "('example_project/' + templateName)", 'rend... |
"""
@Fire
https://github.com/fire717
"""
from lib import init, Data, MoveNet, Task
from config import cfg
from lib.utils.utils import arg_parser
# Script to create and save as images all the various outputs of the model
def main(cfg):
init(cfg)
model = MoveNet(num_classes=cfg["num_classes"],
... | [
"lib.MoveNet",
"lib.utils.utils.arg_parser",
"lib.Task",
"lib.Data",
"lib.init"
] | [((246, 255), 'lib.init', 'init', (['cfg'], {}), '(cfg)\n', (250, 255), False, 'from lib import init, Data, MoveNet, Task\n'), ((270, 358), 'lib.MoveNet', 'MoveNet', ([], {'num_classes': "cfg['num_classes']", 'width_mult': "cfg['width_mult']", 'mode': '"""train"""'}), "(num_classes=cfg['num_classes'], width_mult=cfg['w... |
#!/usr/bin/env python3
# [rights] Copyright 2020 brianddk at github https://github.com/brianddk
# [license] Apache 2.0 License https://www.apache.org/licenses/LICENSE-2.0
# [repo] github.com/brianddk/reddit/blob/master/python/elec-p2sh-hodl.py
# [btc] BTC-b32: bc1qwc2203uym96u0nmq04pcgqfs9ldqz9l3mz8fpj
# [tipja... | [
"electrum.constants.set_testnet",
"electrum.bitcoin.deserialize_privkey",
"electrum.transaction.PartialTxInput",
"electrum.transaction.PartialTxOutput.from_address_and_value",
"electrum.ecc.ECPrivkey",
"electrum.bitcoin.push_script",
"electrum.transaction.TxOutpoint",
"electrum.transaction.PartialTran... | [((1640, 1653), 'electrum.constants.set_testnet', 'set_testnet', ([], {}), '()\n', (1651, 1653), False, 'from electrum.constants import set_testnet\n'), ((2262, 2286), 'electrum.bitcoin.deserialize_privkey', 'deserialize_privkey', (['wif'], {}), '(wif)\n', (2281, 2286), False, 'from electrum.bitcoin import deserialize_... |
from django.contrib import admin
from app.models import *
class TrackAdmin(admin.ModelAdmin):
list_display=('title','description',)
class SessionAdmin(admin.ModelAdmin):
list_display = ('title','status',)
search_fields = ['title','abstract']
list_filter = ('track','speaker',)
actions =... | [
"django.contrib.admin.site.register"
] | [((1079, 1121), 'django.contrib.admin.site.register', 'admin.site.register', (['Speaker', 'SpeakerAdmin'], {}), '(Speaker, SpeakerAdmin)\n', (1098, 1121), False, 'from django.contrib import admin\n'), ((1122, 1160), 'django.contrib.admin.site.register', 'admin.site.register', (['Track', 'TrackAdmin'], {}), '(Track, Tra... |
#!/usr/bin/env python
"""
Defines unit-tests for the module at hms_core.data_objects.
"""
#######################################
# Any needed from __future__ imports #
# Create an "__all__" list to support #
# "from module import member" use #
#######################################
__all__ = [
# Test-case... | [
"uuid.uuid4",
"unittest.TestSuite",
"time.time",
"datetime.datetime.strptime",
"uuid.UUID",
"unittest.TestLoader",
"datetime.datetime.fromtimestamp",
"datetime.datetime.now",
"unittest.TestResult"
] | [((1371, 1391), 'unittest.TestSuite', 'unittest.TestSuite', ([], {}), '()\n', (1389, 1391), False, 'import unittest\n'), ((1891, 1905), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1903, 1905), False, 'from datetime import datetime\n'), ((1907, 1941), 'datetime.datetime.fromtimestamp', 'datetime.fromtime... |
from __future__ import annotations
import argparse
import asyncio
import getpass
import inspect
import json
import logging
import logging.config
import os
import threading
import time
import traceback
import warnings
import webbrowser
from dataclasses import dataclass, field
from datetime import datetime, timedelta
fr... | [
"os.remove",
"argparse.ArgumentParser",
"typing.cast",
"rich.traceback.install",
"logging.getLevelName",
"os.path.join",
"rich.logging.RichHandler",
"traceback.print_exc",
"warnings.simplefilter",
"shell.Command",
"bakalariapi.BakalariAPI",
"os.path.dirname",
"prompt_toolkit.input.create_inp... | [((1762, 1790), 'rich.traceback.install', 'tb_install', ([], {'show_locals': '(True)'}), '(show_locals=True)\n', (1772, 1790), True, 'from rich.traceback import install as tb_install\n'), ((1872, 1965), 'platformdirs.PlatformDirs', 'platformdirs.PlatformDirs', ([], {'appauthor': '"""BakalariAPI"""', 'appname': '"""baka... |
import json
import codecs
import pandas as pd
import boto3
csv_path = "./fixed_tweets.csv"
save_path = "./fixed_tweets.json"
df = pd.read_csv(csv_path, header=None, encoding = "utf-8")
df.columns =["tweet"]
df_json = df.to_dict(orient='records')
resource = boto3.resource('dynamodb', region_name='ap-northeast-1')
#... | [
"pandas.read_csv",
"boto3.resource"
] | [((133, 185), 'pandas.read_csv', 'pd.read_csv', (['csv_path'], {'header': 'None', 'encoding': '"""utf-8"""'}), "(csv_path, header=None, encoding='utf-8')\n", (144, 185), True, 'import pandas as pd\n'), ((261, 317), 'boto3.resource', 'boto3.resource', (['"""dynamodb"""'], {'region_name': '"""ap-northeast-1"""'}), "('dyn... |
"""Authentication routes."""
from __future__ import annotations
from flask import g
from flask_accept import accept_fallback
from keeper.api import api
from keeper.auth import password_auth
from keeper.logutils import log_route
from ._models import AuthTokenResponse
@api.route("/token")
@accept_fallback
@log_rout... | [
"keeper.logutils.log_route",
"keeper.api.api.route",
"flask.g.user.generate_auth_token"
] | [((274, 293), 'keeper.api.api.route', 'api.route', (['"""/token"""'], {}), "('/token')\n", (283, 293), False, 'from keeper.api import api\n'), ((312, 323), 'keeper.logutils.log_route', 'log_route', ([], {}), '()\n', (321, 323), False, 'from keeper.logutils import log_route\n'), ((1250, 1278), 'flask.g.user.generate_aut... |
"""
Test princomp extraction from CLI
"""
import argparse
import os
import numpy as np
from demo_utils import get_random_data
from hebbnets.networks import MultilayerHahNetwork
np.set_printoptions(suppress=True)
def _argparse():
parser = argparse.ArgumentParser(
prog="Testing HebbNet principal c... | [
"numpy.set_printoptions",
"demo_utils.get_random_data",
"argparse.ArgumentParser",
"hebbnets.networks.MultilayerHahNetwork",
"numpy.array_str",
"numpy.argsort",
"numpy.linalg.norm",
"numpy.array",
"numpy.squeeze"
] | [((186, 220), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'suppress': '(True)'}), '(suppress=True)\n', (205, 220), True, 'import numpy as np\n'), ((254, 410), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""Testing HebbNet principal components"""', 'description': '"""Testing HebbNet p... |
# -*- coding: utf-8 -*-
"""
## Author: <NAME>
## Copyright: Copyright 2018-2019, Packt Publishing Limited
## Version: 0.0.1
## Maintainer: <NAME>
## Email: <EMAIL>
## Linkedin: https://www.linkedin.com/in/linus1/
## Contributor : {if you debug, append your name here}
## Contributor Email : {if you debug, appen... | [
"matplotlib.pyplot.xlim",
"sklearn.pipeline.Pipeline",
"numpy.random.seed",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylim",
"numpy.random.randn",
"sklearn.model_selection.cross_val_score",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.setp",
"sklearn.linear_mode... | [((618, 635), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (632, 635), True, 'import numpy as np\n'), ((804, 827), 'numpy.cos', 'np.cos', (['(1.5 * np.pi * X)'], {}), '(1.5 * np.pi * X)\n', (810, 827), True, 'import numpy as np\n'), ((1018, 1045), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsi... |
import numpy as np
import argparse
from utils import Audio
def sample_wav_audio(path):
audio = Audio()
mel = audio.audio_to_mel(path)
samples = audio.mel_sample(mel, width=128, k=5)
return samples
def save_embeddings(name, samples):
audio = Audio()
avg_embed = np.zeros(256, dtype=np.float32)
... | [
"utils.Audio",
"numpy.save",
"numpy.zeros",
"argparse.ArgumentParser"
] | [((100, 107), 'utils.Audio', 'Audio', ([], {}), '()\n', (105, 107), False, 'from utils import Audio\n'), ((263, 270), 'utils.Audio', 'Audio', ([], {}), '()\n', (268, 270), False, 'from utils import Audio\n'), ((287, 318), 'numpy.zeros', 'np.zeros', (['(256)'], {'dtype': 'np.float32'}), '(256, dtype=np.float32)\n', (295... |
import argparse
import logging
import os
import pickle
import random
import ujson
import sys
import math
from ctypes import c_ulong
from multiprocessing import Array, Queue
from multiprocessing.sharedctypes import RawArray
from queue import Empty
from time import time
import numpy as np
import resource
from scipy.spa... | [
"argparse.ArgumentParser",
"experiments.duplicate_bug_detection_deep_learning.getDataHandlerLexiconEmb",
"sklearn.metrics.accuracy_score",
"numpy.around",
"multiprocessing.Queue",
"data.bug_report_database.BugReportDatabase.fromJson",
"experiments.duplicate_bug_detection_deep_learning.getModel",
"skle... | [((2982, 3001), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (2999, 3001), False, 'import logging\n'), ((3010, 3016), 'time.time', 'time', ([], {}), '()\n', (3014, 3016), False, 'from time import time\n'), ((6412, 6437), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (6435, 6437)... |
"""Tests for registering custom formatters."""
from pyramid.testing import DummyRequest
from pyramid.testing import testConfig
def test_add_formatter() -> None:
"""Test registration of a custom formatter."""
with testConfig() as config:
request = DummyRequest()
config.include("pyramid_opena... | [
"pyramid.testing.testConfig",
"pyramid.testing.DummyRequest"
] | [((225, 237), 'pyramid.testing.testConfig', 'testConfig', ([], {}), '()\n', (235, 237), False, 'from pyramid.testing import testConfig\n'), ((267, 281), 'pyramid.testing.DummyRequest', 'DummyRequest', ([], {}), '()\n', (279, 281), False, 'from pyramid.testing import DummyRequest\n')] |
#!/usr/bin/env python
"""Test USCG specific 8:367:22 area notice message Version 23 samples."""
import datetime
import unittest
from ais_area_notice import m366_22
# from m366_22 import AreaNotice
# from m366_22 import AreaNoticeCircle
# from m366_22 import AreaNoticeRectangle
# from m366_22 import AreaNoticeSector
... | [
"unittest.main",
"unittest.skip",
"ais_area_notice.m366_22.AreaNotice",
"datetime.datetime.utcnow"
] | [((1203, 1252), 'unittest.skip', 'unittest.skip', (['"""TODO(schwehr): Fix this failure."""'], {}), "('TODO(schwehr): Fix this failure.')\n", (1216, 1252), False, 'import unittest\n'), ((1593, 1608), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1606, 1608), False, 'import unittest\n'), ((614, 640), 'datetime.da... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
########################################################################
#
# Copyright 2015 Baidu, Inc.
#
########################################################################
"""
File: test_create_thumbnail.py
Date: 2015/06/10 15:15:40
"""
import os
import sys
impo... | [
"mediaBase.MediaBase.__init__",
"os.path.abspath",
"nose.tools.assert_true",
"nose.tools.assert_raises_regexp",
"sys.path.insert",
"baidubce.services.media.media_client.MediaClient",
"time.sleep",
"nose.tools.assert_is_not_none"
] | [((504, 536), 'sys.path.insert', 'sys.path.insert', (['(0)', '_COMMON_PATH'], {}), '(0, _COMMON_PATH)\n', (519, 536), False, 'import sys\n'), ((432, 457), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (447, 457), False, 'import os\n'), ((1010, 1044), 'mediaBase.MediaBase.__init__', 'mediaBas... |
#!/usr/bin/env python3
"""
This module specifies class Monitored designated for processing of cryptocurrencies blocks
"""
import threading
import logging
from timeit import default_timer as timer
from datetime import datetime, timedelta
from .coin import BTC, BCH, DASH, ZEC, LTC, ETH
from .database import Database
from... | [
"threading.Thread",
"timeit.default_timer",
"threading.Event",
"datetime.datetime.now",
"logging.getLogger"
] | [((357, 384), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (374, 384), False, 'import logging\n'), ((492, 509), 'threading.Event', 'threading.Event', ([], {}), '()\n', (507, 509), False, 'import threading\n'), ((2015, 2079), 'threading.Thread', 'threading.Thread', ([], {'target': 'self.... |
import threading
class MultiThreading(object):
def __init__(self, scrapers):
self.scrapers = scrapers
def run(self):
threads = []
for i in range(len(self.scrapers)):
t = threading.Thread(target=self.scrapers[i].start)
t.start()
threads.append(t)
... | [
"threading.Thread"
] | [((218, 265), 'threading.Thread', 'threading.Thread', ([], {'target': 'self.scrapers[i].start'}), '(target=self.scrapers[i].start)\n', (234, 265), False, 'import threading\n')] |
import glob
import numpy as np
from matplotlib import pyplot as plt
for filename in glob.glob("*.dat"):
print(filename)
name = filename.split(".")[0]
data = np.loadtxt(filename, delimiter=",")
size = int(np.sqrt(len(data)))
data = data.reshape((size, size))
fig, ax = plt.subplots(figsize=(5.12,... | [
"matplotlib.pyplot.close",
"matplotlib.pyplot.subplots",
"numpy.loadtxt",
"glob.glob",
"matplotlib.pyplot.tick_params",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.savefig"
] | [((85, 103), 'glob.glob', 'glob.glob', (['"""*.dat"""'], {}), "('*.dat')\n", (94, 103), False, 'import glob\n'), ((170, 205), 'numpy.loadtxt', 'np.loadtxt', (['filename'], {'delimiter': '""","""'}), "(filename, delimiter=',')\n", (180, 205), True, 'import numpy as np\n'), ((293, 327), 'matplotlib.pyplot.subplots', 'plt... |
# -*- coding: utf-8 -*-
"""
Created on Sun Aug 6 00:25:27 2017
@author: Wayne
"""
import pandas as pd
import xgboost as xgb
import numpy as np
from sklearn.model_selection import train_test_split
import pickle
#%%
mydf1= mydf[outliers.outliers==False]
z = np.log(data.trip_duration+1)
X = mydf1
Xtest ... | [
"pandas.DataFrame",
"sklearn.cluster.MiniBatchKMeans",
"numpy.log",
"xgboost.train",
"sklearn.model_selection.train_test_split",
"pandas.get_dummies",
"pickle.load",
"numpy.mean",
"numpy.exp",
"numpy.intersect1d",
"pandas.concat",
"xgboost.DMatrix",
"numpy.vstack"
] | [((273, 303), 'numpy.log', 'np.log', (['(data.trip_duration + 1)'], {}), '(data.trip_duration + 1)\n', (279, 303), True, 'import numpy as np\n'), ((342, 360), 'xgboost.DMatrix', 'xgb.DMatrix', (['Xtest'], {}), '(Xtest)\n', (353, 360), True, 'import xgboost as xgb\n'), ((899, 952), 'sklearn.model_selection.train_test_sp... |
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
import cPickle
import ipdb
class Detector():
def __init__(self,weight_file_path,n_labels):
self.image_mean=[103.939,116.779,123.68]
self.n_labels=n_labels
with open(weight_file_path)as f:
self.pretrained_weights=cPickle.load(f)
def get_weight... | [
"tensorflow.nn.relu",
"tensorflow.constant_initializer",
"tensorflow.reshape",
"tensorflow.reduce_mean",
"tensorflow.concat",
"cPickle.load",
"tensorflow.variable_scope",
"tensorflow.nn.bias_add",
"tensorflow.nn.max_pool",
"tensorflow.matmul",
"tensorflow.get_variable",
"tensorflow.random_norm... | [((1521, 1539), 'numpy.prod', 'np.prod', (['shape[1:]'], {}), '(shape[1:])\n', (1528, 1539), True, 'import numpy as np\n'), ((1544, 1573), 'tensorflow.reshape', 'tf.reshape', (['bottom', '[-1, dim]'], {}), '(bottom, [-1, dim])\n', (1554, 1573), True, 'import tensorflow as tf\n'), ((2136, 2154), 'numpy.prod', 'np.prod',... |
# -*- coding: utf-8 -*-
import os
from unittest import TestCase
import tempfile
from server import db
def use_temp_db(filename):
def _use_temp_db(fn):
def wrapper(obj):
with tempfile.TemporaryDirectory() as dirname:
fn(obj, os.path.join(dirname, filename))
return wrapp... | [
"tempfile.NamedTemporaryFile",
"tempfile.TemporaryDirectory",
"server.db.ItemLabelDBController",
"server.db.MatchResultDBController",
"os.path.join",
"server.db.RatedMatchResultDBController"
] | [((695, 731), 'server.db.MatchResultDBController', 'db.MatchResultDBController', (['filename'], {}), '(filename)\n', (721, 731), False, 'from server import db\n'), ((1176, 1212), 'server.db.MatchResultDBController', 'db.MatchResultDBController', (['filename'], {}), '(filename)\n', (1202, 1212), False, 'from server impo... |
"""Quantitative Proteomic Service
Usage:
pyqp api
pyqp cli <proteomicTSV> <proteomeXML> [--field=<quantity_column>] [--adress=<apiAdress>] [--port=<apiPort>] [--verbose] [--topScore=<pathway_number>]
Options:
-h --help Show this screen.
--field=<quantity column> csv column header featuring signal
... | [
"unigo.uloads",
"pyproteinsExt.uniprot.EntrySet",
"requests.get",
"docopt.docopt"
] | [((1037, 1052), 'docopt.docopt', 'docopt', (['__doc__'], {}), '(__doc__)\n', (1043, 1052), False, 'from docopt import docopt\n'), ((1406, 1471), 'pyproteinsExt.uniprot.EntrySet', 'createUniprotCollection', ([], {'collectionXML': "arguments['<proteomeXML>']"}), "(collectionXML=arguments['<proteomeXML>'])\n", (1429, 1471... |
from kafka import KafkaConsumer, TopicPartition
from json import loads
from sqlalchemy import create_engine, Table, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
import os
user = os.getenv('MYSQL_user')
pw = os.getenv('MYSQL')
str_sql = 'mysql+mysqlconnector://' + user + ':' + pw + '@... | [
"sqlalchemy.String",
"sqlalchemy.ext.declarative.declarative_base",
"sqlalchemy.Column",
"sqlalchemy.create_engine",
"os.getenv"
] | [((214, 237), 'os.getenv', 'os.getenv', (['"""MYSQL_user"""'], {}), "('MYSQL_user')\n", (223, 237), False, 'import os\n'), ((243, 261), 'os.getenv', 'os.getenv', (['"""MYSQL"""'], {}), "('MYSQL')\n", (252, 261), False, 'import os\n'), ((348, 370), 'sqlalchemy.create_engine', 'create_engine', (['str_sql'], {}), '(str_sq... |
import os
from google.cloud import speech_v1p1beta1 as speech
import io
#Set env variable, because it resets every shell session
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "/home/robin_jf_andersson/mbox_speaker_diarization/mbox1-28508a73fde1.json"
def speaker_diarization(audio_file, channels, sample_rate, nbr_of_... | [
"google.cloud.speech_v1p1beta1.RecognitionConfig",
"google.cloud.speech_v1p1beta1.RecognitionAudio",
"google.cloud.speech_v1p1beta1.SpeechClient"
] | [((343, 364), 'google.cloud.speech_v1p1beta1.SpeechClient', 'speech.SpeechClient', ([], {}), '()\n', (362, 364), True, 'from google.cloud import speech_v1p1beta1 as speech\n'), ((492, 532), 'google.cloud.speech_v1p1beta1.RecognitionAudio', 'speech.RecognitionAudio', ([], {'content': 'content'}), '(content=content)\n', ... |
from manimlib.imports import *
from ManimProjects.utils.Parabola import Parabola
from ManimProjects.utils.geometry import CText
class Prob1(Parabola):
CONFIG = {
'x_min' : -5
}
def construct(self):
self.adjust_x_range()
graph = self.get_graph(color=LIGHT_BROWN)
directrix = s... | [
"ManimProjects.utils.geometry.CText"
] | [((1736, 1748), 'ManimProjects.utils.geometry.CText', 'CText', (['"""焦点弦"""'], {}), "('焦点弦')\n", (1741, 1748), False, 'from ManimProjects.utils.geometry import CText\n'), ((8883, 8900), 'ManimProjects.utils.geometry.CText', 'CText', (['"""这些交点在准线上"""'], {}), "('这些交点在准线上')\n", (8888, 8900), False, 'from ManimProjects.ut... |
'''faça um programa que mostre a tabuada de vários números, um de cada vez, para cada valor digitado
pelo usuário. O programa será interrompido quando o valor solicitado for negativo.'''
from time import sleep
n = 0
cont = 0
while n >= 0:
print('--' * 15)
print('\033[33mPara cancelar, digite um número negativo.... | [
"time.sleep"
] | [((489, 497), 'time.sleep', 'sleep', (['(1)'], {}), '(1)\n', (494, 497), False, 'from time import sleep\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import json
import os
from contextlib import contextmanager
import click
import crayons
def open_url(url):
click.echo("Opening {}.".format(crayons.white(url, bold=True)))
click.launch(url)
def get_config_file_path():
home = os.path.expanduser("~")
retur... | [
"json.dump",
"crayons.white",
"os.path.exists",
"click.launch",
"os.path.expanduser"
] | [((228, 245), 'click.launch', 'click.launch', (['url'], {}), '(url)\n', (240, 245), False, 'import click\n'), ((287, 310), 'os.path.expanduser', 'os.path.expanduser', (['"""~"""'], {}), "('~')\n", (305, 310), False, 'import os\n'), ((640, 660), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (654, 660),... |
import json
import requests
import ccxt
import time
import os
import pandas as pd
from datetime import datetime, timedelta
import operator
import csv
import cfg
liquid = ccxt.liquid(cfg.liquid_misc_credential)
exchange = liquid
since = exchange.milliseconds() - 86400000 # -1 day from now
def save_and_get_str():
... | [
"pandas.DataFrame",
"pandas.read_csv",
"time.sleep",
"ccxt.liquid",
"os.path.isfile"
] | [((172, 211), 'ccxt.liquid', 'ccxt.liquid', (['cfg.liquid_misc_credential'], {}), '(cfg.liquid_misc_credential)\n', (183, 211), False, 'import ccxt\n'), ((784, 875), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['utc', 'time', 'type', 'amount', 'price', 'fee', 'takerOrMaker']"}), "(columns=['utc', 'time', 'typ... |
import re
from datetime import datetime
from datetime import timedelta
import dateutil.parser
import pytz
import tzlocal
# datetime objct for beginning of epoch
T_EPOCH = datetime(1970, 1, 1, tzinfo=pytz.utc)
DEFAULT = object() # singleton, for args with default values
class DateTimeError(Exception):
""" custo... | [
"tzlocal.get_localzone",
"datetime.datetime",
"datetime.datetime.strptime",
"datetime.timedelta",
"datetime.datetime.now",
"re.compile"
] | [((173, 210), 'datetime.datetime', 'datetime', (['(1970)', '(1)', '(1)'], {'tzinfo': 'pytz.utc'}), '(1970, 1, 1, tzinfo=pytz.utc)\n', (181, 210), False, 'from datetime import datetime\n'), ((634, 670), 're.compile', 're.compile', (["('^' + single_delta + '$')"], {}), "('^' + single_delta + '$')\n", (644, 670), False, '... |
"""
This module implements connections for CUBRIDdb. Presently there is
only one class: Connection. Others are unlikely. However, you might
want to make your own subclasses. In most cases, you will probably
override Connection.default_cursor with a non-standard Cursor class.
"""
from CUBRIDdb.cursors import *
import t... | [
"_cubrid.connect"
] | [((634, 667), '_cubrid.connect', '_cubrid.connect', (['*args'], {}), '(*args, **kwargs2)\n', (649, 667), False, 'import types, _cubrid\n')] |
from setuptools import setup
setup(name='tutorials',
version='POC',
url='https://github.com/pyomeca/tutorials.git',
author='pyomeca',
packages=['src'],
zip_safe=False)
| [
"setuptools.setup"
] | [((30, 178), 'setuptools.setup', 'setup', ([], {'name': '"""tutorials"""', 'version': '"""POC"""', 'url': '"""https://github.com/pyomeca/tutorials.git"""', 'author': '"""pyomeca"""', 'packages': "['src']", 'zip_safe': '(False)'}), "(name='tutorials', version='POC', url=\n 'https://github.com/pyomeca/tutorials.git', ... |
import random
import json
import math
async def battle_attack(x, y, u, e, call):
if x == y:
await call.answer("❗ Противник увернулся от удара", show_alert=True)
return e.health, e.defence
else:
if e.defence <= 0:
e.health -= u.damage
return e.health, e.defence
... | [
"math.floor",
"random.randint",
"random.uniform"
] | [((2701, 2723), 'random.randint', 'random.randint', (['(1)', '(100)'], {}), '(1, 100)\n', (2715, 2723), False, 'import random\n'), ((3000, 3026), 'math.floor', 'math.floor', (['(n * multiplier)'], {}), '(n * multiplier)\n', (3010, 3026), False, 'import math\n'), ((3170, 3194), 'random.uniform', 'random.uniform', (['(0.... |
import pandas as pd
from news_classifier.database import db
def load_data(projection: dict) -> pd.DataFrame:
"""
Load the data from the Mongo collection and transform
into a pandas dataframe
:projection: A dictionary with the fields to load from database
:return: A pandas dataframe with the data
... | [
"pandas.DataFrame",
"news_classifier.database.db.read_articles"
] | [((343, 382), 'news_classifier.database.db.read_articles', 'db.read_articles', ([], {'projection': 'projection'}), '(projection=projection)\n', (359, 382), False, 'from news_classifier.database import db\n'), ((408, 430), 'pandas.DataFrame', 'pd.DataFrame', (['articles'], {}), '(articles)\n', (420, 430), True, 'import ... |
#!/usr/bin/env python
import argparse
import sys
from collections import defaultdict
DEFAULT_OUT = "stackcollapse-merged.txt"
def merge(files, dst):
data = defaultdict(lambda: 0)
for file in files:
with open(file, "r") as fp:
for line in fp.readlines():
stack, hits = lin... | [
"collections.defaultdict",
"argparse.ArgumentParser"
] | [((164, 187), 'collections.defaultdict', 'defaultdict', (['(lambda : 0)'], {}), '(lambda : 0)\n', (175, 187), False, 'from collections import defaultdict\n'), ((546, 582), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['sys.argv[0]'], {}), '(sys.argv[0])\n', (569, 582), False, 'import argparse\n'), ((596, 686)... |
import os
from fastapi import Depends, FastAPI, Response, status
from fastapi.middleware.cors import CORSMiddleware
from fastapi_users import FastAPIUsers
from fastapi_users.authentication import JWTAuthentication
from sqlalchemy.orm import Session
from .database.session import database, user_db
from .deps import db_... | [
"fastapi_users.authentication.JWTAuthentication",
"fastapi_users.FastAPIUsers",
"fastapi.Depends",
"os.getenv",
"fastapi.FastAPI"
] | [((1057, 1080), 'os.getenv', 'os.getenv', (['"""APP_SECRET"""'], {}), "('APP_SECRET')\n", (1066, 1080), False, 'import os\n'), ((1103, 1195), 'fastapi_users.authentication.JWTAuthentication', 'JWTAuthentication', ([], {'secret': 'APP_SECRET', 'lifetime_seconds': '(3600)', 'tokenUrl': '"""/auth/jwt/login"""'}), "(secret... |
"""Utility functions."""
import subprocess
import logging
import os
import shutil
import stat
import itertools
from collections import OrderedDict
from pkg_resources import resource_string
import pandas as pd
from genometools.expression import ExpGeneTable
from genometools import gtf
import singlecell
_LOGGER = lo... | [
"subprocess.Popen",
"os.chmod",
"os.stat",
"pandas.read_csv",
"os.walk",
"pkg_resources.resource_string",
"itertools.product",
"collections.OrderedDict",
"genometools.gtf.parse_attributes",
"shutil.copyfileobj",
"os.path.join",
"logging.getLogger"
] | [((318, 345), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (335, 345), False, 'import logging\n'), ((2162, 2175), 'os.stat', 'os.stat', (['path'], {}), '(path)\n', (2169, 2175), False, 'import os\n'), ((2180, 2221), 'os.chmod', 'os.chmod', (['path', '(st.st_mode | stat.S_IEXEC)'], {}), ... |
import os
import frida
from flask import Flask, jsonify, request
from hook import start_hook
REMOTE_DEVICE = os.getenv('REMOTE_DEVICE', '')
app = Flask(__name__)
api = start_hook(REMOTE_DEVICE)
@app.route('/sign')
def sign():
global api
url = request.args.get('url', '')
headers = dict(request.headers)... | [
"flask.request.args.get",
"flask.Flask",
"flask.jsonify",
"os.getenv",
"hook.start_hook"
] | [((111, 141), 'os.getenv', 'os.getenv', (['"""REMOTE_DEVICE"""', '""""""'], {}), "('REMOTE_DEVICE', '')\n", (120, 141), False, 'import os\n'), ((150, 165), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (155, 165), False, 'from flask import Flask, jsonify, request\n'), ((172, 197), 'hook.start_hook', 'star... |
import PySimpleGUI as sg
from ..model.objectdata import ObjectData
from ..model.search import SearchableList
from ..view import newproduction
from . import get_string_unit, RACES, filter_listbox
from myconfigparser import Section
def open_window(data):
options = SearchableList()
for u in data:
unit = ... | [
"myconfigparser.Section",
"PySimpleGUI.popup"
] | [((320, 336), 'myconfigparser.Section', 'Section', (['data[u]'], {}), '(data[u])\n', (327, 336), False, 'from myconfigparser import Section\n'), ((1030, 1049), 'PySimpleGUI.popup', 'sg.popup', (['"""Success"""'], {}), "('Success')\n", (1038, 1049), True, 'import PySimpleGUI as sg\n')] |
# Generated by Django 3.2.3 on 2021-08-10 02:38
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('artists', '0002_artist_bio'),
('beats', '0002_instrumental_img_file'),
]
operations = [
... | [
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField"
] | [((435, 567), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.models.deletion.DO_NOTHING', 'related_name': '"""+"""', 'to': '"""artists.artist"""'}), "(blank=True, null=True, on_delete=django.db.models.\n deletion.DO_NOTHING, related_name='+', to... |
import os
import sys
sys.path.append(os.path.join(sys.path[0], '../'))
from smart_pipeline import Pipeline
data = [1,2,3,4,5]
# Define a data function
def onlyOdd(item):
return False if item%2==0 else True
pl = Pipeline()
# Adds function into pipeline
pl.addDataPipe(onlyOdd)
res = pl(data)
for item in res:
... | [
"os.path.join",
"smart_pipeline.Pipeline"
] | [((220, 230), 'smart_pipeline.Pipeline', 'Pipeline', ([], {}), '()\n', (228, 230), False, 'from smart_pipeline import Pipeline\n'), ((38, 70), 'os.path.join', 'os.path.join', (['sys.path[0]', '"""../"""'], {}), "(sys.path[0], '../')\n", (50, 70), False, 'import os\n')] |
import tensorflow as tf
batch_size = 4
feature_num = 3
csv1 = [
"harden|james|curry",
"wrestbrook|harden|durant",
"paul|towns",
]
csv2 = [
"curry",
"wrestbrook|harden|durant",
"paul|towns",
]
csv3 = [
"harden|james|curry",
"durant",
"paul|towns",
]
csv4 = [
"wrestbrook|harden|durant",
"wrestbrook|harden|... | [
"tensorflow.contrib.layers.sparse_column_with_hash_bucket",
"tensorflow.global_variables_initializer",
"tensorflow.contrib.layers.embedding_column",
"tensorflow.Session",
"tensorflow.string_split",
"tensorflow.feature_column.input_layer",
"tensorflow.placeholder",
"tensorflow.shape",
"pdb.set_trace"... | [((392, 450), 'tensorflow.placeholder', 'tf.placeholder', ([], {'shape': '[None, feature_num]', 'dtype': 'tf.string'}), '(shape=[None, feature_num], dtype=tf.string)\n', (406, 450), True, 'import tensorflow as tf\n'), ((464, 601), 'tensorflow.contrib.layers.sparse_column_with_hash_bucket', 'tf.contrib.layers.sparse_col... |
"""
Commands for index operations
"""
import os
import re
import sys
import time
from typing import List
from zipfile import ZipFile, ZIP_DEFLATED
from datetime import datetime as DateTime
import click
from mnotes.environment import MnoteEnvironment, pass_env, echo_line, save_global_index_data
from mnotes.notes.in... | [
"mnotes.environment.save_global_index_data",
"mnotes.environment.echo_line",
"zipfile.ZipFile",
"click.argument",
"click.echo",
"click.style",
"datetime.datetime.now",
"time.time",
"os.path.relpath",
"click.group",
"os.path.join",
"sys.exit",
"re.compile"
] | [((413, 439), 're.compile', 're.compile', (['"""[^a-z0-9\\\\-]"""'], {}), "('[^a-z0-9\\\\-]')\n", (423, 439), False, 'import re\n'), ((443, 497), 'click.group', 'click.group', ([], {'name': '"""index"""', 'invoke_without_command': '(True)'}), "(name='index', invoke_without_command=True)\n", (454, 497), False, 'import c... |
import numpy as np
import os
import torch
import torch.nn as nn
import pytorch_lightning as pl
from data.VOCdevkit.vocdata import VOCDataset
from torch.utils.data import DataLoader
from torchvision.transforms import Compose, Resize, ToTensor, Normalize, GaussianBlur
from torchvision.transforms.functional import Interp... | [
"numpy.delete",
"torch.gather",
"torch.utils.data.DataLoader",
"os.path.join",
"numpy.sum",
"torch.argsort",
"torchvision.transforms.ToTensor",
"torch.cumsum",
"numpy.max",
"torch.nn.functional.interpolate",
"torchvision.transforms.GaussianBlur",
"torchvision.transforms.Normalize",
"torch.no... | [((1354, 1483), 'torch.utils.data.DataLoader', 'DataLoader', (['self.dataset'], {'batch_size': 'attn_batch_size', 'shuffle': '(False)', 'num_workers': 'num_workers', 'drop_last': '(True)', 'pin_memory': '(True)'}), '(self.dataset, batch_size=attn_batch_size, shuffle=False,\n num_workers=num_workers, drop_last=True, ... |
import socket, threading
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host = "127.0.0.1"
port = 9090
server.bind((host, port))
server.listen(5)
clients = list()
end = list()
def get():
while True:
client, addr = server.accept()
clients.append(client)
print(f'сервер подключе... | [
"threading.Thread",
"socket.socket"
] | [((35, 84), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (48, 84), False, 'import socket, threading\n'), ((1215, 1262), 'threading.Thread', 'threading.Thread', ([], {'target': 'send_mes', 'name': '"""input"""'}), "(target=send_mes, name='inp... |
# Autoencoder using convolutional layers
# Dataset : MNIST
# Requires : PIL, matplotlib
# Inspired by https://pytorch.org/tutorials/beginner/blitz/cifar10_tutorial.html
# To compress data : net.encode(data)
# To decompress data : net.decode(data)
# To mutate data : net(data)
import os
import numpy as np
import matplot... | [
"torch.nn.MSELoss",
"matplotlib.pyplot.show",
"torch.nn.ConvTranspose2d",
"torch.utils.data.DataLoader",
"torch.load",
"torch.nn.Conv2d",
"os.path.exists",
"numpy.transpose",
"torchvision.transforms.ToPILImage",
"torchvision.utils.make_grid",
"torch.cuda.is_available",
"torch.nn.Linear",
"to... | [((2274, 2295), 'torchvision.transforms.ToTensor', 'transforms.ToTensor', ([], {}), '()\n', (2293, 2295), False, 'from torchvision import transforms\n'), ((2306, 2373), 'torchvision.datasets.MNIST', 'MNIST', ([], {'root': 'dataset_dir', 'train': '(True)', 'download': '(True)', 'transform': 'trans'}), '(root=dataset_dir... |
# Monocyte - Search and Destroy unwanted AWS Resources relentlessly.
# Copyright 2015 Immobilien Scout GmbH
#
# 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/licens... | [
"monocyte.handler.Resource",
"boto.ec2.regions",
"boto.ec2.connect_to_region"
] | [((2322, 2360), 'boto.ec2.connect_to_region', 'ec2.connect_to_region', (['resource.region'], {}), '(resource.region)\n', (2343, 2360), False, 'from boto import ec2\n'), ((4121, 4159), 'boto.ec2.connect_to_region', 'ec2.connect_to_region', (['resource.region'], {}), '(resource.region)\n', (4142, 4159), False, 'from boto... |
from pathlib import Path
import requests
import string
import urllib
import random
import json
import sys
def acapyla(quote, voicename="willfromafar"):
try:
voiceid = "enu_" + voicename + "_22k_ns.bvcu"
except IndexError:
voiceid = "enu_willfromafar_22k_ns.bvcu"
letters = string.ascii_lower... | [
"requests.post",
"random.choice",
"pathlib.Path.home"
] | [((545, 587), 'requests.post', 'requests.post', ([], {'url': 'noncerl', 'data': 'noncedata'}), '(url=noncerl, data=noncedata)\n', (558, 587), False, 'import requests\n'), ((1074, 1133), 'requests.post', 'requests.post', ([], {'url': 'synthrl', 'data': 'synthdata', 'headers': 'headers'}), '(url=synthrl, data=synthdata, ... |
# -*- coding: utf-8 -*-
"""
This module
"""
import attr
import typing
from ..core.model import (
Property, Resource, Tag, GetAtt, TypeHint, TypeCheck,
)
from ..core.constant import AttrMeta
#--- Property declaration ---
@attr.s
class PropJobDefinitionAuthorizationConfig(Property):
"""
AWS Object Type =... | [
"attr.validators.instance_of"
] | [((6867, 6924), 'attr.validators.instance_of', 'attr.validators.instance_of', (['TypeCheck.intrinsic_str_type'], {}), '(TypeCheck.intrinsic_str_type)\n', (6894, 6924), False, 'import attr\n'), ((7264, 7296), 'attr.validators.instance_of', 'attr.validators.instance_of', (['int'], {}), '(int)\n', (7291, 7296), False, 'im... |
#!/usr/bin/env python
# coding: utf-8
# __buildin__ modules
import smtplib
from email.mime.text import MIMEText
from monitor.utils.settings import EMAIL_SERVER
from monitor.utils.settings import EMAIL_PORT
from monitor.utils.settings import EMAIL_USER
from monitor.utils.settings import EMAIL_PASS
from monitor.utils.s... | [
"email.mime.text.MIMEText",
"smtplib.SMTP_SSL"
] | [((562, 597), 'email.mime.text.MIMEText', 'MIMEText', (['content', '"""plain"""', '"""utf-8"""'], {}), "(content, 'plain', 'utf-8')\n", (570, 597), False, 'from email.mime.text import MIMEText\n'), ((708, 726), 'smtplib.SMTP_SSL', 'smtplib.SMTP_SSL', ([], {}), '()\n', (724, 726), False, 'import smtplib\n')] |
# Copyright (c) 2018 <NAME>
# Copyright (c) 2018 <NAME>
#
# Distributed under the Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
from phylanx import Phylanx
import numpy as np
@Phylanx
def foo():
local_a = np.array((2, 1))
lo... | [
"numpy.array"
] | [((297, 313), 'numpy.array', 'np.array', (['(2, 1)'], {}), '((2, 1))\n', (305, 313), True, 'import numpy as np\n'), ((364, 381), 'numpy.array', 'np.array', (['(57, 1)'], {}), '((57, 1))\n', (372, 381), True, 'import numpy as np\n')] |
import importlib
import json
import os
import sys
from pprint import pprint as pp
import pytest
import utils as util
from ixload import IxLoadTestSettings as TestSettings
from ixload import IxLoadUtils as IxLoadUtils
from ixload import IxRestUtils as IxRestUtils
from ixnetwork_restpy import SessionAssistant
from ixnet... | [
"ixload.IxRestUtils.getConnection",
"ixload.IxLoadTestSettings.IxLoadTestSettings",
"importlib.import_module",
"os.path.dirname",
"pytest.fixture",
"sys.path.insert"
] | [((467, 498), 'sys.path.insert', 'sys.path.insert', (['(0)', 'targets_dir'], {}), '(0, targets_dir)\n', (482, 498), False, 'import sys\n'), ((502, 533), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (516, 533), False, 'import pytest\n'), ((722, 771), 'pytest.fixture', 'pyt... |
import matplotlib.pyplot as plt
import matplotlib
import numpy as np
import datetime
from dateutil.tz import tzutc
def plot_water_levels(station, dates, levels):
"""Task 2E: Plots water level against time"""
#Assign variables
range_high = [station.typical_range[1]]*len(dates)
range_low = [station.ty... | [
"matplotlib.pyplot.title",
"numpy.poly1d",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"numpy.polyfit",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xticks",
"numpy.linspace",
"matplotlib.dates.date2num",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.tigh... | [((363, 407), 'matplotlib.pyplot.plot', 'plt.plot', (['dates', 'levels'], {'label': '"""Water Level"""'}), "(dates, levels, label='Water Level')\n", (371, 407), True, 'import matplotlib.pyplot as plt\n'), ((412, 461), 'matplotlib.pyplot.plot', 'plt.plot', (['dates', 'range_high'], {'label': '"""Typical High"""'}), "(da... |
from app import database
def get_single_json_entity(entity_query):
query_result_proxy = database.session.execute(entity_query)
database.session.commit()
row_proxies = [r for r in query_result_proxy]
if len(row_proxies) == 1:
json_entity = {k: v for k, v in row_proxies[0].items()}
else:
... | [
"app.database.session.commit",
"app.database.session.execute"
] | [((94, 132), 'app.database.session.execute', 'database.session.execute', (['entity_query'], {}), '(entity_query)\n', (118, 132), False, 'from app import database\n'), ((137, 162), 'app.database.session.commit', 'database.session.commit', ([], {}), '()\n', (160, 162), False, 'from app import database\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2020 Huawei Device 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
#
#... | [
"os.path.abspath",
"os.path.split",
"os.path.join",
"argparse.ArgumentParser"
] | [((1913, 1938), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1936, 1938), False, 'import argparse\n'), ((2244, 2269), 'os.path.split', 'os.path.split', (['args.input'], {}), '(args.input)\n', (2257, 2269), False, 'import os\n'), ((2288, 2316), 'os.path.abspath', 'os.path.abspath', (['args.ou... |
from basicts.utils.registry import SCALER_REGISTRY
"""
data normalization and re-normalization
"""
# ====================================== re-normalizations ====================================== #
@SCALER_REGISTRY.register()
def re_max_min_normalization(x, **kwargs):
_min, _max = kwargs['min'], kwargs['max']
... | [
"basicts.utils.registry.SCALER_REGISTRY.register"
] | [((202, 228), 'basicts.utils.registry.SCALER_REGISTRY.register', 'SCALER_REGISTRY.register', ([], {}), '()\n', (226, 228), False, 'from basicts.utils.registry import SCALER_REGISTRY\n'), ((393, 419), 'basicts.utils.registry.SCALER_REGISTRY.register', 'SCALER_REGISTRY.register', ([], {}), '()\n', (417, 419), False, 'fro... |
from jinja2 import Environment, PackageLoader, select_autoescape
import yaml
import json
import pkg_resources
import os
env = Environment(
loader=PackageLoader('kite_metrics', 'schemas'),
)
cache = {}
def _schema_exists(filename):
return pkg_resources.resource_exists('kite_metrics', 'schemas/{}'.format(file... | [
"jinja2.PackageLoader",
"json.loads"
] | [((152, 192), 'jinja2.PackageLoader', 'PackageLoader', (['"""kite_metrics"""', '"""schemas"""'], {}), "('kite_metrics', 'schemas')\n", (165, 192), False, 'from jinja2 import Environment, PackageLoader, select_autoescape\n'), ((1501, 1521), 'json.loads', 'json.loads', (['rendered'], {}), '(rendered)\n', (1511, 1521), Fa... |
###############################################################################
# Copyright (c) 2017-2020 <NAME> (Cisco Systems), #
# <NAME> (Cisco Systems), <NAME> (Cisco Systems) and others #
# #
# All rights r... | [
"base.utils.configuration.Configuration"
] | [((1360, 1375), 'base.utils.configuration.Configuration', 'Configuration', ([], {}), '()\n', (1373, 1375), False, 'from base.utils.configuration import Configuration\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.17 on 2020-11-02 11:30
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('activities', '0027_contributionvalue'),
('time_bas... | [
"django.db.migrations.RemoveField",
"django.db.models.OneToOneField",
"django.db.models.DateField"
] | [((2833, 2904), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""application"""', 'name': '"""current_period"""'}), "(model_name='application', name='current_period')\n", (2855, 2904), False, 'from django.db import migrations, models\n'), ((508, 685), 'django.db.models.OneToOneField... |
from __future__ import annotations
from amulet.world_interface.chunk.interfaces.leveldb.leveldb_14.interface import (
LevelDB14Interface,
)
class LevelDB15Interface(LevelDB14Interface):
def __init__(self):
LevelDB14Interface.__init__(self)
self.features["chunk_version"] = 15
INTERFACE_CLAS... | [
"amulet.world_interface.chunk.interfaces.leveldb.leveldb_14.interface.LevelDB14Interface.__init__"
] | [((225, 258), 'amulet.world_interface.chunk.interfaces.leveldb.leveldb_14.interface.LevelDB14Interface.__init__', 'LevelDB14Interface.__init__', (['self'], {}), '(self)\n', (252, 258), False, 'from amulet.world_interface.chunk.interfaces.leveldb.leveldb_14.interface import LevelDB14Interface\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# 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 t... | [
"jobson_systemtests.run",
"argparse.ArgumentParser"
] | [((727, 789), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Run jobson system tests"""'}), "(description='Run jobson system tests')\n", (750, 789), False, 'import argparse\n'), ((1446, 1573), 'jobson_systemtests.run', 'jobson_systemtests.run', ([], {'specs_dir': 'args.specs_dir', 'host'... |
from discord.ext import commands
import discord
import yaml
import os
class Bot(commands.Bot):
async def get_prefix(self, bot, message):
"""Fetches the current prefix in the guild from the database."""
return commands.when_mentioned_or("onyx ")
def __init__(self):
"""Initialize the bot... | [
"discord.ext.commands.when_mentioned_or",
"discord.Intents.default",
"yaml.safe_load",
"os.getenv"
] | [((728, 746), 'os.getenv', 'os.getenv', (['"""TOKEN"""'], {}), "('TOKEN')\n", (737, 746), False, 'import os\n'), ((230, 265), 'discord.ext.commands.when_mentioned_or', 'commands.when_mentioned_or', (['"""onyx """'], {}), "('onyx ')\n", (256, 265), False, 'from discord.ext import commands\n'), ((442, 459), 'yaml.safe_lo... |
import urllib.parse
from django.shortcuts import render
#from ckan_model import stub as ckan
from ckan_model import production as ckan
#from ..ckan_model import production as ckan
import django.http
def index(request: django.http.HttpRequest):
payload = {}
google = ckan.Search()
payload['top_tags'] = ... | [
"django.shortcuts.render",
"ckan_model.production.Search"
] | [((280, 293), 'ckan_model.production.Search', 'ckan.Search', ([], {}), '()\n', (291, 293), True, 'from ckan_model import production as ckan\n'), ((349, 395), 'django.shortcuts.render', 'render', (['request', '"""index.html"""'], {'context': 'payload'}), "(request, 'index.html', context=payload)\n", (355, 395), False, '... |
import numpy as np
from scipy.integrate import quad
import matplotlib.pyplot as plt
def Redshift(n0, n1, n2, z1=3.6, z=np.linspace(0,10,num=1001)):
Rlow = np.power((1.0 + z), n1)
Rhigh = np.power((1.0 + z), n2)
rbrk = np.power((1.0 + z1), n1 - n2)
R = Rlow * (z <= z1) + rbrk * Rhigh * (z > z1)
R *= n0 / R[0]
ret... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"scipy.integrate.quad",
"numpy.power",
"numpy.savetxt",
"numpy.zeros",
"numpy.linspace",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid",
"numpy.concatenate"
] | [((365, 385), 'matplotlib.pyplot.plot', 'plt.plot', (['z', 'R', '"""-k"""'], {}), "(z, R, '-k')\n", (373, 385), True, 'import matplotlib.pyplot as plt\n'), ((384, 401), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""$z$"""'], {}), "('$z$')\n", (394, 401), True, 'import matplotlib.pyplot as plt\n'), ((403, 434), 'matpl... |
from waio.keyboard.reply import QuickReplyContentText, QuickReply, KeyboardButton, QuickReplyContentImage
from callback import callback_reply_keyboard
def generate_keyboard_place():
kb_content = QuickReplyContentText(
header="Куда вы сегодня хотите сходить?",
text="Выберите из предложенного списка... | [
"waio.keyboard.reply.QuickReplyContentText",
"waio.keyboard.reply.KeyboardButton",
"callback.callback_reply_keyboard.new",
"waio.keyboard.reply.QuickReplyContentImage"
] | [((201, 322), 'waio.keyboard.reply.QuickReplyContentText', 'QuickReplyContentText', ([], {'header': '"""Куда вы сегодня хотите сходить?"""', 'text': '"""Выберите из предложенного списка"""', 'caption': '""""""'}), "(header='Куда вы сегодня хотите сходить?', text=\n 'Выберите из предложенного списка', caption='')\n",... |
#!/usr/bin/env python
# Python script for fast text file searching using keyword index on disk.
#
# Author: <NAME> <<EMAIL>>
# Last Change: November 1, 2015
# URL: http://peterodding.com/code/vim/notes/
# License: MIT
#
# This Python script can be used by the notes.vim plug-in to perform fast
# keyword searches in the... | [
"codecs.encode",
"pickle.dump",
"getopt.getopt",
"logging.basicConfig",
"os.path.join",
"codecs.decode",
"os.path.isdir",
"Levenshtein.distance",
"os.walk",
"time.time",
"re.findall",
"pickle.load",
"os.path.getmtime",
"sys.exit",
"os.path.expanduser",
"fnmatch.fnmatch",
"logging.get... | [((2271, 2313), 'os.path.expanduser', 'os.path.expanduser', (['"""~/notes-index.pickle"""'], {}), "('~/notes-index.pickle')\n", (2289, 2313), False, 'import os\n'), ((2315, 2355), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (2334, 2355), False, 'import logg... |
"""Implementation of the FunctionInjectionWalker class."""
from inspect import (
signature as inspect_signature)
from types import (
CodeType,
FunctionType)
from typing import (
Iterator,
Optional)
from .abstract_injection_walker import (
AbstractInjectionWalker)
from .code_object_injection_w... | [
"types.FunctionType",
"inspect.signature"
] | [((6470, 6496), 'types.FunctionType', 'FunctionType', (['code_obj', '{}'], {}), '(code_obj, {})\n', (6482, 6496), False, 'from types import CodeType, FunctionType\n'), ((6524, 6547), 'inspect.signature', 'inspect_signature', (['func'], {}), '(func)\n', (6541, 6547), True, 'from inspect import signature as inspect_signa... |
#
# Copyright (c) nexB Inc. and others. All rights reserved.
# http://nexb.com and https://github.com/nexB/tracecode-toolkit/
# The TraceCode software is licensed under the Apache License version 2.0.
# Data generated with TraceCode require an acknowledgment.
# TraceCode is a trademark of nexB Inc.
#
# You may not use ... | [
"tracecode.pathutils.common_path_suffix",
"tracecode.pathutils.common_path_prefix"
] | [((1673, 1721), 'tracecode.pathutils.common_path_prefix', 'pathutils.common_path_prefix', (['"""/a/b/c"""', '"""/a/b/c"""'], {}), "('/a/b/c', '/a/b/c')\n", (1701, 1721), False, 'from tracecode import pathutils\n'), ((1814, 1860), 'tracecode.pathutils.common_path_prefix', 'pathutils.common_path_prefix', (['"""/a/b/c"""'... |
# Generated by Django 3.2.8 on 2021-10-24 01:32
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('dim_sum', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='dimsum',
name='history',
fi... | [
"django.db.models.TextField"
] | [((324, 371), 'django.db.models.TextField', 'models.TextField', ([], {'default': '"""Write summary here."""'}), "(default='Write summary here.')\n", (340, 371), False, 'from django.db import migrations, models\n')] |
# Copyright (c) 2020-2021 CRS4
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribu... | [
"tests.utils.pick_and_register_workflow",
"logging.getLogger"
] | [((1196, 1215), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (1213, 1215), False, 'import logging\n'), ((1302, 1357), 'tests.utils.pick_and_register_workflow', 'utils.pick_and_register_workflow', (['user1', 'valid_workflow'], {}), '(user1, valid_workflow)\n', (1334, 1357), False, 'from tests import utils... |
# =============================================
# -*- coding: utf-8 -*-
# @Time : 2020/5/14 上午10:50
# @Author : xiao9616
# @Email : <EMAIL>
# @File : BaseModel.py
# @Software: PyCharm
# ============================================
import logging
import tensorflow as tf
import os
f... | [
"tensorflow.math.ceil",
"logging.basicConfig",
"tensorflow.keras.metrics.Mean",
"tensorflow.print",
"tensorflow.keras.optimizers.schedules.ExponentialDecay",
"tensorflow.config.experimental.set_memory_growth",
"logging.info",
"tensorflow.keras.optimizers.Adam",
"tensorflow.debugging.set_log_device_p... | [((454, 635), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG', 'format': '"""%(asctime)s %(levelname)s %(message)s"""', 'datefmt': '"""%a, %d %b %Y %H:%M:%S"""', 'filename': '"""./yolo4/logs/train.log"""', 'filemode': '"""w+"""'}), "(level=logging.DEBUG, format=\n '%(asctime)s %(levelnam... |
import networkx as nx
import sys
from collections import defaultdict
sys.setrecursionlimit(100000000)
def direct_paths(lines):
world = nx.Graph()
for row,line in enumerate(lines):
for col,obj in enumerate(line):
if obj != '.':
continue
if line[col - 1] == '.':
... | [
"networkx.dijkstra_path_length",
"networkx.dijkstra_path",
"collections.defaultdict",
"networkx.Graph",
"sys.setrecursionlimit"
] | [((70, 102), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(100000000)'], {}), '(100000000)\n', (91, 102), False, 'import sys\n'), ((1461, 1538), 'networkx.dijkstra_path', 'nx.dijkstra_path', (['W', "portal_connections['AA'][0]", "portal_connections['ZZ'][0]"], {}), "(W, portal_connections['AA'][0], portal_conne... |