code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import time
import asyncio
#import websockets
from io import BytesIO
import os
import json
from flask import Flask, jsonify, request, make_response
from flask_socketio import SocketIO, send, emit
#import predict
dir_path = os.path.dirname(os.path.realpath(__file__))
app = Flask(__name__)
#app.config['SECRET_KEY'] =... | [
"os.path.realpath",
"flask_socketio.emit",
"flask_socketio.SocketIO",
"flask.Flask"
] | [((277, 292), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (282, 292), False, 'from flask import Flask, jsonify, request, make_response\n'), ((342, 355), 'flask_socketio.SocketIO', 'SocketIO', (['app'], {}), '(app)\n', (350, 355), False, 'from flask_socketio import SocketIO, send, emit\n'), ((242, 268), ... |
import numpy as np
import torch
import torch.nn as nn
from PIL import Image
from loader.dataloader import ColorSpace2RGB
from torchvision import transforms
from torchvision.transforms.functional import InterpolationMode as IM
# Only for inference
class plt2pix(object):
def __init__(self, args):
... | [
"network.Generator",
"torchvision.transforms.Resize",
"torch.nn.DataParallel",
"torch.cuda.device_count",
"loader.dataloader.ColorSpace2RGB",
"numpy.zeros",
"torch.cuda.is_available",
"network.ColorPredictor",
"torchvision.transforms.ToTensor",
"torch.FloatTensor",
"torch.device"
] | [((622, 654), 'loader.dataloader.ColorSpace2RGB', 'ColorSpace2RGB', (['args.color_space'], {}), '(args.color_space)\n', (636, 654), False, 'from loader.dataloader import ColorSpace2RGB\n'), ((1259, 1373), 'network.Generator', 'Generator', ([], {'input_size': 'args.input_size', 'layers': 'args.layers', 'palette_num': 's... |
from django.apps import AppConfig
from django.db.models.signals import pre_save
class CommentsXtdConfig(AppConfig):
default_auto_field = 'django.db.models.AutoField'
name = 'django_comments_xtd'
verbose_name = 'Comments Xtd'
def ready(self):
from django_comments_xtd import get_model
f... | [
"django_comments_xtd.get_model",
"django.db.models.signals.pre_save.connect"
] | [((450, 524), 'django.db.models.signals.pre_save.connect', 'pre_save.connect', (['publish_or_unpublish_on_pre_save'], {'sender': 'model_app_label'}), '(publish_or_unpublish_on_pre_save, sender=model_app_label)\n', (466, 524), False, 'from django.db.models.signals import pre_save\n'), ((418, 429), 'django_comments_xtd.g... |
"""Manages different functions related to cc rules parsing."""
__author__ = '<EMAIL> (<NAME>)'
__copyright__ = 'Copyright 2012 Room77, Inc.'
import itertools
import os
import shutil
import time
from pylib.base.term_color import TermColor
from pylib.base.exec_utils import ExecUtils
from pylib.file.file_utils import ... | [
"pylib.flash.utils.Utils.RuleDisplayName",
"pylib.file.file_utils.FileUtils.GetBinPathForFile",
"os.path.join",
"os.path.basename"
] | [((1314, 1349), 'pylib.file.file_utils.FileUtils.GetBinPathForFile', 'FileUtils.GetBinPathForFile', (['target'], {}), '(target)\n', (1341, 1349), False, 'from pylib.file.file_utils import FileUtils\n'), ((1370, 1394), 'os.path.basename', 'os.path.basename', (['target'], {}), '(target)\n', (1386, 1394), False, 'import o... |
from Bio import SeqIO
import pandas
def describe(file_name):
sections = pandas.read_csv(file_name, header=None)
print(sections.describe())
print(sections[3].sum())
def get_indices(file_name, segment_length, n_regions):
sections = pandas.read_csv(file_name, header=None, nrows=n_regions)
regions =... | [
"pandas.DataFrame",
"Bio.SeqIO.parse",
"pandas.read_csv"
] | [((78, 117), 'pandas.read_csv', 'pandas.read_csv', (['file_name'], {'header': 'None'}), '(file_name, header=None)\n', (93, 117), False, 'import pandas\n'), ((250, 306), 'pandas.read_csv', 'pandas.read_csv', (['file_name'], {'header': 'None', 'nrows': 'n_regions'}), '(file_name, header=None, nrows=n_regions)\n', (265, 3... |
from django.urls import path
from . import views
from django.conf.urls import url
from .views import connect
app_name = 'blog'
urlpatterns = [
# post views
path('', views.homepage, name='homepage'),
path('connect', connect.as_view(), name='connect'),
path('disconnect', views.disconnect, name='disconnect'),
url(r'^disc... | [
"django.urls.path",
"django.conf.urls.url"
] | [((157, 198), 'django.urls.path', 'path', (['""""""', 'views.homepage'], {'name': '"""homepage"""'}), "('', views.homepage, name='homepage')\n", (161, 198), False, 'from django.urls import path\n'), ((252, 307), 'django.urls.path', 'path', (['"""disconnect"""', 'views.disconnect'], {'name': '"""disconnect"""'}), "('dis... |
"""
Ensures that the protocol manager can encode and decode messages circularly, so
that a message which is encoded and decoded is equal to the original message.
"""
import io
import unittest
from lns import control_proto, net_proto
class NetworkProtocol(unittest.TestCase):
def roundtrip(self, message):
o... | [
"lns.control_proto.get_length_encoded_json",
"lns.net_proto.Announce",
"lns.control_proto.GetAll",
"lns.control_proto.IP",
"lns.control_proto.NameIPMapping",
"io.BytesIO",
"lns.control_proto.Host",
"unittest.main",
"lns.control_proto.get_message_class",
"lns.net_proto.Announce.unserialize"
] | [((3019, 3034), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3032, 3034), False, 'import unittest\n'), ((374, 412), 'lns.net_proto.Announce.unserialize', 'net_proto.Announce.unserialize', (['output'], {}), '(output)\n', (404, 412), False, 'from lns import control_proto, net_proto\n'), ((1587, 1605), 'io.BytesIO... |
#!/usr/bin/env python3
import flask
import os
from PIL import Image, ImageFilter
import hashlib
import FileMimetypes as mime
app = flask.Flask(__name__)
app.jinja_env.trim_blocks = True
RELEASE_VERSION = '1.0.0'
app.config['APPLICATION_NAME'] = 'AutoGalleryIndex'
app.config['ROW_ITEMS_SHORT'] = 3
app.config['ROW_I... | [
"flask.render_template",
"os.path.exists",
"os.listdir",
"PIL.Image.open",
"os.path.isabs",
"os.makedirs",
"flask.Flask",
"flask.abort",
"os.getuid",
"os.access",
"os.path.join",
"FileMimetypes.get_type",
"os.path.split",
"os.path.isfile",
"os.path.dirname",
"os.path.getmtime"
] | [((134, 155), 'flask.Flask', 'flask.Flask', (['__name__'], {}), '(__name__)\n', (145, 155), False, 'import flask\n'), ((679, 748), 'os.path.join', 'os.path.join', (["app.config['CACHE_ABS']", "app.config['APPLICATION_NAME']"], {}), "(app.config['CACHE_ABS'], app.config['APPLICATION_NAME'])\n", (691, 748), False, 'impor... |
#Written for Python 3.4.2
import functools
import itertools
from math import sqrt
puzzle_input = 33100000
def integer_factorization(n):
return set(functools.reduce(list.__iadd__, ([i, n//i] for i in range(1, int(sqrt(n))+1) if n % i == 0)))
part1 = False
part2 = False
for house in itertools.count(start=1):
e... | [
"itertools.count",
"math.sqrt"
] | [((289, 313), 'itertools.count', 'itertools.count', ([], {'start': '(1)'}), '(start=1)\n', (304, 313), False, 'import itertools\n'), ((218, 225), 'math.sqrt', 'sqrt', (['n'], {}), '(n)\n', (222, 225), False, 'from math import sqrt\n')] |
# coding=utf-8
from twtrexcs.helpers import get_excuse, get_hashtag
def test_get_hashtag():
assert isinstance(get_hashtag(), str)
def test_get_excuse():
assert isinstance(get_excuse(), str)
def test_length_twitt():
resp = get_excuse()
assert len(resp) <= 280
| [
"twtrexcs.helpers.get_excuse",
"twtrexcs.helpers.get_hashtag"
] | [((242, 254), 'twtrexcs.helpers.get_excuse', 'get_excuse', ([], {}), '()\n', (252, 254), False, 'from twtrexcs.helpers import get_excuse, get_hashtag\n'), ((118, 131), 'twtrexcs.helpers.get_hashtag', 'get_hashtag', ([], {}), '()\n', (129, 131), False, 'from twtrexcs.helpers import get_excuse, get_hashtag\n'), ((185, 19... |
import logging
import logging as logger
from datetime import datetime
from functools import wraps
import krakenex
import pandas
from pandas import DataFrame
from pykrakenapi import KrakenAPI
from krakee import OrderBuilder
from krakee.api import PrettyNames
from krakee.api import utils
from krakee.types.AssetDataFram... | [
"logging.basicConfig",
"krakee.api.utils.as_list",
"krakee.api.utils.merge_ohlc",
"krakee.api.utils.dataframe_to_numeric",
"krakee.api.utils.assert_interval",
"krakee.types.TickerDataFrame.TickerDataFrame",
"krakenex.API",
"logging.info",
"functools.wraps",
"krakee.api.PrettyNames.get_pretty_name"... | [((717, 728), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (722, 728), False, 'from functools import wraps\n'), ((2302, 2341), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (2321, 2341), False, 'import logging\n'), ((2368, 2382), 'datetime.datetime.n... |
from transaction import extractData
from dotenv import load_dotenv
from datetime import datetime
from zipfile import ZipFile
from difflib import Differ
import urllib.request
import pandas as pd
import sqlalchemy
import shutil
import redis
import sys
import os
import io
def connectDb():
load_dotenv()
try:
... | [
"sqlalchemy.text",
"os.getenv",
"os.makedirs",
"pandas.DataFrame",
"os.rename",
"sqlalchemy.create_engine",
"dotenv.load_dotenv",
"os.getcwd",
"sys.exc_info",
"datetime.datetime.today",
"os.removedirs",
"difflib.Differ",
"transaction.extractData",
"os.remove"
] | [((293, 306), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (304, 306), False, 'from dotenv import load_dotenv\n'), ((588, 612), 'os.makedirs', 'os.makedirs', (['f"""./{year}"""'], {}), "(f'./{year}')\n", (599, 612), False, 'import os\n'), ((1089, 1102), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (... |
import numpy as np
import random
import copy
from collections import namedtuple, deque
from models import Actor, Critic
from noise import NoiseReducer
import torch
import torch.nn.functional as F
import torch.optim as optim
BUFFER_SIZE = int(1e5) # replay buffer size
WEIGHT_DECAY = 0 # L2 weight decay
device... | [
"numpy.clip",
"models.Critic",
"random.sample",
"torch.nn.functional.mse_loss",
"noise.NoiseReducer",
"collections.deque",
"collections.namedtuple",
"random.seed",
"torch.from_numpy",
"torch.cuda.is_available",
"models.Actor",
"numpy.vstack",
"torch.no_grad"
] | [((348, 373), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (371, 373), False, 'import torch\n'), ((959, 976), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (970, 976), False, 'import random\n'), ((2583, 2641), 'noise.NoiseReducer', 'NoiseReducer', (['factor_reduction', 'min_factor... |
"""Define docutils elements.
This module intentionally does not import anything from sphinx.
References:
- https://docutils.sourceforge.io/docs/howto/rst-directives.html
"""
import re
from string import Formatter
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
from docutils import nodes
from docut... | [
"docutils.nodes.superscript",
"docutils.nodes.inline",
"docutils.nodes.emphasis",
"docutils.nodes.strong",
"docutils.nodes.subscript",
"docutils.utils.unescape",
"docutils.nodes.Text",
"docutils.nodes.Element"
] | [((5292, 5306), 'docutils.utils.unescape', 'unescape', (['text'], {}), '(text)\n', (5300, 5306), False, 'from docutils.utils import unescape\n'), ((3562, 3577), 'docutils.nodes.Element', 'nodes.Element', ([], {}), '()\n', (3575, 3577), False, 'from docutils import nodes\n'), ((9665, 9679), 'docutils.nodes.strong', 'nod... |
import unittest
from metapack import MetapackDoc
from metapack_db import Database, MetatabManager
from metapack_db.document import Document
from metapack_db.term import Term
from os import remove
from os.path import exists
from sqlalchemy.exc import IntegrityError
def test_data(*paths):
from os.path import dirn... | [
"os.path.exists",
"metapack_db.MetatabManager",
"metapack.MetapackDoc",
"unittest.main",
"os.path.abspath",
"metapack_db.Database",
"os.remove"
] | [((5481, 5496), 'unittest.main', 'unittest.main', ([], {}), '()\n', (5494, 5496), False, 'import unittest\n'), ((676, 702), 'os.path.exists', 'exists', (['test_database_path'], {}), '(test_database_path)\n', (682, 702), False, 'from os.path import exists\n'), ((757, 800), 'metapack_db.Database', 'Database', (["('sqlite... |
#!/usr/bin/env python
'''
Filename : VCFscreen_subset.py
Author : <NAME>
Email : <EMAIL>
Date created : 12/17/2019
Date last modified : 12/17/2019
Python version : 2.7
'''
import sys
import os
import argparse
import cyvcf2
from collections import defaultdict
# if VCFscreen not in PYTHONPATH, make sure it is
#VCFSCR... | [
"vcfscreen.arguments.args_annots",
"vcfscreen.arguments.args_vars",
"argparse.ArgumentParser",
"cyvcf2.VCF",
"vcfscreen.cyvcf2_variant.Cyvcf2Vcf",
"os.path.isfile",
"cyvcf2.Writer",
"vcfscreen.cyvcf2_variant.Cyvcf2Variant",
"collections.defaultdict",
"vcfscreen.vcf_cnds.VcfCnds",
"vcfscreen.misc... | [((1066, 1109), 'vcfscreen.misc.str_none_split', 'misc.str_none_split', (['args.qual_impacts', '""","""'], {}), "(args.qual_impacts, ',')\n", (1085, 1109), True, 'import vcfscreen.misc as misc\n'), ((1137, 1183), 'vcfscreen.misc.str_none_split', 'misc.str_none_split', (['args.max_impact_csqs', '""","""'], {}), "(args.m... |
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
x = pd.period_range(pd.datetime.now(), periods=200, freq='d')
x = x.to_timestamp().to_pydatetime()
# 產生三組，每組 200 個隨機常態分布元素
y = np.random.randn(200, 3).cumsum(0)
plt.plot(x, y)
plt.show()
# Matplotlib 使用點 point 而非 pixel 為圖... | [
"matplotlib.pyplot.boxplot",
"matplotlib.pyplot.hist",
"matplotlib.pyplot.ylabel",
"numpy.polyfit",
"matplotlib.pyplot.figtext",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.random.normal",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.gcf",
"matplotlib.pyplot.title",
"numpy.... | [((259, 273), 'matplotlib.pyplot.plot', 'plt.plot', (['x', 'y'], {}), '(x, y)\n', (267, 273), True, 'import matplotlib.pyplot as plt\n'), ((274, 284), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (282, 284), True, 'import matplotlib.pyplot as plt\n'), ((574, 588), 'matplotlib.pyplot.plot', 'plt.plot', (['x',... |
import pytest
from packratAgent.Container import Container
def test_load():
Container( 'test_resources/docker-test_0.0.tar' )
with pytest.raises( ValueError ):
Container( 'test_resources/notexist' )
with pytest.raises( ValueError ):
Container( 'test_resources' )
def test_layers():
c = Container( ... | [
"pytest.raises",
"packratAgent.Container.Container"
] | [((81, 128), 'packratAgent.Container.Container', 'Container', (['"""test_resources/docker-test_0.0.tar"""'], {}), "('test_resources/docker-test_0.0.tar')\n", (90, 128), False, 'from packratAgent.Container import Container\n'), ((309, 356), 'packratAgent.Container.Container', 'Container', (['"""test_resources/docker-tes... |
"""Helper Functions"""
import json
import bs4
import certifi
import urllib3
from .errors import PortalXKeyError
# TODO: Patch disable_warnings, see: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#ssl-warnings
# HTTP = urllib3.disable_warnings().PoolManager()
HTTP = urllib3.PoolManager(
cert_reqs="CERT... | [
"certifi.where",
"json.dumps"
] | [((345, 360), 'certifi.where', 'certifi.where', ([], {}), '()\n', (358, 360), False, 'import certifi\n'), ((1867, 1902), 'json.dumps', 'json.dumps', (["{'PageIndex': page_num}"], {}), "({'PageIndex': page_num})\n", (1877, 1902), False, 'import json\n'), ((2543, 2597), 'json.dumps', 'json.dumps', (["{'ParentPostID': pos... |
"""JSON utility functions."""
from collections import deque
import json
import logging
import os
import tempfile
from typing import Any, Dict, List, Optional, Type, Union
from openpeerpower.exceptions import OpenPeerPowerError
_LOGGER = logging.getLogger(__name__)
class SerializationError(OpenPeerPowerError):
"... | [
"logging.getLogger",
"os.path.exists",
"collections.deque",
"openpeerpower.exceptions.OpenPeerPowerError",
"json.dumps",
"os.replace",
"os.path.split",
"os.chmod",
"tempfile.NamedTemporaryFile",
"os.remove"
] | [((239, 266), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (256, 266), False, 'import logging\n'), ((2965, 2989), 'collections.deque', 'deque', (["[(bad_data, '$')]"], {}), "([(bad_data, '$')])\n", (2970, 2989), False, 'from collections import deque\n'), ((1506, 1561), 'json.dumps', 'js... |
from gpiozero import Button
import subprocess
# GPIO pin number
PIN = 3
# Time threshold for shutdown in seconds
THRES = 3
button = Button(PIN)
def button_listener(button):
button.wait_for_press()
while button.is_pressed:
if button.active_time > THRES:
print('SHUTDOWN')
subprocess.call(['sudo', 'shutdown... | [
"subprocess.call",
"gpiozero.Button"
] | [((134, 145), 'gpiozero.Button', 'Button', (['PIN'], {}), '(PIN)\n', (140, 145), False, 'from gpiozero import Button\n'), ((380, 443), 'subprocess.call', 'subprocess.call', (["['sudo', 'shutdown', '-r', 'now']"], {'shell': '(False)'}), "(['sudo', 'shutdown', '-r', 'now'], shell=False)\n", (395, 443), False, 'import sub... |
import html
from config import cmds
from pyrogram import Client, Filters
@Client.on_message(Filters.command("help", prefixes=".") & Filters.me)
async def chelp(client, message):
if message.text[6:]:
a = message.text[6:]
if a in cmds:
await message.edit(f'<code>{html.escape(a)}</code>: ... | [
"config.cmds.update",
"html.escape",
"pyrogram.Filters.command"
] | [((581, 628), 'config.cmds.update', 'cmds.update', (["{'.help': 'List all the commands'}"], {}), "({'.help': 'List all the commands'})\n", (592, 628), False, 'from config import cmds\n'), ((94, 131), 'pyrogram.Filters.command', 'Filters.command', (['"""help"""'], {'prefixes': '"""."""'}), "('help', prefixes='.')\n", (1... |
import argparse
from . import config
config.setup_logging()
import logging
log = logging.getLogger(__name__)
def emit(args):
from . import emit
emit.run()
def main():
log.info('Starting mactrack')
config.setup_database()
parser = argparse.ArgumentParser()
args = parser.parse_args()
emi... | [
"logging.getLogger",
"argparse.ArgumentParser"
] | [((83, 110), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (100, 110), False, 'import logging\n'), ((256, 281), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (279, 281), False, 'import argparse\n')] |
"""Calculate graph edge bearings."""
import math
import numpy as np
def get_bearing(origin_point, destination_point):
"""
Calculate the bearing between two lat-lng points.
Each argument tuple should represent (lat, lng) as decimal degrees.
Bearing represents angle in degrees (clockwise) between nor... | [
"math.degrees",
"math.radians",
"math.cos",
"math.atan2",
"math.sin"
] | [((923, 952), 'math.radians', 'math.radians', (['origin_point[0]'], {}), '(origin_point[0])\n', (935, 952), False, 'import math\n'), ((964, 998), 'math.radians', 'math.radians', (['destination_point[0]'], {}), '(destination_point[0])\n', (976, 998), False, 'import math\n'), ((1014, 1066), 'math.radians', 'math.radians'... |
from transformers import (AutoModelForTokenClassification,
AutoModelForSequenceClassification,
TrainingArguments,
AutoTokenizer,
AutoConfig,
Trainer)
from biobert_ner.utils_ner import (con... | [
"logging.getLogger",
"biobert_ner.utils_ner.NerTestDataset",
"utils.display_knowledge_graph",
"transformers.TrainingArguments",
"torch.nn.CrossEntropyLoss",
"os.path.join",
"numpy.argmax",
"utils.get_long_relation_table",
"ehr.HealthRecord",
"annotations.Entity",
"utils.get_relation_table",
"b... | [((831, 858), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (848, 858), False, 'import logging\n'), ((1201, 1245), 'logging.getLogger', 'logging.getLogger', (['"""matplotlib.font_manager"""'], {}), "('matplotlib.font_manager')\n", (1218, 1245), False, 'import logging\n'), ((1470, 1514), ... |
import os
os.environ['basedir_a'] = '/gpfs/home/cj3272/tmp/'
os.environ["CUDA_VISIBLE_DEVICES"] = '0'
import keras
import PIL
import numpy as np
import scipy
# set tf backend to allow memory to grow, instead of claiming everything
import tensorflow as tf
def get_session():
config = tf.ConfigProto()
config.... | [
"PIL.Image.fromarray",
"keras.models.load_model",
"pathlib.Path",
"tensorflow.Session",
"luccauchon.data.Generators.AmateurDataFrameDataGenerator",
"luccauchon.data.C.generate_X_y_raw_from_amateur_dataset",
"luccauchon.data.Generators.amateur_test",
"numpy.expand_dims",
"tensorflow.ConfigProto"
] | [((292, 308), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {}), '()\n', (306, 308), True, 'import tensorflow as tf\n'), ((363, 388), 'tensorflow.Session', 'tf.Session', ([], {'config': 'config'}), '(config=config)\n', (373, 388), True, 'import tensorflow as tf\n'), ((1249, 1420), 'luccauchon.data.C.generate_X_y_raw... |
import argparse
import csv
import json
import pickle
import yaml
from sklearn import metrics, svm
from sklearn.model_selection import train_test_split
def load_params(param_path="params.yaml"):
with open("params.yaml", "r") as config_file:
return yaml.safe_load(config_file)
def load_data(X_path, y_pat... | [
"sklearn.metrics.f1_score",
"pickle.dump",
"argparse.ArgumentParser",
"sklearn.model_selection.train_test_split",
"csv.writer",
"pickle.load",
"sklearn.metrics.precision_score",
"sklearn.metrics.recall_score",
"yaml.safe_load",
"csv.reader",
"sklearn.metrics.accuracy_score",
"json.dump",
"sk... | [((709, 794), 'sklearn.model_selection.train_test_split', 'train_test_split', (['X', 'y'], {'test_size': "params['test_size']", 'shuffle': "params['shuffle']"}), "(X, y, test_size=params['test_size'], shuffle=params['shuffle']\n )\n", (725, 794), False, 'from sklearn.model_selection import train_test_split\n'), ((12... |
from django.forms import widgets
from django.core.validators import RegexValidator
from django.utils.translation import ugettext_lazy as _
from rest_framework import serializers
from orchestra.api.serializers import SetPasswordHyperlinkedSerializer
from orchestra.contrib.accounts.serializers import AccountSerializerMi... | [
"django.utils.translation.ugettext_lazy",
"rest_framework.serializers.DictField"
] | [((481, 518), 'rest_framework.serializers.DictField', 'serializers.DictField', ([], {'required': '(False)'}), '(required=False)\n', (502, 518), False, 'from rest_framework import serializers\n'), ((771, 880), 'django.utils.translation.ugettext_lazy', '_', (['"""Enter a valid password. This value may contain any ascii c... |
"""
This is an example to train a task with DDPG algorithm.
Here it creates a gym environment InvertedDoublePendulum. And uses a DDPG with
1M steps.
Results:
AverageReturn: 250
RiseTime: epoch 499
"""
import gym
import tensorflow as tf
from garage.misc.instrument import run_experiment
from garage.replay_buff... | [
"garage.tf.exploration_strategies.OUStrategy",
"garage.misc.instrument.run_experiment",
"garage.tf.q_functions.ContinuousMLPQFunction",
"garage.tf.policies.ContinuousMLPPolicy",
"gym.make"
] | [((1744, 1829), 'garage.misc.instrument.run_experiment', 'run_experiment', (['run_task'], {'n_parallel': '(1)', 'snapshot_mode': '"""last"""', 'seed': '(1)', 'plot': '(False)'}), "(run_task, n_parallel=1, snapshot_mode='last', seed=1, plot=False\n )\n", (1758, 1829), False, 'from garage.misc.instrument import run_ex... |
import logging
import tensorflow as tf
from . import utils
from .dataset import TFDataset
class TFDatasetForQuestionAnswering(TFDataset):
"""Dataset for question answering in TensorFlow."""
def __init__(
self,
examples=None,
input_ids="input_ids",
token_type_ids="token_type_... | [
"tensorflow.ragged.constant",
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.sparse.to_dense",
"tensorflow.size",
"tensorflow.io.parse_example",
"tensorflow.io.VarLenFeature"
] | [((1295, 1329), 'tensorflow.ragged.constant', 'tf.ragged.constant', (['x'], {'dtype': 'dtype'}), '(x, dtype=dtype)\n', (1313, 1329), True, 'import tensorflow as tf\n'), ((1346, 1383), 'tensorflow.data.Dataset.from_tensor_slices', 'tf.data.Dataset.from_tensor_slices', (['x'], {}), '(x)\n', (1380, 1383), True, 'import te... |
from model.seq2seq import Seq2Seq
from model.decoding_techniques import BeamSearchDecoder, GreedyDecoder, NucleusDecoder
from utils.model_utils import predict_beam, predict_greedy, predict_nucleus, process_sentence
import telebot
from telebot import types
import logging
logger = telebot.logger
telebot.logger.setLevel(... | [
"model.decoding_techniques.GreedyDecoder",
"model.decoding_techniques.NucleusDecoder",
"telebot.types.InlineKeyboardButton",
"telebot.logger.setLevel",
"telebot.types.InlineKeyboardMarkup",
"utils.model_utils.process_sentence",
"model.decoding_techniques.BeamSearchDecoder",
"telebot.TeleBot"
] | [((296, 334), 'telebot.logger.setLevel', 'telebot.logger.setLevel', (['logging.DEBUG'], {}), '(logging.DEBUG)\n', (319, 334), False, 'import telebot\n'), ((366, 431), 'telebot.TeleBot', 'telebot.TeleBot', (['"""1716865383:AAGR9GxP_cOefogxRgqN-b1NbXAQcgt-GDE"""'], {}), "('1716865383:AAGR9GxP_cOefogxRgqN-b1NbXAQcgt-GDE')... |
import os
import shutil
import numpy as np
import mxnet as mx
from mxnet import gluon
from mxnet.gluon import nn
from mxnet import autograd as ag
def train_one_epoch(epoch, optimizer, train_data, criterion, ctx):
train_data.reset()
acc_metric = mx.metric.Accuracy()
loss_sum = 0.0
count = 0
... | [
"mxnet.gluon.loss.SoftmaxCrossEntropyLoss",
"os.path.exists",
"mxnet.autograd.record",
"mxnet.metric.Accuracy",
"mxnet.gluon.utils.split_and_load",
"mxnet.gluon.nn.Dense",
"mxnet.gluon.nn.Conv2D",
"mxnet.cpu",
"os.path.join",
"mxnet.gluon.nn.Flatten",
"mxnet.init.Xavier",
"mxnet.gluon.nn.Leaky... | [((264, 284), 'mxnet.metric.Accuracy', 'mx.metric.Accuracy', ([], {}), '()\n', (282, 284), True, 'import mxnet as mx\n'), ((1361, 1381), 'mxnet.metric.Accuracy', 'mx.metric.Accuracy', ([], {}), '()\n', (1379, 1381), True, 'import mxnet as mx\n'), ((3737, 3752), 'mxnet.gluon.nn.Sequential', 'nn.Sequential', ([], {}), '(... |
from __future__ import print_function
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# create an instance of the API class
api_instance = swagger_client.DefaultApi()
text = 'This is a sample sentence' # String | The input natural language text.
'''
prefix = pr... | [
"swagger_client.DefaultApi"
] | [((197, 224), 'swagger_client.DefaultApi', 'swagger_client.DefaultApi', ([], {}), '()\n', (222, 224), False, 'import swagger_client\n')] |
"""Models of the ``django_libs`` projects."""
from django.core.validators import RegexValidator
from django.db.models import CharField
try:
from south.modelsinspector import add_introspection_rules
except ImportError:
pass
else:
add_introspection_rules([], [r"^django_libs\.models\.ColorField"])
from .widg... | [
"django.core.validators.RegexValidator",
"south.modelsinspector.add_introspection_rules"
] | [((242, 309), 'south.modelsinspector.add_introspection_rules', 'add_introspection_rules', (['[]', "['^django_libs\\\\.models\\\\.ColorField']"], {}), "([], ['^django_libs\\\\.models\\\\.ColorField'])\n", (265, 309), False, 'from south.modelsinspector import add_introspection_rules\n'), ((599, 737), 'django.core.validat... |
# -*- coding: utf-8 -*-
import networkx as nx
__author__ = '\n'.join(['<NAME> <<EMAIL>>'])
__all__ = [ 'dominating_set', 'is_dominating_set']
def dominating_set(G, start_with=None):
r"""Finds a dominating set for the graph G.
A dominating set for a graph `G = (V, E)` is a node subset `D` of `V`
such that ... | [
"networkx.NetworkXError"
] | [((1203, 1252), 'networkx.NetworkXError', 'nx.NetworkXError', (["('node %s not in G' % start_with)"], {}), "('node %s not in G' % start_with)\n", (1219, 1252), True, 'import networkx as nx\n')] |
from enum import IntEnum
from eth_typing.evm import HexAddress
from eth_utils.units import units
from raiden_contracts.utils.signature import private_key_to_address
MAX_UINT256 = 2 ** 256 - 1
MAX_UINT192 = 2 ** 192 - 1
MAX_UINT32 = 2 ** 32 - 1
FAKE_ADDRESS = "0x03432"
EMPTY_ADDRESS = HexAddress("0x000000000000000000... | [
"raiden_contracts.utils.signature.private_key_to_address",
"eth_typing.evm.HexAddress"
] | [((288, 344), 'eth_typing.evm.HexAddress', 'HexAddress', (['"""0x0000000000000000000000000000000000000000"""'], {}), "('0x0000000000000000000000000000000000000000')\n", (298, 344), False, 'from eth_typing.evm import HexAddress\n'), ((602, 644), 'raiden_contracts.utils.signature.private_key_to_address', 'private_key_to_... |
"""
Testing tool messages specific of the LoRaWAN testing.
"""
#################################################################################
# MIT License
#
# Copyright (c) 2018, <NAME>, Universitat Oberta de Catalunya (UOC),
# Universidad de la Republica Oriental del Uruguay (UdelaR).
#
# Permission is hereby gran... | [
"logging.getLogger",
"base64.b64encode",
"json.dumps",
"base64.b64decode",
"utils.bytes_to_text",
"conformance_testing.test_errors.TestingToolError",
"utils.encrypt_ieee802154",
"copy.copy"
] | [((1699, 1726), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1716, 1726), False, 'import logging\n'), ((8001, 8029), 'copy.copy', 'copy.copy', (['self.empty_gw_msg'], {}), '(self.empty_gw_msg)\n', (8010, 8029), False, 'import copy\n'), ((8918, 8969), 'json.dumps', 'json.dumps', (['resp... |
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: apponly.proto
"""Generated protocol buffer code."""
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobu... | [
"google.protobuf.reflection.GeneratedProtocolMessageType",
"google.protobuf.symbol_database.Default",
"google.protobuf.descriptor.FieldDescriptor",
"google.protobuf.descriptor.FileDescriptor"
] | [((412, 438), 'google.protobuf.symbol_database.Default', '_symbol_database.Default', ([], {}), '()\n', (436, 438), True, 'from google.protobuf import symbol_database as _symbol_database\n'), ((498, 943), 'google.protobuf.descriptor.FileDescriptor', '_descriptor.FileDescriptor', ([], {'name': '"""apponly.proto"""', 'pac... |
from lightgbm import LGBMClassifier
from sklearn.model_selection import RandomizedSearchCV, PredefinedSplit
from sklearn import metrics
import pandas as pd
from data import get_data
import numpy as np
import pickle
import hydra
@hydra.main(config_path="config", config_name="config")
def random_forest(cfg):
# Load... | [
"sklearn.metrics.f1_score",
"sklearn.model_selection.PredefinedSplit",
"pickle.dump",
"hydra.main",
"data.get_data",
"lightgbm.LGBMClassifier",
"sklearn.metrics.roc_auc_score",
"pandas.concat",
"numpy.arange",
"sklearn.model_selection.RandomizedSearchCV"
] | [((231, 285), 'hydra.main', 'hydra.main', ([], {'config_path': '"""config"""', 'config_name': '"""config"""'}), "(config_path='config', config_name='config')\n", (241, 285), False, 'import hydra\n'), ((360, 373), 'data.get_data', 'get_data', (['cfg'], {}), '(cfg)\n', (368, 373), False, 'from data import get_data\n'), (... |
#!/usr/bin/env python
# coding: utf8
#
# Copyright (c) 2020 Centre National d'Etudes Spatiales (CNES).
#
# This file is part of PANDORA
#
# https://github.com/CNES/Pandora_pandora
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
#... | [
"codecs.open",
"setuptools.find_packages"
] | [((1595, 1626), 'codecs.open', 'open', (['"""README.md"""', '"""r"""', '"""utf-8"""'], {}), "('README.md', 'r', 'utf-8')\n", (1599, 1626), False, 'from codecs import open\n'), ((2196, 2211), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (2209, 2211), False, 'from setuptools import setup, find_packages\... |
# Copyright 2013-2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance
# with the License. A copy of the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "LICENSE.txt" file ... | [
"pcluster.commands._setup_bucket_with_resources",
"assertpy.assert_that",
"pcluster.commands._validate_cluster_name",
"pkg_resources.resource_filename",
"pytest.mark.parametrize",
"pytest.raises",
"pcluster.cli_commands.update._check_cluster_models",
"botocore.exceptions.ClientError"
] | [((1530, 2100), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["('scheduler', 'expected_dirs', 'expect_upload_hit_resources',\n 'mock_generated_bucket_name', 'expected_bucket_name',\n 'provided_bucket_name', 'expected_remove_bucket')", "[('slurm', ['resources/custom_resources'], True, 'bucket', 'bucket',... |
import pprint
import re
from typing import Any, Dict
import numpy as np
import pytest
from qcelemental.molutil import compute_scramble
from qcengine.programs.tests.standard_suite_contracts import (
contractual_accsd_prt_pr,
contractual_ccd,
contractual_ccsd,
contractual_ccsd_prt_pr,
contractual_ccs... | [
"qcengine.programs.util.mill_qcvars",
"qcdb.Molecule.from_schema",
"numpy.printoptions",
"pytest.raises",
"pprint.PrettyPrinter",
"qcengine.programs.tests.standard_suite_contracts.query_qcvar",
"qcengine.programs.tests.standard_suite_contracts.query_has_qcvar",
"pytest.skip",
"pytest.xfail",
"qcdb... | [((1056, 1087), 'pprint.PrettyPrinter', 'pprint.PrettyPrinter', ([], {'width': '(120)'}), '(width=120)\n', (1076, 1087), False, 'import pprint\n'), ((6921, 6980), 'qcdb.set_options', 'qcdb.set_options', (["{'e_convergence': 10, 'd_convergence': 9}"], {}), "({'e_convergence': 10, 'd_convergence': 9})\n", (6937, 6980), F... |
import argparse
import glob
import os
import pickle
import random
from tqdm import tqdm
def pickle_examples(image_paths, train_path, val_path, train_val_split):
"""
Compile a list of examples into pickled format, so during
the training, all io will happen in memory
"""
with open(train_path, 'wb')... | [
"pickle.dump",
"os.makedirs",
"argparse.ArgumentParser",
"tqdm.tqdm",
"os.path.join",
"os.path.basename",
"random.random"
] | [((914, 1015), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Compile list of images into a pickled object for training"""'}), "(description=\n 'Compile list of images into a pickled object for training')\n", (937, 1015), False, 'import argparse\n'), ((1483, 1524), 'os.makedirs', 'os.... |
#
# SPDX-License-Identifier: MIT
#
# Copyright (C) 2019-2021, AllWorldIT.
#
# 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
# u... | [
"re.match",
"logging.debug",
"pkgutil.iter_modules"
] | [((8554, 8629), 'logging.debug', 'logging.debug', (['"""EZPLUGINS => Finding plugins in package \'%s\'"""', 'package_name'], {}), '("EZPLUGINS => Finding plugins in package \'%s\'", package_name)\n', (8567, 8629), False, 'import logging\n'), ((9349, 9413), 'pkgutil.iter_modules', 'pkgutil.iter_modules', (['base_package... |
"""
Short Plotting Routine to Plot Pandas Dataframes by Column Label
1. Takes list of dateframes to compare multiple trials
2. Takes list of y-variables to combine on 1 plot
3. Legend location and y-axis limits can be customized
Written by <NAME> (pat-coady.github.io)
"""
import matplotlib.pyplot as plt
def df_plot... | [
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((1278, 1304), 'matplotlib.pyplot.legend', 'plt.legend', ([], {'loc': 'legend_loc'}), '(loc=legend_loc)\n', (1288, 1304), True, 'import matplotlib.pyplot as plt\n'), ((1309, 1319), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (1317, 1319), True, 'import matplotlib.pyplot as plt\n'), ((960, 974), 'matplotlib... |
from setuptools import setup
import aiodata
setup(
name='aiodata',
version=aiodata.__version__,
description='',
author='Jan',
url='',
packages=['aiodata'],
include_package_data=True,
python_requires=">=3.6.0",
install_requires=[
'aiohttp',
'aiofiles',
... | [
"setuptools.setup"
] | [((48, 604), 'setuptools.setup', 'setup', ([], {'name': '"""aiodata"""', 'version': 'aiodata.__version__', 'description': '""""""', 'author': '"""Jan"""', 'url': '""""""', 'packages': "['aiodata']", 'include_package_data': '(True)', 'python_requires': '""">=3.6.0"""', 'install_requires': "['aiohttp', 'aiofiles', 'xmlto... |
from __future__ import absolute_import, division, print_function
__metaclass__ = type
import sys
import pytest
from ansible_collections.sensu.sensu_go.plugins.module_utils import (
errors, utils,
)
from ansible_collections.sensu.sensu_go.plugins.modules import pipe_handler
from .common.utils import (
Ansibl... | [
"ansible_collections.sensu.sensu_go.plugins.modules.pipe_handler.main",
"ansible_collections.sensu.sensu_go.plugins.modules.pipe_handler.do_differ",
"pytest.raises",
"pytest.mark.skipif",
"ansible_collections.sensu.sensu_go.plugins.module_utils.errors.Error"
] | [((397, 486), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(sys.version_info < (2, 7))'], {'reason': '"""requires python2.7 or higher"""'}), "(sys.version_info < (2, 7), reason=\n 'requires python2.7 or higher')\n", (415, 486), False, 'import pytest\n'), ((4161, 4186), 'ansible_collections.sensu.sensu_go.plugins.m... |
#!/usr/bin/env python
import urlparse # Allows you to verify the validity of a URL
import requests # Require the requests API
import argparse # Required to parse the first arguement
argparser = argparse.ArgumentParser(description='Given a URL, determine if that URL is returning a static code 200')
argparser.add_argume... | [
"urlparse.urlunparse",
"argparse.ArgumentParser",
"urlparse.urlparse"
] | [((195, 304), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Given a URL, determine if that URL is returning a static code 200"""'}), "(description=\n 'Given a URL, determine if that URL is returning a static code 200')\n", (218, 304), False, 'import argparse\n'), ((538, 576), 'urlpar... |
import datetime
import timeit
import redgrease
# Bind / register the function on some Redis instance.
r = redgrease.RedisGears()
# CommandReader Decorator
# The `command` decorator tunrs the function to a CommandReader,
# registerered on the Redis Gears sever if using the `on` argument
@redgrease.command(on=r, requ... | [
"redgrease.RedisGears",
"redgrease.cmd.get",
"requests.get",
"redgrease.cmd.set",
"redgrease.cmd.exists",
"timeit.timeit",
"redgrease.command"
] | [((108, 130), 'redgrease.RedisGears', 'redgrease.RedisGears', ([], {}), '()\n', (128, 130), False, 'import redgrease\n'), ((292, 357), 'redgrease.command', 'redgrease.command', ([], {'on': 'r', 'requirements': "['requests']", 'replace': '(False)'}), "(on=r, requirements=['requests'], replace=False)\n", (309, 357), Fals... |
# Generated by Django 4.0.2 on 2022-03-12 01:42
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('kennels', '0007_alter_co... | [
"django.db.models.UniqueConstraint",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.BigAutoField",
"django.db.migrations.swappable_dependency"
] | [((227, 284), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (258, 284), False, 'from django.db import migrations, models\n'), ((523, 594), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'through': ... |
import requests
import json
import os
import six
from units import fmtscaled
import cache
import copy
PHEDEX_API_URL = 'https://cmsweb.cern.ch/phedex/datasvc/json'
PHEDEX_INSTANCE = 'prod'
PHEDEX_REQUEST_TEMPLATE = 'https://cmsweb.cern.ch/phedex/{instance}/Request::View?request={request_id}'
SITE = None
REQUEST_CACH... | [
"cache.PhedexCache.get",
"units.fmtscaled",
"requests.get",
"cache.SubscriptionCache.set",
"copy.deepcopy",
"pandas.DataFrame",
"six.iteritems",
"cache.SubscriptionCache.get"
] | [((324, 353), 'cache.SubscriptionCache.get', 'cache.SubscriptionCache.get', ([], {}), '()\n', (351, 353), False, 'import cache\n'), ((707, 755), 'requests.get', 'requests.get', (['query'], {'verify': '(False)', 'params': 'params'}), '(query, verify=False, params=params)\n', (719, 755), False, 'import requests\n'), ((10... |
from setuptools import setup
setup(
name='xkbparse',
version='0.1',
description='xkb configuration parser',
url='https://github.com/svenlr/xkbparse',
author='<NAME>',
author_email='<EMAIL>',
license='MIT',
packages=['xkbparse'],
zip_safe=False,
install_requires=['pypeg2']
)
| [
"setuptools.setup"
] | [((30, 287), 'setuptools.setup', 'setup', ([], {'name': '"""xkbparse"""', 'version': '"""0.1"""', 'description': '"""xkb configuration parser"""', 'url': '"""https://github.com/svenlr/xkbparse"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'packages': "['xkbparse']", 'zip_safe':... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Nov 6 09:44:54 2019
@author: thomas
"""
import numpy as np
import matplotlib.pyplot as plt
plt.close('all')
def graycode(M):
if (M==1):
g=['0','1']
elif (M>1):
gs=graycode(M-1)
gsr=gs[::-1]
gs0=['0'+x for x in... | [
"matplotlib.pyplot.text",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"numpy.max",
"matplotlib.pyplot.close",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.stem",
"matplotlib.pyplot.tight_layout",
"numpy.min",
"matplotlib.pyplot.ylim",
"numpy.log2",
... | [((160, 176), 'matplotlib.pyplot.close', 'plt.close', (['"""all"""'], {}), "('all')\n", (169, 176), True, 'import matplotlib.pyplot as plt\n'), ((527, 542), 'numpy.arange', 'np.arange', (['(0)', 'M'], {}), '(0, M)\n', (536, 542), True, 'import numpy as np\n'), ((691, 703), 'matplotlib.pyplot.figure', 'plt.figure', ([],... |
import base64
from typing import Optional
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from fidesops.core.config import config
from fidesops.util.cryptographic_util import bytes_to_b64_str
def encrypt_to_bytes_verify_secrets_length(
plain_value: Optional[str], key: bytes, nonce: bytes
) -> byt... | [
"cryptography.hazmat.primitives.ciphers.aead.AESGCM",
"fidesops.util.cryptographic_util.bytes_to_b64_str",
"base64.b64decode"
] | [((890, 901), 'cryptography.hazmat.primitives.ciphers.aead.AESGCM', 'AESGCM', (['key'], {}), '(key)\n', (896, 901), False, 'from cryptography.hazmat.primitives.ciphers.aead import AESGCM\n'), ((1385, 1412), 'fidesops.util.cryptographic_util.bytes_to_b64_str', 'bytes_to_b64_str', (['encrypted'], {}), '(encrypted)\n', (1... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.17 on 2021-03-02 13:17
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('bb_projects', '0017_auto_20210302_1417'),
('projects', '0095_auto_20210302_1417'),
... | [
"django.db.migrations.SeparateDatabaseAndState",
"django.db.migrations.DeleteModel"
] | [((504, 547), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '"""ProjectTheme"""'}), "(name='ProjectTheme')\n", (526, 547), False, 'from django.db import migrations\n'), ((580, 634), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '"""ProjectThemeTranslation"""'}... |
import torch
import torch.nn as nn
from torch import cuda
class GradReverse(torch.autograd.Function):
def __init__(self, lambd):
self.lambd = lambd
def forward(self, x):
return x.view_as(x)
def backward(self, grad_output):
return (grad_output * -self.lambd)
class Encoder(nn.... | [
"torch.nn.Dropout",
"torch.nn.Tanh",
"torch.nn.Linear"
] | [((462, 494), 'torch.nn.Linear', 'nn.Linear', (['emb_size', 'hidden_size'], {}), '(emb_size, hidden_size)\n', (471, 494), True, 'import torch.nn as nn\n'), ((518, 544), 'torch.nn.Dropout', 'nn.Dropout', ([], {'p': 'dropout_rate'}), '(p=dropout_rate)\n', (528, 544), True, 'import torch.nn as nn\n'), ((565, 574), 'torch.... |
import datetime
now = datetime.datetime.now()
print(f"The time right now is {now}") | [
"datetime.datetime.now"
] | [((23, 46), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (44, 46), False, 'import datetime\n')] |
import torch
import unittest
from qtorch.quant import *
from qtorch import FixedPoint, BlockFloatingPoint, FloatingPoint
DEBUG = False
log = lambda m: print(m) if DEBUG else False
class TestStochastic(unittest.TestCase):
"""
invariant: quantized numbers cannot be greater than the maximum representable number... | [
"unittest.main",
"torch.Tensor",
"torch.linspace",
"numpy.arange"
] | [((3957, 3972), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3970, 3972), False, 'import unittest\n'), ((697, 739), 'torch.linspace', 'torch.linspace', (['(-2)', '(2)'], {'steps': '(100)', 'device': 'd'}), '(-2, 2, steps=100, device=d)\n', (711, 739), False, 'import torch\n'), ((973, 1015), 'torch.linspace', 't... |
import random
from dateutil import parser
from django.utils import timezone
from django.core import signing
from .primes import PRIMES
SURVEY_TOKEN_SALT = 'salary:survey'
SURVEY_TOKEN_MAX_AGE = 60 * 60 * 24 * 7 # 7 days
def get_survey_unique_primes(*emails):
if len(emails) > len(PRIMES):
raise ValueE... | [
"dateutil.parser.parse",
"django.core.signing.loads",
"django.utils.timezone.now",
"django.utils.timezone.timedelta"
] | [((834, 908), 'django.core.signing.loads', 'signing.loads', (['token'], {'salt': 'SURVEY_TOKEN_SALT', 'max_age': 'SURVEY_TOKEN_MAX_AGE'}), '(token, salt=SURVEY_TOKEN_SALT, max_age=SURVEY_TOKEN_MAX_AGE)\n', (847, 908), False, 'from django.core import signing\n'), ((993, 1021), 'dateutil.parser.parse', 'parser.parse', ([... |
#!/usr/bin/env python3
#
# Advent of Code 2020 - day 17
#
from pathlib import Path
from collections import defaultdict
INPUTFILE = "input.txt"
SAMPLE_INPUT = """
.#.
..#
###
"""
NEIGHBORS = [
(0, 0, -1),
(0, 0, 1),
(0, -1, 0),
(0, -1, -1),
(0, -1, 1),
(0, 1, 0),
(0, 1, -1),
(0, 1, ... | [
"collections.defaultdict",
"pathlib.Path"
] | [((2913, 2929), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (2924, 2929), False, 'from collections import defaultdict\n'), ((4022, 4038), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (4033, 4038), False, 'from collections import defaultdict\n'), ((5277, 5293), 'collections... |
# -*- coding: utf-8 -*-
from simmate.workflow_engine import s3task_to_workflow
from simmate.calculators.vasp.tasks.static_energy import (
MITStaticEnergy as MITStaticEnergyTask,
)
from simmate.calculators.vasp.database.energy import (
MITStaticEnergy as MITStaticEnergyResults,
)
workflow = s3task_to_workflow(... | [
"simmate.workflow_engine.s3task_to_workflow"
] | [((301, 569), 'simmate.workflow_engine.s3task_to_workflow', 's3task_to_workflow', ([], {'name': '"""static-energy/mit"""', 'module': '__name__', 'project_name': '"""Simmate-Energy"""', 's3task': 'MITStaticEnergyTask', 'calculation_table': 'MITStaticEnergyResults', 'register_kwargs': "['structure', 'source']", 'descript... |
from django import template
register = template.Library()
@register.filter()
def get(h, key):
return h[key]
| [
"django.template.Library"
] | [((40, 58), 'django.template.Library', 'template.Library', ([], {}), '()\n', (56, 58), False, 'from django import template\n')] |
import numpy as np
import random
import copy
class Environment():
def __init__(self, agents, n_players=4, tiles_per_player=7):
self.tiles_per_player = tiles_per_player
self.hand_sizes = []
self.n_players = n_players
self.agents = agents
self.pile = generate_tiles()
for agent in agents:
for i in range... | [
"random.shuffle",
"numpy.random.random",
"numpy.argmax",
"numpy.random.randint",
"numpy.expand_dims",
"copy.copy"
] | [((8798, 8819), 'random.shuffle', 'random.shuffle', (['tiles'], {}), '(tiles)\n', (8812, 8819), False, 'import random\n'), ((4260, 4290), 'numpy.expand_dims', 'np.expand_dims', (['self.frames', '(0)'], {}), '(self.frames, 0)\n', (4274, 4290), True, 'import numpy as np\n'), ((8518, 8530), 'numpy.argmax', 'np.argmax', ([... |
# Generated by Django 3.2.4 on 2021-06-16 12:22
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('shop', '0001_initial'),
... | [
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.db.models.BigAutoField",
"django.db.models.DateTimeField",
"django.db.models.DecimalField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
] | [((227, 284), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (258, 284), False, 'from django.db import migrations, models\n'), ((448, 544), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '... |
"""Python package treeplot vizualizes a tree based on a randomforest or xgboost model."""
# --------------------------------------------------
# Name : treeplot.py
# Author : E.Taskesen
# Contact : <EMAIL>
# github : https://github.com/erdogant/treeplot
# Licence : See Licences
# --------------... | [
"wget.download",
"zipfile.ZipFile",
"matplotlib.image.imread",
"wget.filename_from_url",
"matplotlib.pyplot.imshow",
"sklearn.datasets.fetch_openml",
"xgboost.plot_importance",
"sklearn.datasets.load_breast_cancer",
"os.path.split",
"os.path.isdir",
"matplotlib.pyplot.axis",
"graphviz.Source",... | [((12831, 12858), 'wget.filename_from_url', 'wget.filename_from_url', (['url'], {}), '(url)\n', (12853, 12858), False, 'import wget\n'), ((12878, 12906), 'os.path.join', 'os.path.join', (['curpath', 'gfile'], {}), '(curpath, gfile)\n', (12890, 12906), False, 'import os\n'), ((3090, 3125), 'matplotlib.pyplot.subplots', ... |
"""
Copyright 2016 <NAME> <<EMAIL>>
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 ... | [
"error.DecodeException"
] | [((1730, 1757), 'error.DecodeException', 'DecodeException', (['"""char err"""'], {}), "('char err')\n", (1745, 1757), False, 'from error import DecodeException\n')] |
import json
import pandas as pd
with open ('input/senate.JSON') as data:
memebers = json.load(data)
# create an instance of set to store the unique committees
result = set()
# input is a list, where each item is a dictionary of the information about a committee memeber
for member in memebers:
committees = member['... | [
"json.load"
] | [((86, 101), 'json.load', 'json.load', (['data'], {}), '(data)\n', (95, 101), False, 'import json\n')] |
from alpaca_trade_api.rest import Order
from faker import Faker
from .helpers import get_uuid
fake = Faker()
def generate_sell_order():
return {
"replaces": "532b9037-6844-4bf9-8a4a-7e9a59d69167",
"order_type": "trailing_stop",
"type": "trailing_stop",
"side": "sell",
"ti... | [
"faker.Faker"
] | [((103, 110), 'faker.Faker', 'Faker', ([], {}), '()\n', (108, 110), False, 'from faker import Faker\n')] |
from model.contact import Contact
def test_delete_first_contact(app):
if app.contact.count() == 0:
app.contact.create_new(Contact(firstname="Ivan", middlename="Ivanovich", lastname="Ivanov"))
old_contacts = app.contact.get_contact_list()
app.contact.delete_first_contact()
new_contact... | [
"model.contact.Contact"
] | [((143, 211), 'model.contact.Contact', 'Contact', ([], {'firstname': '"""Ivan"""', 'middlename': '"""Ivanovich"""', 'lastname': '"""Ivanov"""'}), "(firstname='Ivan', middlename='Ivanovich', lastname='Ivanov')\n", (150, 211), False, 'from model.contact import Contact\n')] |
import pandas as pd
from enum import Enum
class EQUI(Enum):
EQUIVALENT = 1
DIF_CARDINALITY = 2
DIF_SCHEMA = 3
DIF_VALUES = 4
"""
UTILS
"""
def most_likely_key(df):
res = uniqueness(df)
res = sorted(res.items(), key=lambda x: x[1], reverse=True)
return res[0]
def uniqueness(df):
r... | [
"pandas.isnull",
"pandas.read_csv"
] | [((5410, 5443), 'pandas.read_csv', 'pd.read_csv', (['v'], {'encoding': '"""latin1"""'}), "(v, encoding='latin1')\n", (5421, 5443), True, 'import pandas as pd\n'), ((5517, 5550), 'pandas.read_csv', 'pd.read_csv', (['v'], {'encoding': '"""latin1"""'}), "(v, encoding='latin1')\n", (5528, 5550), True, 'import pandas as pd\... |
import os
from pyBigstick.nucleus import Nucleus
import streamlit as st
import numpy as np
import plotly.express as px
from barChartPlotly import plotly_barcharts_3d
from PIL import Image
he4_image = Image.open('assets/he4.png')
nucl_image = Image.open('assets/nucl_symbol.png')
table_image = Image.open('assets/table.... | [
"streamlit.image",
"streamlit.table",
"streamlit.button",
"numpy.arange",
"streamlit.title",
"streamlit.columns",
"streamlit.markdown",
"streamlit.write",
"streamlit.text",
"barChartPlotly.plotly_barcharts_3d",
"streamlit.subheader",
"streamlit.selectbox",
"streamlit.container",
"streamlit... | [((202, 230), 'PIL.Image.open', 'Image.open', (['"""assets/he4.png"""'], {}), "('assets/he4.png')\n", (212, 230), False, 'from PIL import Image\n'), ((244, 280), 'PIL.Image.open', 'Image.open', (['"""assets/nucl_symbol.png"""'], {}), "('assets/nucl_symbol.png')\n", (254, 280), False, 'from PIL import Image\n'), ((295, ... |
import uuid
import os
def get_path(instance, filename, folder):
""" Function to make 'upload_to' value of ImageField's """
ext = filename.split('.')[-1]
filename = "%s.%s" % (uuid.uuid4(), ext)
return os.path.join(folder, filename)
| [
"os.path.join",
"uuid.uuid4"
] | [((220, 250), 'os.path.join', 'os.path.join', (['folder', 'filename'], {}), '(folder, filename)\n', (232, 250), False, 'import os\n'), ((190, 202), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (200, 202), False, 'import uuid\n')] |
"""Scrape Google Play category data from Google Play."""
import argparse
import json
import logging
import os
from lxml.html import html5parser
import requests
from util.parse import parse_package_details
__log__ = logging.getLogger(__name__)
PLAY_STORE_LINK = 'https://play.google.com/store/apps/details?id={}'
C... | [
"logging.getLogger",
"os.makedirs",
"lxml.html.html5parser.fromstring",
"os.path.join",
"requests.get",
"util.parse.parse_package_details",
"json.dump"
] | [((220, 247), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (237, 247), False, 'import logging\n'), ((576, 610), 'requests.get', 'requests.get', (['url'], {'headers': 'HEADERS'}), '(url, headers=HEADERS)\n', (588, 610), False, 'import requests\n'), ((663, 696), 'lxml.html.html5parser.fro... |
from django.test import TestCase
from flaim.database import models
"""
https://realpython.com/test-driven-development-of-a-django-restful-api/
"""
class ProductTest(TestCase):
@classmethod
def setUpTestData(cls):
print("setUpTestData: Run once to set up non-modified data for all class methods.")
... | [
"flaim.database.models.Product.objects.create",
"flaim.database.models.Product.objects.get"
] | [((325, 446), 'flaim.database.models.Product.objects.create', 'models.Product.objects.create', ([], {'product_code': '"""EA_000000"""', 'name': '"""Test Product Name"""', 'brand': '"""Kelloggs"""', 'store': '"""WALMART"""'}), "(product_code='EA_000000', name=\n 'Test Product Name', brand='Kelloggs', store='WALMART')... |
import numpy as np
import matplotlib.pyplot as plt
theta = np.arange(0.01, 10., 0.04)
ytan = np.tan(theta)
ytanM = np.ma.masked_where(np.abs(ytan)>20., ytan)
plt.figure()
plt.plot(theta, ytanM)
plt.ylim(-8, 8)
plt.axhline(color="gray", zorder=-1)
plt.savefig('plotLimits3.pdf')
plt.show() | [
"numpy.abs",
"matplotlib.pyplot.savefig",
"numpy.tan",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.axhline",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.ylim",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((60, 87), 'numpy.arange', 'np.arange', (['(0.01)', '(10.0)', '(0.04)'], {}), '(0.01, 10.0, 0.04)\n', (69, 87), True, 'import numpy as np\n'), ((94, 107), 'numpy.tan', 'np.tan', (['theta'], {}), '(theta)\n', (100, 107), True, 'import numpy as np\n'), ((160, 172), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()... |
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: gateway/auth.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobu... | [
"google.protobuf.reflection.GeneratedProtocolMessageType",
"google.protobuf.symbol_database.Default",
"google.protobuf.descriptor.FieldDescriptor"
] | [((466, 492), 'google.protobuf.symbol_database.Default', '_symbol_database.Default', ([], {}), '()\n', (490, 492), True, 'from google.protobuf import symbol_database as _symbol_database\n'), ((5689, 5846), 'google.protobuf.reflection.GeneratedProtocolMessageType', '_reflection.GeneratedProtocolMessageType', (['"""HttpA... |
# -*- coding: utf-8 -*-
import logging
import numpy as np
class phandim(object):
"""
class to hold phantom dimensions
"""
def __init__(self, bx, by, bz):
"""
Constructor. Builds object from boundary vectors
Parameters
----------
bx: array of f... | [
"numpy.sort",
"logging.info",
"numpy.float32"
] | [((1354, 1389), 'logging.info', 'logging.info', (['"""phandim initialized"""'], {}), "('phandim initialized')\n", (1366, 1389), False, 'import logging\n'), ((2006, 2018), 'numpy.sort', 'np.sort', (['bnp'], {}), '(bnp)\n', (2013, 2018), True, 'import numpy as np\n'), ((1920, 1936), 'numpy.float32', 'np.float32', (['b[k]... |
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--num_sampled', type=int, default=1000)
parser.add_argument('--max_len', type=int, default=15)
parser.add_argument('--word_dropout_rate', type=float, default=0.8)
parser.add_argument('--batch_size', type=int, default=128)
parser.add_argument('--e... | [
"argparse.ArgumentParser"
] | [((26, 51), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (49, 51), False, 'import argparse\n')] |
async def say_hello():
print("hey, hello world!")
async def hello_world():
print("Resume coroutine.")
for i in range(3):
await say_hello()
print("Finished coroutine.")
class MyLoop:
def run_until_complete(self, task):
try:
while 1:
task.send(None)
... | [
"asyncio.get_event_loop"
] | [((464, 488), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (486, 488), False, 'import asyncio\n')] |
# Script to populate our training and testing databases with
# Financial company info: https://finnhub.io/docs/api/websocket-trades
# Finnhub page (log-in required):https://finnhub.io/dashboard
import pandas as pd
import numpy as np
import pandas_datareader as web
import matplotlib.pyplot as plt
import requests
import... | [
"datetime.datetime",
"random.choice",
"pandas_datareader.DataReader",
"os.path.join",
"requests.get",
"datetime.datetime.now"
] | [((484, 571), 'requests.get', 'requests.get', (['f"""https://finnhub.io/api/v1/stock/symbol?exchange=US&token={my_key}"""'], {}), "(\n f'https://finnhub.io/api/v1/stock/symbol?exchange=US&token={my_key}')\n", (496, 571), False, 'import requests\n'), ((1472, 1495), 'datetime.datetime', 'dt.datetime', (['(1985)', '(1)... |
"""
"""
import pandas as pd
import numpy as np
import os
class IntensitySuperStructure:
def __init__(self, parent_source_directory):
self.sources = set()
self.df = pd.DataFrame(dtype=object)
self.par = parent_source_directory
self.info = dict()
self.output = os.path.joi... | [
"pandas.Series",
"os.path.exists",
"os.listdir",
"pandas.read_csv",
"os.path.join",
"os.path.split",
"os.mkdir",
"pandas.DataFrame"
] | [((190, 216), 'pandas.DataFrame', 'pd.DataFrame', ([], {'dtype': 'object'}), '(dtype=object)\n', (202, 216), True, 'import pandas as pd\n'), ((309, 374), 'os.path.join', 'os.path.join', (['self.par', '"""TraceAnalysis"""', '"""gathered_data_book.csv"""'], {}), "(self.par, 'TraceAnalysis', 'gathered_data_book.csv')\n", ... |
# -*- coding: future_fstrings -*-
from app.database import Model, Column, SurrogatePK, db, relationship
import datetime as dt
import hashlib
class Room(SurrogatePK, Model):
__tablename__ = 'rooms'
name = Column(db.String(80), unique=True, nullable=False)
description = Column(db.String(300), unique=True, nullab... | [
"app.database.db.String",
"app.database.Column"
] | [((393, 456), 'app.database.Column', 'Column', (['db.DateTime'], {'nullable': '(False)', 'default': 'dt.datetime.utcnow'}), '(db.DateTime, nullable=False, default=dt.datetime.utcnow)\n', (399, 456), False, 'from app.database import Model, Column, SurrogatePK, db, relationship\n'), ((472, 535), 'app.database.Column', 'C... |
import sys
import numpy as np
import argparse
from mung.data import DataSet, Partition
PART_NAMES = ["train", "dev", "test"]
parser = argparse.ArgumentParser()
parser.add_argument('data_dir', action="store")
parser.add_argument('split_output_file', action="store")
parser.add_argument('train_size', action="s... | [
"mung.data.DataSet.load",
"mung.data.Partition.load",
"numpy.random.seed",
"argparse.ArgumentParser"
] | [((143, 168), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (166, 168), False, 'import argparse\n'), ((686, 711), 'numpy.random.seed', 'np.random.seed', (['args.seed'], {}), '(args.seed)\n', (700, 711), True, 'import numpy as np\n'), ((983, 1022), 'mung.data.DataSet.load', 'DataSet.load', (['d... |
from bigflow.workflow import Workflow
from bigflow.workflow import Definition
from .sequential_workflow import Job
job1, job2, job3, job4 = Job('1'), Job('2'), Job('3'), Job('4')
graph_workflow = Workflow(workflow_id='graph_workflow', definition=Definition({
job1: (job2, job3),
job2: (job4,),
job3: (job4,... | [
"bigflow.workflow.Definition"
] | [((248, 310), 'bigflow.workflow.Definition', 'Definition', (['{job1: (job2, job3), job2: (job4,), job3: (job4,)}'], {}), '({job1: (job2, job3), job2: (job4,), job3: (job4,)})\n', (258, 310), False, 'from bigflow.workflow import Definition\n')] |
from abc import ABC, abstractmethod
from copy import copy
from typing import Any, Optional
import numpy as np
from gym.spaces import Space
from gym.utils import seeding
class Operator(ABC):
# Set these in ALL subclasses
suboperators: tuple = tuple()
grid_dependant: Optional[bool] = None
action_depe... | [
"copy.copy",
"gym.utils.seeding.np_random"
] | [((1474, 1484), 'copy.copy', 'copy', (['grid'], {}), '(grid)\n', (1478, 1484), False, 'from copy import copy\n'), ((1507, 1520), 'copy.copy', 'copy', (['context'], {}), '(context)\n', (1511, 1520), False, 'from copy import copy\n'), ((1708, 1731), 'gym.utils.seeding.np_random', 'seeding.np_random', (['seed'], {}), '(se... |
import argparse
from precovery.precovery_db import PrecoveryDatabase
def parse_args():
parser = argparse.ArgumentParser(
"precoverydb-load-hdf", "populate a precoverydb with data from NSC hdf5 files"
)
parser.add_argument("db_dir", help="Directory holding the database")
parser.add_argument("d... | [
"precovery.precovery_db.PrecoveryDatabase.from_dir",
"argparse.ArgumentParser"
] | [((103, 210), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""precoverydb-load-hdf"""', '"""populate a precoverydb with data from NSC hdf5 files"""'], {}), "('precoverydb-load-hdf',\n 'populate a precoverydb with data from NSC hdf5 files')\n", (126, 210), False, 'import argparse\n'), ((940, 992), 'precov... |
"""m2t.py
The m2t engine for producing code for handling the code generation.
"""
import os
import autopep8
from jinja2 import Environment, FileSystemLoader
from ..exceptions import NotImplementedDriverError
from ..hw_devices import *
from ..get_impls import ImplementationsGetter
class Generator():
"""Generate ... | [
"os.path.abspath",
"jinja2.FileSystemLoader",
"autopep8.fix_code",
"jinja2.Environment"
] | [((1349, 1386), 'jinja2.FileSystemLoader', 'FileSystemLoader', (["(path + '/templates')"], {}), "(path + '/templates')\n", (1365, 1386), False, 'from jinja2 import Environment, FileSystemLoader\n'), ((1406, 1437), 'jinja2.Environment', 'Environment', ([], {'loader': 'file_loader'}), '(loader=file_loader)\n', (1417, 143... |
import subprocess, time, datetime
def cmdline(command):
process = subprocess.Popen(
args=command,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
return process.communicate()[0]
def getUptimeDict():
# uptimeData = subprocess.run(["tuptime", "-tcs"], stdout=subprocess.PIPE, sh... | [
"subprocess.Popen",
"datetime.timedelta",
"datetime.datetime.now"
] | [((71, 149), 'subprocess.Popen', 'subprocess.Popen', ([], {'args': 'command', 'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.PIPE'}), '(args=command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n', (87, 149), False, 'import subprocess, time, datetime\n'), ((1116, 1142), 'datetime.timedelta', 'datetime.timedelta... |
from setuptools import setup
setup(
name='forambulator',
version='0.1.0',
description='Generate synthetic forams',
url='https://github.com/metazool/forambulator',
author='<NAME>',
license='BSD 3-clause',
packages=['forambulator'],
install_requires=['numpy',
're... | [
"setuptools.setup"
] | [((30, 561), 'setuptools.setup', 'setup', ([], {'name': '"""forambulator"""', 'version': '"""0.1.0"""', 'description': '"""Generate synthetic forams"""', 'url': '"""https://github.com/metazool/forambulator"""', 'author': '"""<NAME>"""', 'license': '"""BSD 3-clause"""', 'packages': "['forambulator']", 'install_requires'... |
#!/opt/hostedtoolcache/Python/3.8.8/x64/bin/python
"""A script for casting spells on NIF files. This script is essentially
a nif specific wrapper around L{pyffi.spells.Toaster}."""
# --------------------------------------------------------------------------
# ***** BEGIN LICENSE BLOCK *****
#
# Copyright (c) 2007-201... | [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((8480, 8506), 'logging.getLogger', 'logging.getLogger', (['"""pyffi"""'], {}), "('pyffi')\n", (8497, 8506), False, 'import logging\n'), ((8559, 8592), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (8580, 8592), False, 'import logging\n'), ((8651, 8706), 'logging.Formatter',... |
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 2 11:13:20 2018
@author: RuxandraV
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Jun 26 14:27:37 2018
@author: rucsa
"""
import pandas as pd
from random import choice
from sklearn.preprocessing import MinMaxScaler
from rank_by_preferences impor... | [
"pandas.Series",
"sklearn.cluster.AgglomerativeClustering",
"random.choice",
"plots.plot",
"rank_by_preferences.rank_by_preferences",
"pandas.DataFrame",
"sklearn.preprocessing.MinMaxScaler",
"pandas.read_hdf",
"main_helper.group_clusters"
] | [((524, 618), 'pandas.read_hdf', 'pd.read_hdf', (['"""../data/fundamentals_2016_with_feat_msci_regions_encoded.hdf5"""', '"""dataset1/x"""'], {}), "('../data/fundamentals_2016_with_feat_msci_regions_encoded.hdf5',\n 'dataset1/x')\n", (535, 618), True, 'import pandas as pd\n'), ((753, 787), 'sklearn.preprocessing.Min... |
"""
Using CherryPy to put together very basic webserver to display
today's discussions on the IRC channel.
<NAME>, 6 September 2012
"""
import os
import time
import cherrypy
REFRESHCODE = """<META HTTP-EQUIV="REFRESH" CONTENT="60"> """
class HelloWorld:
def index(self):
# CherryPy will call this method ... | [
"os.system",
"time.asctime",
"cherrypy.config.update",
"cherrypy.server.start"
] | [((1635, 1674), 'cherrypy.config.update', 'cherrypy.config.update', (['"""cherrypy.conf"""'], {}), "('cherrypy.conf')\n", (1657, 1674), False, 'import cherrypy\n'), ((1712, 1735), 'cherrypy.server.start', 'cherrypy.server.start', ([], {}), '()\n', (1733, 1735), False, 'import cherrypy\n'), ((1133, 1246), 'os.system', '... |
import io
import logging
import os
import socket
import threading
import time
import unittest
from jobmon.protocol import *
logging.basicConfig(filename='jobmon-test_protocol.log', level=logging.DEBUG)
# The timeout value used when protocol wrappers with timeouts are requested.
# This value is in seconds.
TIMEOUT_LE... | [
"logging.basicConfig",
"socket.socket",
"time.sleep",
"os.fdopen",
"threading.Thread",
"os.pipe"
] | [((126, 203), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""jobmon-test_protocol.log"""', 'level': 'logging.DEBUG'}), "(filename='jobmon-test_protocol.log', level=logging.DEBUG)\n", (145, 203), False, 'import logging\n'), ((3721, 3752), 'threading.Thread', 'threading.Thread', ([], {'target': 'writ... |
# -*- coding: utf-8 -*-
# Copyright (c) 2018, VMRaid Technologies and contributors
# For license information, please see license.txt
from __future__ import unicode_literals
import vmraid
from vmraid.model.document import Document
from vmraid.core.doctype.user.user import extract_mentions
class PostComment(Document):
... | [
"vmraid.publish_realtime",
"vmraid.core.doctype.user.user.extract_mentions",
"vmraid.utils.get_fullname"
] | [((358, 388), 'vmraid.core.doctype.user.user.extract_mentions', 'extract_mentions', (['self.content'], {}), '(self.content)\n', (374, 388), False, 'from vmraid.core.doctype.user.user import extract_mentions\n'), ((693, 779), 'vmraid.publish_realtime', 'vmraid.publish_realtime', (["('new_post_comment' + self.parent)", '... |
###############################################################################
# WaterTAP Copyright (c) 2021, The Regents of the University of California,
# through Lawrence Berkeley National Laboratory, Oak Ridge National
# Laboratory, National Renewable Energy Laboratory, and National Energy
# Technology Laboratory ... | [
"idaes.core.util.initialization.propagate_state",
"pyomo.environ.value",
"idaes.models.unit_models.Product",
"watertap.property_models.NaCl_prop_pack.NaClParameterBlock",
"idaes.core.util.scaling.get_scaling_factor",
"pyomo.environ.check_optimal_termination",
"pyomo.network.SequentialDecomposition",
"... | [((3555, 3585), 'pyomo.environ.check_optimal_termination', 'check_optimal_termination', (['res'], {}), '(res)\n', (3580, 3585), False, 'from pyomo.environ import ConcreteModel, value, Param, Var, Constraint, Expression, Objective, TransformationFactory, Block, NonNegativeReals, RangeSet, Set, check_optimal_termination,... |
import functools
from collections import defaultdict
class EventDispatcherException(Exception):
pass
class Event:
def __init__(self, name, data=None):
self.name = name
self.data = data
self.stop = False
class EventSubscriber:
EVENTS = {}
class MemoryRegistry:
def __init__... | [
"collections.defaultdict",
"functools.wraps"
] | [((354, 371), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (365, 371), False, 'from collections import defaultdict\n'), ((2594, 2615), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (2609, 2615), False, 'import functools\n')] |
#!/usr/bin/env python
import rospy
def spam():
rospy.loginfo("spam foo")
def eggs():
rospy.loginfo("eggs foo")
if __name__ == '__main__':
try:
rospy.loginfo("do something")
except rospy.ROSInterruptException:
spam()
eggs()
rospy.loginfo("something went wrong!")
pass
finally:
rospy.loginfo("finished"... | [
"rospy.loginfo"
] | [((49, 74), 'rospy.loginfo', 'rospy.loginfo', (['"""spam foo"""'], {}), "('spam foo')\n", (62, 74), False, 'import rospy\n'), ((89, 114), 'rospy.loginfo', 'rospy.loginfo', (['"""eggs foo"""'], {}), "('eggs foo')\n", (102, 114), False, 'import rospy\n'), ((151, 180), 'rospy.loginfo', 'rospy.loginfo', (['"""do something"... |
from django.conf.urls import url
from django.views.generic import TemplateView
from . import views
from schoolOrSociety.views import index, questionary, result, process
urlpatterns = [
url(r'^questionary', views.questionary, {'template_name': 'schoolOrSociety/questionary.html'}, name='questionary'),
url(r'^res... | [
"django.conf.urls.url"
] | [((190, 307), 'django.conf.urls.url', 'url', (['"""^questionary"""', 'views.questionary', "{'template_name': 'schoolOrSociety/questionary.html'}"], {'name': '"""questionary"""'}), "('^questionary', views.questionary, {'template_name':\n 'schoolOrSociety/questionary.html'}, name='questionary')\n", (193, 307), False, ... |
import datetime
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
import Pegasus.db.schema as schema
from Pegasus.db.ensembles import EMError, Triggers, TriggerType
@pytest.fixture(scope="function")
def session():
"""
Create in-memory sqlite database with tables setu... | [
"sqlalchemy.orm.sessionmaker",
"sqlalchemy.create_engine",
"Pegasus.db.schema.Trigger",
"datetime.datetime.now",
"Pegasus.db.ensembles.Triggers.get_object",
"pytest.raises",
"Pegasus.db.schema.Base.metadata.create_all",
"pytest.fixture",
"Pegasus.db.ensembles.Triggers"
] | [((211, 243), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (225, 243), False, 'import pytest\n'), ((379, 405), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite://"""'], {}), "('sqlite://')\n", (392, 405), False, 'from sqlalchemy import create_engine\n'), ((449,... |
from bisect import bisect_right
from pathlib import Path
from katar.engine.io.index_interactor import IndexInteractor
from katar.engine.io.katar_interactor import KatarInteractor
from katar.engine.io.timeindex_interactor import TimeindexInteractor
from katar.engine.metadata import Metadata
from katar.engine.serializer... | [
"bisect.bisect_right",
"katar.engine.io.index_interactor.IndexInteractor",
"katar.engine.io.timeindex_interactor.TimeindexInteractor",
"katar.engine.io.katar_interactor.KatarInteractor"
] | [((737, 754), 'katar.engine.io.katar_interactor.KatarInteractor', 'KatarInteractor', ([], {}), '()\n', (752, 754), False, 'from katar.engine.io.katar_interactor import KatarInteractor\n'), ((787, 804), 'katar.engine.io.index_interactor.IndexInteractor', 'IndexInteractor', ([], {}), '()\n', (802, 804), False, 'from kata... |