code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import logging
from cliff.lister import Lister
from cliff.show import ShowOne
from atmosphere.api import AtmosphereAPI
class GroupList(Lister):
"""
List groups for a user.
"""
log = logging.getLogger(__name__)
def take_action(self, parsed_args):
column_headers = ('uuid', 'name')
... | [
"logging.getLogger",
"atmosphere.api.AtmosphereAPI"
] | [((202, 229), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (219, 229), False, 'import logging\n'), ((851, 878), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (868, 878), False, 'import logging\n'), ((327, 479), 'atmosphere.api.AtmosphereAPI', 'AtmosphereA... |
import numpy as np
from sklearn.cluster import KMeans
from splearn.cluster import SparkKMeans
from splearn.utils.testing import SplearnTestCase, assert_array_almost_equal
class TestKMeans(SplearnTestCase):
def test_same_centroids(self):
X, y, X_rdd = self.make_blobs(centers=4, n_samples=200000)
... | [
"sklearn.cluster.KMeans",
"numpy.sort",
"splearn.cluster.SparkKMeans",
"splearn.utils.testing.assert_array_almost_equal"
] | [((328, 383), 'sklearn.cluster.KMeans', 'KMeans', ([], {'n_clusters': '(4)', 'init': '"""k-means++"""', 'random_state': '(42)'}), "(n_clusters=4, init='k-means++', random_state=42)\n", (334, 383), False, 'from sklearn.cluster import KMeans\n'), ((399, 459), 'splearn.cluster.SparkKMeans', 'SparkKMeans', ([], {'n_cluster... |
""" Tests for worker """
import sys
import _pytest
import act.api
import pytest
from act.api.base import ValidationError
from act.api.helpers import handle_fact
from act.api.libs import cli
from act.types.format import object_format
from act.types.types import object_validates
from act.workers.libs import worker
de... | [
"act.workers.libs.worker.parseargs",
"pytest.raises",
"act.workers.libs.worker.init_act"
] | [((632, 653), 'act.workers.libs.worker.init_act', 'worker.init_act', (['args'], {}), '(args)\n', (647, 653), False, 'from act.workers.libs import worker\n'), ((1190, 1211), 'act.workers.libs.worker.init_act', 'worker.init_act', (['args'], {}), '(args)\n', (1205, 1211), False, 'from act.workers.libs import worker\n'), (... |
from setuptools import setup, find_packages
from codecs import open
from os import path
here = path.abspath(path.dirname(__file__))
# Get the long description from the README file
with open(path.join(here, 'README.md'), encoding='utf-8') as f:
long_description = f.read()
setup(
name='darch',
# Versions ... | [
"os.path.join",
"os.path.dirname",
"setuptools.setup"
] | [((279, 963), 'setuptools.setup', 'setup', ([], {'name': '"""darch"""', 'version': '"""0.1.0"""', 'description': '"""Deep Architect"""', 'long_description': 'long_description', 'url': '"""https://github.com/negrinho/deep_architect"""', 'author': '"""The Python Packaging Authority"""', 'author_email': '"""<EMAIL>"""', '... |
import curses
from .game import Game
def go(stdscr):
Game(stdscr).run() # Start game
def main():
# Curses convinient wrapper
curses.wrapper(go)
if __name__ == '__main__':
main() | [
"curses.wrapper"
] | [((142, 160), 'curses.wrapper', 'curses.wrapper', (['go'], {}), '(go)\n', (156, 160), False, 'import curses\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright(c) 2019 Nippon Telegraph and Telephone Corporation
# Filename: NVRDriverCLIProtocol.py
import traceback
import re
import GlobalModule
from EmCommonLog import decorater_log
from CgwshDriverCLIProtocol import CgwshDriverCLIProtocol
class NVRDriverCL... | [
"GlobalModule.EM_LOGGER.debug",
"traceback.format_exc",
"re.search"
] | [((970, 1047), 'GlobalModule.EM_LOGGER.debug', 'GlobalModule.EM_LOGGER.debug', (['("""start exit command :\n%s""" % (send_message,))'], {}), '("""start exit command :\n%s""" % (send_message,))\n', (998, 1047), False, 'import GlobalModule\n'), ((1885, 1960), 'GlobalModule.EM_LOGGER.debug', 'GlobalModule.EM_LOGGER.debug'... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2015 <NAME> (davvid -at- gmail.com)
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
import os
try:
import setuptools as setup_mod
except ImportError:... | [
"os.path.dirname",
"os.path.join",
"distutils.core.setup"
] | [((368, 393), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (383, 393), False, 'import os\n'), ((404, 456), 'os.path.join', 'os.path.join', (['here', '"""skeletor"""', '"""core"""', '"""version.py"""'], {}), "(here, 'skeletor', 'core', 'version.py')\n", (416, 456), False, 'import os\n'), ((1... |
# coding=utf-8
# Copyright 2020 HuggingFace Datasets Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"datasets.SplitGenerator",
"datasets.features.ClassLabel",
"datasets.Version",
"datasets.logging.get_logger",
"datasets.Value"
] | [((665, 702), 'datasets.logging.get_logger', 'datasets.logging.get_logger', (['__name__'], {}), '(__name__)\n', (692, 702), False, 'import datasets\n'), ((3421, 3527), 'datasets.SplitGenerator', 'datasets.SplitGenerator', ([], {'name': 'datasets.Split.TRAIN', 'gen_kwargs': "{'filepath': downloaded_files['train']}"}), "... |
import click
import vk.config as config
import vk.utils as utils
from vk.commands.query import show_layer_state
def _add_layers(layer_str, current_layers, set_layers_func):
"""Append layers to current_layers and set to device props.
Args:
layer_str: A string in <layer1:layer2:layerN> format.
... | [
"click.echo",
"vk.utils.get_valid_app_name",
"click.BadParameter",
"vk.utils.enable_gpu_debug_layers",
"click.UsageError",
"click.option",
"click.command",
"vk.commands.query.show_layer_state",
"vk.utils.get_gpu_debug_layers",
"click.argument",
"click.confirm",
"click.prompt",
"vk.config.Set... | [((1164, 1179), 'click.command', 'click.command', ([], {}), '()\n', (1177, 1179), False, 'import click\n'), ((1181, 1295), 'click.option', 'click.option', (['"""--app"""', '"""app_name"""'], {'type': 'str', 'metavar': '"""<app_name>"""', 'help': '"""Modify per-app layer configuration."""'}), "('--app', 'app_name', type... |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
import rospy
import message_filters
from std_msgs.msg import Int32, Float32
from pololu_drv8835_rpi import motors
rospy.init_node('message_sync', anonymous=False)
speed_desired = 0.5 # desired wheel speed in rpm
angle_desired = 0.0 # desired angle - 0
k_p_angle = 4*480... | [
"rospy.init_node",
"rospy.get_rostime",
"rospy.spin",
"message_filters.Subscriber",
"message_filters.ApproximateTimeSynchronizer"
] | [((164, 212), 'rospy.init_node', 'rospy.init_node', (['"""message_sync"""'], {'anonymous': '(False)'}), "('message_sync', anonymous=False)\n", (179, 212), False, 'import rospy\n'), ((1319, 1338), 'rospy.get_rostime', 'rospy.get_rostime', ([], {}), '()\n', (1336, 1338), False, 'import rospy\n'), ((2284, 2303), 'rospy.ge... |
# -*- coding: utf-8 -*-
# Copyright (c) 2016, KOL
# All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list o... | [
"updater.Updater"
] | [((2445, 2476), 'updater.Updater', 'Updater', (["(PREFIX + '/update')", 'oc'], {}), "(PREFIX + '/update', oc)\n", (2452, 2476), False, 'from updater import Updater\n')] |
# !/usr/bin/env python
# coding:utf-8
# Author:XuPengTao
# Date: 2020/3/14
from ssd.layers import L2Norm
import torch.nn.functional as F
import torch.nn as nn
import torch
from ssd.modeling import registry
import os
import quantization.WqAq.dorefa.models.util_wqaq as dorefa
import quantization.WqAq.IAO.models.util_wqaq... | [
"torch.nn.ReLU",
"ssd.layers.L2Norm",
"torch.nn.Sequential",
"torch.sqrt",
"torch.nn.BatchNorm2d",
"torch.nn.ModuleList",
"torch.nn.init.zeros_",
"torch.nn.functional.relu6",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.LeakyReLU",
"ssd.modeling.registry.BACKBONES.register",
"torch.nn.init.kaiming_... | [((20852, 20895), 'ssd.modeling.registry.BACKBONES.register', 'registry.BACKBONES.register', (['"""cfg_backbone"""'], {}), "('cfg_backbone')\n", (20879, 20895), False, 'from ssd.modeling import registry\n'), ((481, 496), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (494, 496), False, 'import torch\n'), ((533, 72... |
import os
import shutil
def build_env(config, config_name, path):
t_path = os.path.join(path, config_name)
if config != t_path:
os.makedirs(path, exist_ok=True)
shutil.copyfile(config, os.path.join(path, config_name))
| [
"os.path.join",
"os.makedirs"
] | [((80, 111), 'os.path.join', 'os.path.join', (['path', 'config_name'], {}), '(path, config_name)\n', (92, 111), False, 'import os\n'), ((145, 177), 'os.makedirs', 'os.makedirs', (['path'], {'exist_ok': '(True)'}), '(path, exist_ok=True)\n', (156, 177), False, 'import os\n'), ((210, 241), 'os.path.join', 'os.path.join',... |
"""
Python 3.9 программа самостоятельной игры агентов текущего и предыдущего покаления
программа на Python по изучению обучения с подкреплением - Reinforcement Learning
Название файла actor.py
Version: 0.1
Author: <NAME>
Date: 2021-12-23
"""
import numpy as np
import parl
import os
from alphazero_agent import create_a... | [
"MCTS.MCTS",
"utils.win_loss_draw",
"parl.remote_class",
"alphazero_agent.create_agent",
"numpy.random.seed"
] | [((406, 435), 'parl.remote_class', 'parl.remote_class', ([], {'wait': '(False)'}), '(wait=False)\n', (423, 435), False, 'import parl\n'), ((531, 551), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (545, 551), True, 'import numpy as np\n'), ((1788, 1823), 'alphazero_agent.create_agent', 'create_agen... |
from ptkcmd import PtkCmd, Completion, complete_files
class MyPtkCmd(PtkCmd):
prompt='MyPtkCmd$ '
def __init__(self,stdin=None,stdout=None,intro=None,interactive=True,do_complete_cmd=True,default_shell=False,**psession_kwargs):
super().__init__(stdin,stdout,intro,interactive,do_complete_cmd,default_shel... | [
"ptkcmd.complete_files"
] | [((759, 783), 'ptkcmd.complete_files', 'complete_files', (['curr_arg'], {}), '(curr_arg)\n', (773, 783), False, 'from ptkcmd import PtkCmd, Completion, complete_files\n')] |
from schema.models import Member
from django.shortcuts import render
def save_userdata(backend, user, response, *args, **kwargs):
if backend.name == 'facebook':
try:
profile = Member.objects.get(user_id=user.id)
except Member.DoesNotExist:
profile = Member(user_id=user.id)
... | [
"django.shortcuts.render",
"schema.models.Member",
"schema.models.Member.objects.get"
] | [((462, 491), 'django.shortcuts.render', 'render', (['request', '"""index.html"""'], {}), "(request, 'index.html')\n", (468, 491), False, 'from django.shortcuts import render\n'), ((525, 554), 'django.shortcuts.render', 'render', (['request', '"""index.html"""'], {}), "(request, 'index.html')\n", (531, 554), False, 'fr... |
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import get_object_or_404, render, redirect
from django.urls import reverse
from django.views import generic
from django.views.generic import View
from .pdf import *
from .models import Campus, Usuario, Inventario, Libros,Issue,Resp,Cd
fro... | [
"django.shortcuts.render",
"django.http.HttpResponse",
"django.shortcuts.redirect"
] | [((479, 549), 'django.shortcuts.render', 'render', (['request', '"""inventario/index.html"""', "{'inventarios': inventarios}"], {}), "(request, 'inventario/index.html', {'inventarios': inventarios})\n", (485, 549), False, 'from django.shortcuts import get_object_or_404, render, redirect\n'), ((823, 919), 'django.shortc... |
import math
a = int(input('digite um numero:'))
print('O dobro do valor digitado é: {}\nO triplo é: {}\nA Raiz quadrada é: {}'.format((a*2),(a*3),(math.sqrt(a))))
| [
"math.sqrt"
] | [((150, 162), 'math.sqrt', 'math.sqrt', (['a'], {}), '(a)\n', (159, 162), False, 'import math\n')] |
#!/usr/bin/python
import os, csv
import tensorflow as tf
import numpy as np
import pandas as pd
import helpers
# fix random seed for reproducibility
np.random.seed(7)
#-------------------------- Constants --------------------------#
FLAGS = tf.flags.FLAGS
tf.flags.DEFINE_string(
"input_dir", os.path.abspath("../d... | [
"helpers.extract_hour",
"pandas.DataFrame",
"os.path.join",
"tensorflow.contrib.learn.preprocessing.VocabularyProcessor",
"helpers.create_iter_generator",
"numpy.random.seed",
"tensorflow.flags.DEFINE_integer",
"os.path.abspath",
"tensorflow.contrib.learn.preprocessing.VocabularyProcessor.restore"
] | [((151, 168), 'numpy.random.seed', 'np.random.seed', (['(7)'], {}), '(7)\n', (165, 168), True, 'import numpy as np\n'), ((549, 619), 'tensorflow.flags.DEFINE_integer', 'tf.flags.DEFINE_integer', (['"""max_vector_len"""', '(16)', '"""Maximum vector length"""'], {}), "('max_vector_len', 16, 'Maximum vector length')\n", (... |
from django.contrib import admin
from django.urls import path
# from django.contrib.auth.decorators import login_required
# from rest_framework.urlpatterns import format_suffix_patterns
from . views import *
urlpatterns = [
# path('admin/', admin.site.urls),
path('', main_view, name='main_view'),
]
| [
"django.urls.path"
] | [((267, 304), 'django.urls.path', 'path', (['""""""', 'main_view'], {'name': '"""main_view"""'}), "('', main_view, name='main_view')\n", (271, 304), False, 'from django.urls import path\n')] |
#!/usr/bin/env python
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import unittest
from app_yaml_helper import AppYamlHelper
from extensions_paths import SERVER2
from host_file_system_provider import H... | [
"test_file_system.MoveTo",
"test_file_system.TestFileSystem",
"unittest.main",
"object_store_creator.ObjectStoreCreator.ForTest",
"app_yaml_helper.AppYamlHelper",
"host_file_system_provider.HostFileSystemProvider",
"test_util.DisableLogging"
] | [((2371, 2396), 'test_util.DisableLogging', 'DisableLogging', (['"""warning"""'], {}), "('warning')\n", (2385, 2396), False, 'from test_util import DisableLogging\n'), ((6137, 6152), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6150, 6152), False, 'import unittest\n'), ((3295, 3323), 'object_store_creator.Objec... |
import numpy as np
import tensorflow as tf
from tensorstream.finance.supertrend import Supertrend
from tensorstream.tests import TestCase
class SupertrendSpec(TestCase):
def setUp(self):
self.sheets = self.read_ods(
self.from_test_res('supertrend.ods', __file__))
def test_supertrend(self):
sheet =... | [
"numpy.testing.assert_almost_equal",
"tensorflow.placeholder",
"tensorstream.finance.supertrend.Supertrend",
"tensorflow.Session"
] | [((364, 381), 'tensorstream.finance.supertrend.Supertrend', 'Supertrend', (['(10)', '(3)'], {}), '(10, 3)\n', (374, 381), False, 'from tensorstream.finance.supertrend import Supertrend\n'), ((401, 427), 'tensorflow.placeholder', 'tf.placeholder', (['tf.float32'], {}), '(tf.float32)\n', (415, 427), True, 'import tensorf... |
import sys
import math
sys.setrecursionlimit(999000)
def fac(x):
if x < 2:
return 1
return x * fac(x - 1)
print(math.log10( fac(int(sys.argv[1])) ))
| [
"sys.setrecursionlimit"
] | [((23, 52), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(999000)'], {}), '(999000)\n', (44, 52), False, 'import sys\n')] |
#!/usr/bin/python
from Tkinter import *
from notifier import Notifier
from configurationReader import Configuration
class PomodoroTimer(Frame):
def __start(self):
"""
Start to work, this function is executed only the first
time
"""
self.__button.config(text = "Stop",
background = '#e21212',
ac... | [
"notifier.Notifier",
"configurationReader.Configuration"
] | [((3474, 3489), 'notifier.Notifier', 'Notifier', (['alarm'], {}), '(alarm)\n', (3482, 3489), False, 'from notifier import Notifier\n'), ((3024, 3039), 'configurationReader.Configuration', 'Configuration', ([], {}), '()\n', (3037, 3039), False, 'from configurationReader import Configuration\n')] |
"""
"""
import unittest
import arcpy
from numpy import pi
from gsfarc.test import config
class TestDatatypeDouble(unittest.TestCase):
"""Tests the double task datatype"""
@classmethod
def setUpClass(cls):
"""Class setup creates a toolbox file wrapper to GSF."""
config.setup_idl_toolbox('t... | [
"unittest.main",
"gsfarc.test.config.setup_idl_toolbox",
"arcpy.QA_IDLTaskEngine_DataType_Double_GSF"
] | [((1017, 1032), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1030, 1032), False, 'import unittest\n'), ((293, 381), 'gsfarc.test.config.setup_idl_toolbox', 'config.setup_idl_toolbox', (['"""test_datatype_double"""', '"""qa_idltaskengine_datatype_double"""'], {}), "('test_datatype_double',\n 'qa_idltaskengine... |
import psutil
import os
import time
def get_function_memory_usage(function, iterations=100, max_time=None,
max_mem_usage=90, verbose=False, display_period=0.2):
'''
Cette fonction execute <iterations> fois <function> et renvoit la difference
de mémoire virtuelle utilisée pa... | [
"psutil.virtual_memory",
"time.time",
"os.getpid"
] | [((660, 671), 'time.time', 'time.time', ([], {}), '()\n', (669, 671), False, 'import time\n'), ((628, 639), 'os.getpid', 'os.getpid', ([], {}), '()\n', (637, 639), False, 'import os\n'), ((1014, 1037), 'psutil.virtual_memory', 'psutil.virtual_memory', ([], {}), '()\n', (1035, 1037), False, 'import psutil\n'), ((1051, 1... |
"""__main__ file invoked with `python -m tiatoolbox` command"""
from tiatoolbox.cli import main
main()
| [
"tiatoolbox.cli.main"
] | [((98, 104), 'tiatoolbox.cli.main', 'main', ([], {}), '()\n', (102, 104), False, 'from tiatoolbox.cli import main\n')] |
# Copyright 2020, Battelle Energy Alliance, LLC
# ALL RIGHTS RESERVED
import numpy as np
import math
import random
from scipy.integrate import quad
def timeDepLambda(t,a,b):
return a+t*b
def pdfFailure(t,a,b):
first = timeDepLambda(t,a,b)
second = math.exp(-quad(timeDepLambda, 0, t, args=(a,b))[0])
return fi... | [
"scipy.integrate.quad",
"numpy.zeros",
"numpy.ndenumerate"
] | [((452, 480), 'numpy.zeros', 'np.zeros', (["Input['time'].size"], {}), "(Input['time'].size)\n", (460, 480), True, 'import numpy as np\n'), ((503, 532), 'numpy.ndenumerate', 'np.ndenumerate', (["Input['time']"], {}), "(Input['time'])\n", (517, 532), True, 'import numpy as np\n'), ((267, 305), 'scipy.integrate.quad', 'q... |
from collections import defaultdict
from minpair import arpabet
from minpair.corpus import require as corpus_require
from nltk.corpus import brown
from nltk.corpus import cmudict
from nltk.corpus import words
import re
class Generator(object):
"""Class to generate minimal pairs.
"""
def __init__(self, do... | [
"minpair.arpabet.is_vowel",
"minpair.corpus.require",
"minpair.arpabet.has_stress",
"nltk.corpus.brown.tagged_words",
"nltk.corpus.cmudict.entries",
"collections.defaultdict",
"nltk.corpus.words.words"
] | [((2496, 2520), 'collections.defaultdict', 'defaultdict', (['(lambda : {})'], {}), '(lambda : {})\n', (2507, 2520), False, 'from collections import defaultdict\n'), ((1455, 1478), 'minpair.corpus.require', 'corpus_require', (['corpora'], {}), '(corpora)\n', (1469, 1478), True, 'from minpair.corpus import require as cor... |
import asyncio
import glob
import os
import random
import subprocess
import sys
import wave
from collections import defaultdict
from contextlib import suppress
from datetime import datetime
from functools import partial
from itertools import count, islice
from pathlib import Path
from typing import Default... | [
"discord.FFmpegPCMAudio",
"youtube_dl.YoutubeDL",
"discord.ext.commands.group",
"pathvalidate.sanitize_filename",
"discord.ext.commands.cooldown",
"discord.ext.commands.command",
"os.remove",
"pathlib.Path",
"asyncio.Queue",
"subprocess.call",
"discord.opus.load_opus",
"asyncio.get_event_loop"... | [((1927, 1946), 'youtube_dl.YoutubeDL', 'YoutubeDL', (['ytdlopts'], {}), '(ytdlopts)\n', (1936, 1946), False, 'from youtube_dl import YoutubeDL\n'), ((10776, 10808), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""players"""'}), "(name='players')\n", (10792, 10808), False, 'from discord.ext import... |
# -*- encoding: utf-8 -*-
"""
_core/queries_db/query_stats.py
"""
import re
import random
import pandas as pd
import numpy as np
from pandas.io.json import json_normalize
from log_config import log, pformat
log.debug("... _core.queries_db.query_stats.py ..." )
from bson.objectid import ObjectId
from flask_r... | [
"bson.objectid.ObjectId",
"log_config.pformat",
"log_config.log.debug",
"bson.objectid.ObjectId.is_valid"
] | [((213, 265), 'log_config.log.debug', 'log.debug', (['"""... _core.queries_db.query_stats.py ..."""'], {}), "('... _core.queries_db.query_stats.py ...')\n", (222, 265), False, 'from log_config import log, pformat\n'), ((1034, 1101), 'log_config.log.debug', 'log.debug', (['"""... Query_db_stats / document_type : %s"""',... |
# This is the file that implements a flask server to do inferences.
import os
import json
import flask
import pandas as pd
from io import StringIO, BytesIO
import mindsdb
# Define the path
prefix = '/opt/ml/'
model_path = os.path.join(prefix, 'model')
def parse_data(content_type, data):
'''
Get the request c... | [
"os.path.exists",
"mindsdb.Predictor",
"pandas.read_csv",
"flask.Flask",
"json.dumps",
"os.path.join",
"io.BytesIO",
"flask.Response",
"pandas.read_excel",
"pandas.DataFrame",
"io.StringIO"
] | [((223, 252), 'os.path.join', 'os.path.join', (['prefix', '"""model"""'], {}), "(prefix, 'model')\n", (235, 252), False, 'import os\n'), ((1000, 1021), 'flask.Flask', 'flask.Flask', (['__name__'], {}), '(__name__)\n', (1011, 1021), False, 'import flask\n'), ((1392, 1469), 'flask.Response', 'flask.Response', ([], {'resp... |
from math import floor
n = int(input())
result = 0
game_over = False
path = []
directions = {
"up": (-1, 0),
"down": (1, 0),
"left": (0, -1),
"right": (0, 1)
}
matrix = []
for row in range(n):
matrix.append(input().split())
def movement_is_valid(movement):
if movement == "up" or movement... | [
"math.floor"
] | [((2158, 2171), 'math.floor', 'floor', (['result'], {}), '(result)\n', (2163, 2171), False, 'from math import floor\n')] |
import os
import torch
import torchvision.datasets as datasets
from .imagenet import ImageNetSubsample, ImageNetSubsampleValClasses
import numpy as np
CLASS_SUBLIST = [
1, 2, 4, 6, 8, 9, 11, 13, 22, 23, 26, 29, 31, 39, 47, 63, 71, 76, 79, 84, 90, 94, 96, 97, 99, 100, 105, 107,
113, 122,
125, 130, 132, 14... | [
"os.path.join"
] | [((1596, 1637), 'os.path.join', 'os.path.join', (['self.location', '"""imagenet-r"""'], {}), "(self.location, 'imagenet-r')\n", (1608, 1637), False, 'import os\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
This bot retreives a list of long term IP blocks on the wiki and tries to
identify if any of them are proxies. If so, it extends the block for another
year.
"""
#
# (C) User:<NAME>, 2019
# (C) User:Huji, 2019
#
# Distributed under the terms of the CC-BY-SA license.
#
from _... | [
"json.loads",
"cidr_trie.PatriciaTrie",
"pywikibot.Site",
"pywikibot.User",
"re.match",
"requests.get",
"ipwhois.IPWhois",
"pywikibot.Page",
"MySQLdb.connect",
"pywikibot.output"
] | [((583, 599), 'pywikibot.Site', 'pywikibot.Site', ([], {}), '()\n', (597, 599), False, 'import pywikibot\n'), ((940, 954), 'cidr_trie.PatriciaTrie', 'PatriciaTrie', ([], {}), '()\n', (952, 954), False, 'from cidr_trie import PatriciaTrie\n'), ((980, 994), 'cidr_trie.PatriciaTrie', 'PatriciaTrie', ([], {}), '()\n', (992... |
from backend.create_app import create_app
application = create_app()
| [
"backend.create_app.create_app"
] | [((58, 70), 'backend.create_app.create_app', 'create_app', ([], {}), '()\n', (68, 70), False, 'from backend.create_app import create_app\n')] |
# encoding: utf-8
from unittest.mock import Mock, patch
from src.client.models import utils
from src.exceptions import WalletError
from tests.unit.logging import LoggingMixin
class ClientUtilsTest(LoggingMixin):
def setUp(self):
self.data = {'test_data_key': 'test_data_value'}
def test_get_utcnow_... | [
"src.client.models.utils.serialize",
"unittest.mock.patch",
"src.client.models.utils.get_utcnow_timestamp",
"src.exceptions.WalletError"
] | [((617, 660), 'unittest.mock.patch', 'patch', (['"""src.client.models.utils.json.dumps"""'], {}), "('src.client.models.utils.json.dumps')\n", (622, 660), False, 'from unittest.mock import Mock, patch\n'), ((357, 385), 'src.client.models.utils.get_utcnow_timestamp', 'utils.get_utcnow_timestamp', ([], {}), '()\n', (383, ... |
from flask import request
from assemblyline.common.concurrency import execute_concurrently
from assemblyline.common.importing import module_attribute_by_name
from al_ui.api_base import api_login, make_api_response
from al_ui.apiv3 import core
from al_ui.config import LOGGER, config
from assemblyline.al.datasource.comm... | [
"flask.request.args.get",
"al_ui.api_base.make_api_response",
"assemblyline.common.concurrency.execute_concurrently",
"assemblyline.common.importing.module_attribute_by_name",
"al_ui.config.LOGGER.exception",
"al_ui.config.config.datasources.iteritems",
"al_ui.apiv3.core.make_subapi_blueprint",
"assem... | [((384, 419), 'al_ui.apiv3.core.make_subapi_blueprint', 'core.make_subapi_blueprint', (['SUB_API'], {}), '(SUB_API)\n', (410, 419), False, 'from al_ui.apiv3 import core\n'), ((1881, 1911), 'al_ui.api_base.api_login', 'api_login', ([], {'required_priv': "['R']"}), "(required_priv=['R'])\n", (1890, 1911), False, 'from al... |
#!/usr/bin/env python
r"""
This file contains functions useful for validating variables in robot.
"""
import gen_robot_print as grp
import gen_valid as gv
from robot.libraries.BuiltIn import BuiltIn
from robot.api import logger
def rvalid_value(var_name,
invalid_values=[],
valid_v... | [
"gen_robot_print.sprint_error_report",
"robot.libraries.BuiltIn.BuiltIn",
"gen_valid.svalid_range",
"gen_valid.svalid_integer",
"gen_valid.svalid_value"
] | [((2546, 2612), 'gen_valid.svalid_value', 'gv.svalid_value', (['var_value', 'invalid_values', 'valid_values', 'var_name'], {}), '(var_value, invalid_values, valid_values, var_name)\n', (2561, 2612), True, 'import gen_valid as gv\n'), ((2709, 2747), 'gen_robot_print.sprint_error_report', 'grp.sprint_error_report', (['er... |
import cherrypy
import os
hostIp = "127.0.0.1"
portNumber = 1337
class ImpulseServer(object):
def get_path(self, data_path):
return os.path.dirname(os.path.realpath(__file__)) + os.sep + data_path
@cherrypy.expose
def index(self):
main_path = self.get_path('main.html')
with open(main_path, "r") as f:
ret... | [
"os.path.realpath",
"os.getcwd"
] | [((509, 520), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (518, 520), False, 'import os\n'), ((153, 179), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (169, 179), False, 'import os\n')] |
# -*- coding: utf-8 -*-
import sys
import numpy as np
import time
from utils import print_bracketing, check_dir
import argparse
import torch
import os.path
import re
import matplotlib
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
class Saver():
"""
Handles the saving of checkpoints a... | [
"time.localtime",
"re.search",
"numpy.convolve",
"numpy.ones",
"argparse.ArgumentParser",
"torch.load",
"numpy.array",
"matplotlib.pyplot.figure",
"matplotlib.gridspec.GridSpec",
"numpy.zeros",
"torch.cuda.is_available",
"time.time",
"numpy.pad",
"utils.check_dir",
"utils.print_bracketin... | [((21619, 21792), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Continuous control environment for Udacity DeepRL course."""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description=\n 'Continuous control environment for Udacity DeepRL co... |
import json
from unittest.mock import ANY, MagicMock, call, patch
from pinga.events.consumer import Consumer
@patch("pinga.events.consumer.get_db_conn")
@patch("pinga.events.consumer.save_event")
@patch("pinga.events.consumer.get_logger")
@patch(
"pinga.events.consumer.KafkaConsumer",
return_value=[
... | [
"pinga.events.consumer.Consumer",
"unittest.mock.MagicMock",
"unittest.mock.call",
"json.dumps",
"unittest.mock.patch"
] | [((113, 155), 'unittest.mock.patch', 'patch', (['"""pinga.events.consumer.get_db_conn"""'], {}), "('pinga.events.consumer.get_db_conn')\n", (118, 155), False, 'from unittest.mock import ANY, MagicMock, call, patch\n'), ((157, 198), 'unittest.mock.patch', 'patch', (['"""pinga.events.consumer.save_event"""'], {}), "('pin... |
from PySide6.QtCore import Qt, QThread, Signal, QPoint, QRect, QLocale, QTranslator, QCoreApplication, QThreadPool, \
QObject, QRunnable
from PySide6.QtGui import QCursor, QPixmap, QIcon, QFont
from PySide6.QtWidgets import QApplication, QMessageBox
from gui_about import Ui_AboutWindow
from gui_main import Ui_MainW... | [
"PySide6.QtCore.QLocale",
"webbrowser.open_new",
"subprocess.STARTUPINFO",
"PySide6.QtWidgets.QMessageBox",
"os.walk",
"PySide6.QtCore.QPoint",
"PySide6.QtCore.QThreadPool",
"subprocess.Popen",
"PySide6.QtWidgets.QApplication.setHighDpiScaleFactorRoundingPolicy",
"PySide6.QtGui.QCursor",
"packag... | [((930, 947), 'os.walk', 'os.walk', (['dir_path'], {}), '(dir_path)\n', (937, 947), False, 'import os\n'), ((13008, 13019), 'PySide6.QtCore.Signal', 'Signal', (['str'], {}), '(str)\n', (13014, 13019), False, 'from PySide6.QtCore import Qt, QThread, Signal, QPoint, QRect, QLocale, QTranslator, QCoreApplication, QThreadP... |
import json_and_dictionary_constructor
class Channel:
def __init__(self, user, channel_id):
self.channel_id = channel_id
self.user = user
async def send(self, message):
http_template = dictionary_templates.http_load
message_template = dictionary_templates.new_message
... | [
"json_and_dictionary_constructor.create_http_request"
] | [((737, 888), 'json_and_dictionary_constructor.create_http_request', 'json_and_dictionary_constructor.create_http_request', (['"""GET"""', "('/channels/' + self.channel_id)", "{'Authorization': 'Bot ' + self.user.bot_data['token']}"], {}), "('GET', '/channels/' +\n self.channel_id, {'Authorization': 'Bot ' + self.us... |
# This file is just a basic example of the server comunication structure to a client program.
# The server is run on the embedded computer and passes data to a client on your local pc
# over a direct wifi connection. This can be used to display telemetry.
import time
import json
import socket
def current_time(start_... | [
"socket.socket",
"json.dumps",
"socket.bind",
"time.time",
"socket.recvfrom"
] | [((911, 922), 'time.time', 'time.time', ([], {}), '()\n', (920, 922), False, 'import time\n'), ((968, 1016), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (981, 1016), False, 'import socket\n'), ((1045, 1068), 'socket.bind', 'socket.bind', (['(... |
from django.db import models
from mayan.apps.testing.tests.base import BaseTestCase
from ..classes import QuerysetParametersSerializer
class QuerysetParametersSerializerTestCase(BaseTestCase):
def setUp(self):
super().setUp()
self.TestModelParent = self._create_test_model(
model_name... | [
"django.db.models.ForeignKey"
] | [((451, 546), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'models.CASCADE', 'related_name': '"""children"""', 'to': '"""TestModelParent"""'}), "(on_delete=models.CASCADE, related_name='children', to=\n 'TestModelParent')\n", (468, 546), False, 'from django.db import models\n')] |
import matplotlib.pyplot as plt
import numpy as np
def autolabel(rects):
for rect in rects:
height = rect.get_height()
plt.text(rect.get_x()+rect.get_width()/2., 1.03*height, "%s" % float(height))
text = ["10.65x", "57.62x", "54.44x"]
def autolabel_user(rects):
for i, rect in enumerate(rects... | [
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.bar",
"matplotlib.pyplot.yticks",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((478, 493), 'numpy.arange', 'np.arange', (['size'], {}), '(size)\n', (487, 493), True, 'import numpy as np\n'), ((760, 798), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Operation"""'], {'fontsize': '(18.5)'}), "('Operation', fontsize=18.5)\n", (770, 798), True, 'import matplotlib.pyplot as plt\n'), ((799, 850), '... |
from django_tables2 import TemplateColumn
from service_catalog.models import GlobalHook
from Squest.utils.squest_table import SquestTable
class GlobalHookTable(SquestTable):
state = TemplateColumn(template_name='custom_columns/global_hook_state.html')
actions = TemplateColumn(template_name='custom_columns/gl... | [
"django_tables2.TemplateColumn"
] | [((189, 258), 'django_tables2.TemplateColumn', 'TemplateColumn', ([], {'template_name': '"""custom_columns/global_hook_state.html"""'}), "(template_name='custom_columns/global_hook_state.html')\n", (203, 258), False, 'from django_tables2 import TemplateColumn\n'), ((273, 365), 'django_tables2.TemplateColumn', 'Template... |
# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"tensorflow.compat.v2.TensorShape",
"keras.engine.input_spec.InputSpec",
"tensorflow.python.util.tf_export.keras_export",
"keras.backend.repeat_elements"
] | [((959, 1000), 'tensorflow.python.util.tf_export.keras_export', 'keras_export', (['"""keras.layers.UpSampling1D"""'], {}), "('keras.layers.UpSampling1D')\n", (971, 1000), False, 'from tensorflow.python.util.tf_export import keras_export\n'), ((1966, 1983), 'keras.engine.input_spec.InputSpec', 'InputSpec', ([], {'ndim':... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Main script for Empty My Fridge project. Provides a CLI for the Spoonacular API.
"""
import requests
from rich.console import Console
import config
def get_missing_ingredients(available_ingredients, amount_recipes):
"""
:param available_ingredients: comma ... | [
"rich.console.Console",
"requests.get",
"rich.table.Table"
] | [((1353, 1446), 'requests.get', 'requests.get', (['"""https://api.spoonacular.com/recipes/findByIngredients/"""'], {'params': 'parameters'}), "('https://api.spoonacular.com/recipes/findByIngredients/',\n params=parameters)\n", (1365, 1446), False, 'import requests\n'), ((2262, 2271), 'rich.console.Console', 'Console... |
import json
from flask import Blueprint
from metrics import availability as avail
from metrics import utils as ut
from elasticsearch.exceptions import ConnectionError
avail_page = Blueprint('availability', __name__)
QUERY_CONTENT = '*'
@avail_page.route('/')
def hello():
return ut.json_response_formatter({'msg'... | [
"metrics.utils.es_rest",
"metrics.utils.json_response_formatter",
"metrics.availability.get_availability_per_bp_and_method",
"flask.Blueprint",
"metrics.utils.get_timestamp_timewindow"
] | [((181, 216), 'flask.Blueprint', 'Blueprint', (['"""availability"""', '__name__'], {}), "('availability', __name__)\n", (190, 216), False, 'from flask import Blueprint\n'), ((287, 352), 'metrics.utils.json_response_formatter', 'ut.json_response_formatter', (['{\'msg\': "I\'m the availability file!"}'], {}), '({\'msg\':... |
#!/usr/bin/env python
from nlputil import *
import fileinput
import re
switch_thresh_and_grid = True
errdists = dictdict()
for line in fileinput.input():
line = line.strip()
m = re.match(r'.*thresh: ([0-9.]*), grid: ([0-9.]*),.*true error distance.*\(([0-9.]*) km.*', line)
if not m:
errprint("Can't parse ... | [
"re.match",
"fileinput.input"
] | [((139, 156), 'fileinput.input', 'fileinput.input', ([], {}), '()\n', (154, 156), False, 'import fileinput\n'), ((186, 291), 're.match', 're.match', (['""".*thresh: ([0-9.]*), grid: ([0-9.]*),.*true error distance.*\\\\(([0-9.]*) km.*"""', 'line'], {}), "(\n '.*thresh: ([0-9.]*), grid: ([0-9.]*),.*true error distanc... |
import sys
import os
import re
import json
import base64
REFERENCE_BRANCH_NAME = 'master'
GRADLE_FILE_PATH = './build.gradle'
GET_GRADLE_COMMAND = f'git show {REFERENCE_BRANCH_NAME} HEAD:{GRADLE_FILE_PATH}'
class Version:
def __init__(self, version_string: str):
parts = version_string.split('.')
if le... | [
"re.findall",
"os.popen"
] | [((1443, 1511), 're.findall', 're.findall', (['"""-*\\\\+*version\\\\s*=*\\\\s*\'\\\\S+\'\\\\n"""', 'build_gradle_content'], {}), '("-*\\\\+*version\\\\s*=*\\\\s*\'\\\\S+\'\\\\n", build_gradle_content)\n', (1453, 1511), False, 'import re\n'), ((1327, 1355), 'os.popen', 'os.popen', (['GET_GRADLE_COMMAND'], {}), '(GET_GR... |
from sklearn.metrics.pairwise import cosine_similarity
import pandas as pd
import numpy as np
cs = cosine_similarity
df=pd.read_csv("df_final.csv")
def get_recommender(user_input):
""" This function produces the 5 top recommendations depending on user_input.
The user_input is the age group and skills selecte... | [
"numpy.array",
"pandas.read_csv"
] | [((121, 148), 'pandas.read_csv', 'pd.read_csv', (['"""df_final.csv"""'], {}), "('df_final.csv')\n", (132, 148), True, 'import pandas as pd\n'), ((619, 639), 'numpy.array', 'np.array', (['all_scores'], {}), '(all_scores)\n', (627, 639), True, 'import numpy as np\n')] |
# -*- coding: utf-8 -*-
#config
import configparser
#sys & os
import sys
import os.path
#set logging
import logging
logging.basicConfig(filename=os.path.join(os.path.dirname(os.path.abspath(sys.argv[0])), 'umr.log'),level=logging.DEBUG)
#Set locale
#FIXME : force French, should be in conf ?
import locale
locale.set... | [
"configparser.ConfigParser",
"logging.info",
"locale.setlocale",
"logging.debug"
] | [((310, 351), 'locale.setlocale', 'locale.setlocale', (['locale.LC_TIME', '"""fr_FR"""'], {}), "(locale.LC_TIME, 'fr_FR')\n", (326, 351), False, 'import locale\n'), ((687, 714), 'logging.info', 'logging.info', (['"""Load config"""'], {}), "('Load config')\n", (699, 714), False, 'import logging\n'), ((733, 760), 'config... |
from django.db import models
from django.conf import settings
from django.urls import reverse
# Create your models here.
class Room(models.Model):
ROOM_CATEGORIES = (
('BZS', 'BUSINESS SUITE'),
('TNS', 'TWIN SUITE'),
('EXS', 'EXECUTIVE SUITE'),
('SGB', 'SINGLE BED'),
)
room_... | [
"django.db.models.FloatField",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.urls.reverse",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((329, 371), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'null': '(True)', 'blank': '(True)'}), '(null=True, blank=True)\n', (348, 371), False, 'from django.db import models\n'), ((387, 442), 'django.db.models.CharField', 'models.CharField', ([], {'choices': 'ROOM_CATEGORIES', 'max_length': '(3)'}), ... |
from HABApp.openhab.connection_handler import http_connection
from ._plugin import on_connect, on_disconnect, setup_plugins
log = http_connection.log
def setup():
from HABApp.runtime import shutdown
# initialize callbacks
http_connection.ON_CONNECTED = on_connect
http_connection.ON_DISCONNECTED = on... | [
"HABApp.runtime.shutdown.register_func",
"HABApp.openhab.connection_handler.http_connection.start_connection"
] | [((375, 470), 'HABApp.runtime.shutdown.register_func', 'shutdown.register_func', (['http_connection.stop_connection'], {'msg': '"""Stopping openHAB connection"""'}), "(http_connection.stop_connection, msg=\n 'Stopping openHAB connection')\n", (397, 470), False, 'from HABApp.runtime import shutdown\n'), ((506, 575), ... |
#Imported to DeOXy
from userbot import bot, BOTLOG_CHATID, ALIVE_NAME, CMD_LIST
import asyncio
from telethon import events
from telethon.tl.functions.channels import EditBannedRequest
from telethon.tl.types import (PeerChat, PeerChannel,ChannelParticipantsAdmins, ChatAdminRights,ChatBannedRights, MessageEntityMentionN... | [
"telethon.tl.functions.contacts.BlockRequest",
"userbot.modules.sql_helper.gmute_sql.gmute",
"telethon.tl.functions.contacts.UnblockRequest",
"userbot.modules.sql_helper.gmute_sql.ungmute"
] | [((2568, 2582), 'userbot.modules.sql_helper.gmute_sql.gmute', 'gmute', (['user.id'], {}), '(user.id)\n', (2573, 2582), False, 'from userbot.modules.sql_helper.gmute_sql import gmute\n'), ((4763, 4779), 'userbot.modules.sql_helper.gmute_sql.ungmute', 'ungmute', (['user.id'], {}), '(user.id)\n', (4770, 4779), False, 'fro... |
import bluetooth
import time
import RPi.GPIO as GPIO
from bt_rssi import BluetoothRSSI
search_time = 10
GPIO.setmode(GPIO.BCM)
GPIO.setup(17, GPIO.OUT)
THRESHOLD = (-13, 38)
# You can hardcode the desired device ID here as a string to skip the discovery stage
addr = "F4:AF:E7:72:CB:19"
b = BluetoothRSSI(addr=addr)
pr... | [
"RPi.GPIO.cleanup",
"bt_rssi.BluetoothRSSI",
"bluetooth.discover_devices",
"RPi.GPIO.setup",
"RPi.GPIO.output",
"time.sleep",
"bluetooth.find_service",
"RPi.GPIO.setmode",
"bluetooth.lookup_name"
] | [((105, 127), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BCM'], {}), '(GPIO.BCM)\n', (117, 127), True, 'import RPi.GPIO as GPIO\n'), ((128, 152), 'RPi.GPIO.setup', 'GPIO.setup', (['(17)', 'GPIO.OUT'], {}), '(17, GPIO.OUT)\n', (138, 152), True, 'import RPi.GPIO as GPIO\n'), ((292, 316), 'bt_rssi.BluetoothRSSI', 'Blueto... |
import clockngpn.totp as totp
from clockngpn.proc_worker import Event, Broker, ProcWorkerEvent
from clockngpn.ttp import TocTocPorts, TocTocPortsWorker
from queue import Queue
import time
import os
import logging
from clockngpn.bidi import OTPBidi
import signal
import argparse
log = logging.getLogger(__name__)
def... | [
"logging.getLogger",
"logging.basicConfig",
"signal.signal",
"argparse.ArgumentParser",
"clockngpn.port_manager.PortManager",
"clockngpn.ttp.TocTocPorts",
"clockngpn.proc_worker.Broker",
"clockngpn.totp.web_secret_2_bytes",
"clockngpn.totp.gen_secret",
"clockng.firewall_manager.FirewallManager",
... | [((287, 314), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (304, 314), False, 'import logging\n'), ((1148, 1155), 'queue.Queue', 'Queue', ([], {}), '()\n', (1153, 1155), False, 'from queue import Queue\n'), ((1165, 1172), 'queue.Queue', 'Queue', ([], {}), '()\n', (1170, 1172), False, 'f... |
"""
CLI for azureml module.
"""
import json
import click
from mlflow.google.aiplatform import register_model as do_register_model
from mlflow.utils import cli_args
from mlflow.utils.annotations import experimental
@click.group("google")
def commands():
"""
Serve models on Google Cloud AI Platform. **These c... | [
"click.group",
"click.option",
"json.loads",
"mlflow.google.aiplatform.register_model"
] | [((219, 240), 'click.group', 'click.group', (['"""google"""'], {}), "('google')\n", (230, 240), False, 'import click\n'), ((722, 846), 'click.option', 'click.option', (['"""--display-name"""', '"""-n"""'], {'required': '(True)', 'help': '"""Name of the model when it\'s registered on Cloud AI Platform"""'}), '(\'--displ... |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
import numpy as np
from music21 import midi
import pypianoroll
from pypianoroll import Multitrack
from texttable import Texttable
import os
from pprint import pprint
def play_midi(input_midi):
'''Takes path ... | [
"numpy.random.choice",
"os.path.join",
"music21.midi.MidiFile",
"music21.midi.translate.midiFileToStream",
"numpy.load",
"os.walk"
] | [((457, 472), 'music21.midi.MidiFile', 'midi.MidiFile', ([], {}), '()\n', (470, 472), False, 'from music21 import midi\n'), ((569, 613), 'music21.midi.translate.midiFileToStream', 'midi.translate.midiFileToStream', (['midi_object'], {}), '(midi_object)\n', (600, 613), False, 'from music21 import midi\n'), ((920, 933), ... |
# *****************************************************************
# Copyright 2013 MIT Lincoln Laboratory
# Project: SPAR
# Authors: SY
# Description: Section class
#
#
# Modifications:
# Date Name Modification
# ---- ---- ... | [
"spar_python.report_generation.common.latex_classes.LatexTable",
"spar_python.report_generation.ta1.ta1_analysis_input.Input",
"spar_python.report_generation.ta1.ta1_analysis_percentiles.Ta1PercentileGetter"
] | [((1833, 1950), 'spar_python.report_generation.common.latex_classes.LatexTable', 'latex_classes.LatexTable', (['caption', '"""perc_main"""', "['DBNR', 'DBRS', 'Select', 'Query Type', 'Num Passing $\\\\%$iles']"], {}), "(caption, 'perc_main', ['DBNR', 'DBRS', 'Select',\n 'Query Type', 'Num Passing $\\\\%$iles'])\n", ... |
#-*- encoding: utf-8 -*-
"""
About : Code to run as a linux daemon service, interface with it via REST POST
"""
__author__ = "<NAME>"
__email__ = "<EMAIL>"
__company__ = ""
__copyright__ = "Copyright (C) 2020 {a}".format(a=__author__)
__credits__ = ""
__license__ = "MIT"
__version__ = 0.03
__lastdate__ = "2020-04-13"... | [
"json.loads",
"uuid.uuid5",
"io.BytesIO",
"time.sleep",
"uuid.uuid4",
"http.server.HTTPServer",
"threading.Thread",
"queue.Queue",
"time.time"
] | [((868, 875), 'queue.Queue', 'Queue', ([], {}), '()\n', (873, 875), False, 'from queue import Queue\n'), ((5733, 5742), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (5740, 5742), False, 'from io import BytesIO\n'), ((5941, 5950), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (5948, 5950), False, 'from io import BytesIO\n'),... |
# Generated by Django 2.1.2 on 2018-11-08 12:48
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('Game', '0004_auto_20181106_1255'),
]
operations = [
migrations.CreateModel(
name='Loan',
... | [
"django.db.models.DateField",
"django.db.models.FloatField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"django.db.models.AutoField"
] | [((1325, 1416), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'django.db.models.deletion.DO_NOTHING', 'to': '"""Game.LoanOffer"""'}), "(on_delete=django.db.models.deletion.DO_NOTHING, to=\n 'Game.LoanOffer')\n", (1342, 1416), False, 'from django.db import migrations, models\n'), ((358, 451),... |
#!/usr/bin/env python
from __future__ import division
import rospy
from std_msgs.msg import String
from hopper_msgs.msg import ServoTelemetry, HexapodTelemetry
from sensor_msgs.msg import BatteryState
def mean(numbers):
return sum(numbers) / max(len(numbers), 1)
SERVO_COUNT = 18
MAX_VOLTAGE = 12.5
MIN_VOLTAGE ... | [
"rospy.Subscriber",
"rospy.init_node",
"sensor_msgs.msg.BatteryState",
"rospy.Duration.from_sec",
"rospy.Time.now",
"rospy.spin",
"rospy.Publisher"
] | [((403, 430), 'rospy.Duration.from_sec', 'rospy.Duration.from_sec', (['(15)'], {}), '(15)\n', (426, 430), False, 'import rospy\n'), ((517, 574), 'rospy.init_node', 'rospy.init_node', (['"""hopper_battery_monitor"""'], {'anonymous': '(True)'}), "('hopper_battery_monitor', anonymous=True)\n", (532, 574), False, 'import r... |
import pytest
from datacube.utils.geometry import box
from datacube_ows.cube_pool import cube
from datacube_ows.ogc_utils import local_solar_date_range
from datacube_ows.ows_configuration import get_config
from datacube_ows.mv_index import MVSelectOpts, mv_search_datasets
def test_full_layer():
cfg = get_config... | [
"pytest.helpers.enclosed_bbox",
"datacube_ows.mv_index.mv_search_datasets",
"datacube.utils.geometry.box",
"datacube_ows.ows_configuration.get_config",
"datacube_ows.cube_pool.cube"
] | [((310, 322), 'datacube_ows.ows_configuration.get_config', 'get_config', ([], {}), '()\n', (320, 322), False, 'from datacube_ows.ows_configuration import get_config\n'), ((693, 705), 'datacube_ows.ows_configuration.get_config', 'get_config', ([], {}), '()\n', (703, 705), False, 'from datacube_ows.ows_configuration impo... |
# coding:utf-8
# @Time : 2019-01-14 15:22
# @Author : 小贰
# @FileName: ansible_sync_hosts.py
# @function: ansible for python 3.x
import json
from collections import namedtuple
from ansible.parsing.dataloader import DataLoader
from ansible.vars.manager import VariableManager
from ansible.inventory.manager import In... | [
"collections.namedtuple",
"ansible.vars.manager.VariableManager",
"ansible.playbook.play.Play",
"json.dumps",
"ansible.inventory.manager.InventoryManager",
"ansible.parsing.dataloader.DataLoader",
"ansible.executor.task_queue_manager.TaskQueueManager"
] | [((1464, 1476), 'ansible.parsing.dataloader.DataLoader', 'DataLoader', ([], {}), '()\n', (1474, 1476), False, 'from ansible.parsing.dataloader import DataLoader\n'), ((1507, 1670), 'collections.namedtuple', 'namedtuple', (['"""Options"""', "['connection', 'module_path', 'forks', 'become', 'become_method',\n 'private... |
# -*- coding:utf-8 -*-
from django.db import models
from alipay import conf
from alipay.models import AliPayBaseModel
from alipay.create_direct_pay_by_user.dpn.signals import alipay_dpn_flagged, alipay_dpn_successful
class AliPayDPN(AliPayBaseModel):
"""
AliPay DPN
"""
gmt_close = models.DateTimeFiel... | [
"django.db.models.DateTimeField",
"django.db.models.CharField",
"alipay.create_direct_pay_by_user.dpn.signals.alipay_dpn_successful.send",
"alipay.create_direct_pay_by_user.dpn.signals.alipay_dpn_flagged.send"
] | [((301, 344), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'blank': '(True)', 'null': '(True)'}), '(blank=True, null=True)\n', (321, 344), False, 'from django.db import models\n'), ((370, 425), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'null': '(True)', 'max_length': ... |
import numpy as np
import pandas as pd
import time
mnist = pd.read_csv("../input/train.csv")
mnist.head()
y_train = mnist.label.values
x_train = mnist.drop('label',axis=1)
x_train = (x_train / 255.0).values
x_train = np.reshape(x_train,(42000,1,28,28))
x_train.shape
from keras.models import Sequential
from keras.l... | [
"keras.backend.set_image_data_format",
"keras.layers.core.Flatten",
"matplotlib.pyplot.grid",
"numpy.reshape",
"pandas.read_csv",
"matplotlib.pyplot.xticks",
"keras.layers.pooling.MaxPooling2D",
"time.strftime",
"numpy.argmax",
"keras.models.Sequential",
"matplotlib.pyplot.figure",
"keras.laye... | [((60, 93), 'pandas.read_csv', 'pd.read_csv', (['"""../input/train.csv"""'], {}), "('../input/train.csv')\n", (71, 93), True, 'import pandas as pd\n'), ((221, 260), 'numpy.reshape', 'np.reshape', (['x_train', '(42000, 1, 28, 28)'], {}), '(x_train, (42000, 1, 28, 28))\n', (231, 260), True, 'import numpy as np\n'), ((531... |
import subprocess
import time
from os import listdir
from os.path import isfile, join
COMMAND = ["python3", "onnx_sender.py",]
DIR = "working"
def get_file_list_from_dir(mypath):
onlyfiles = [join(mypath, f) for f in listdir(mypath) if isfile(join(mypath, f))]
return onlyfiles
file_list = get_file_list_fro... | [
"os.listdir",
"subprocess.run",
"os.path.join"
] | [((621, 652), 'subprocess.run', 'subprocess.run', (['current_command'], {}), '(current_command)\n', (635, 652), False, 'import subprocess\n'), ((199, 214), 'os.path.join', 'join', (['mypath', 'f'], {}), '(mypath, f)\n', (203, 214), False, 'from os.path import isfile, join\n'), ((224, 239), 'os.listdir', 'listdir', (['m... |
import paho.mqtt.client as mqtt
# 當地端程式連線伺服器得到回應時，要做的動作
def on_connect(client, userdata, flags, rc):
print("Connected with result code "+str(rc))
# 將訂閱主題寫在on_connet中
# 如果我們失去連線或重新連線時
# 地端程式將會重新訂閱
client.subscribe("Try/MQTT")
# 當接收到從伺服器發送的訊息時要進行的動作
def on_message(client, userdata, msg):
# 轉換編... | [
"paho.mqtt.client.Client"
] | [((414, 427), 'paho.mqtt.client.Client', 'mqtt.Client', ([], {}), '()\n', (425, 427), True, 'import paho.mqtt.client as mqtt\n')] |
import copy
import pprint
import inspect
from collections import OrderedDict
import six
from neupy.exceptions import LayerConnectionError
__all__ = ('LayerGraph',)
def filter_list(iterable, include_values):
"""
Create new list that contains only values
specified in the ``include_values`` attribute.
... | [
"collections.OrderedDict",
"inspect.ismethod",
"pprint.pformat",
"inspect.getargspec",
"copy.copy"
] | [((1278, 1291), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1289, 1291), False, 'from collections import OrderedDict\n'), ((1895, 1908), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1906, 1908), False, 'from collections import OrderedDict\n'), ((3980, 4012), 'inspect.getargspec', 'inspe... |
# Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applic... | [
"torch.index_select",
"kaolin.nnsearch.nnsearch",
"torch.mul",
"kaolin.cuda.sided_distance.forward_cuda",
"torch.sum",
"kaolin.cuda.sided_distance.forward",
"torch.zeros"
] | [((976, 1001), 'torch.zeros', 'torch.zeros', (['batchsize', 'n'], {}), '(batchsize, n)\n', (987, 1001), False, 'import torch\n'), ((1017, 1059), 'torch.zeros', 'torch.zeros', (['batchsize', 'n'], {'dtype': 'torch.int'}), '(batchsize, n, dtype=torch.int)\n', (1028, 1059), False, 'import torch\n'), ((3854, 3900), 'torch.... |
import argparse
import sys
import torch
from inferno.trainers.basic import Trainer
from inferno.trainers.callbacks.logging.tensorboard import TensorboardLogger
from torch import nn
from torch.autograd import Variable
from torch.utils.data.dataloader import DataLoader
from torch.utils.data.dataset import Dataset
from t... | [
"mnist_wgangp.WGANGeneratorLoss",
"torch.nn.BatchNorm1d",
"torch.cuda.is_available",
"mnist_gan.Reshape",
"mnist_gan.format_images",
"torch.arange",
"mnist_gan.generate_video",
"torch.nn.Sigmoid",
"torch.nn.BatchNorm2d",
"argparse.ArgumentParser",
"torchvision.transforms.ToTensor",
"torch.auto... | [((7509, 7524), 'mnist_gan.save_args', 'save_args', (['args'], {}), '(args)\n', (7518, 7524), False, 'from mnist_gan import save_args, GANModel, GenerateDataCallback, GeneratorTrainingCallback\n'), ((7800, 7814), 'inferno.trainers.basic.Trainer', 'Trainer', (['model'], {}), '(model)\n', (7807, 7814), False, 'from infer... |
#!/usr/bin/env python
# coding:utf8
# Copyright (c) 2018, Tencent. All rights reserved
# This file contain DataProcessor class which can
# 1. Generate dict from train text data:
# Text format: label\t[(token )+]\t[(char )+]\t[(custom_feature )+].
# Label could be flattened or hierarchical which is separat... | [
"config.Config",
"util.Logger",
"tensorflow.TFRecordReader",
"tensorflow.cast",
"tensorflow.app.run",
"os.path.exists",
"tensorflow.train.Example",
"tensorflow.train.Coordinator",
"tensorflow.placeholder",
"json.dumps",
"tensorflow.estimator.export.ServingInputReceiver",
"tensorflow.python_io.... | [((28196, 28227), 'config.Config', 'Config', ([], {'config_file': 'sys.argv[1]'}), '(config_file=sys.argv[1])\n', (28202, 28227), False, 'from config import Config\n'), ((28348, 28360), 'tensorflow.app.run', 'tf.app.run', ([], {}), '()\n', (28358, 28360), True, 'import tensorflow as tf\n'), ((6482, 6532), 'codecs.open'... |
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
text = "This is an example sentence for showing stop words filteration."
stop_words = set(stopwords.words("english"))
# all the stop words of englist language defined in nltk
# print(stop_words)
words = word_tokenize(text)
filtered_sentence ... | [
"nltk.corpus.stopwords.words",
"nltk.tokenize.word_tokenize"
] | [((281, 300), 'nltk.tokenize.word_tokenize', 'word_tokenize', (['text'], {}), '(text)\n', (294, 300), False, 'from nltk.tokenize import word_tokenize\n'), ((166, 192), 'nltk.corpus.stopwords.words', 'stopwords.words', (['"""english"""'], {}), "('english')\n", (181, 192), False, 'from nltk.corpus import stopwords\n')] |
import sys
import subprocess
ex = sys.executable
print(subprocess.run([ex, sys.argv[1], *sys.argv[2:]], capture_output=True).stdout.decode("UTF-8"))
| [
"subprocess.run"
] | [((57, 126), 'subprocess.run', 'subprocess.run', (['[ex, sys.argv[1], *sys.argv[2:]]'], {'capture_output': '(True)'}), '([ex, sys.argv[1], *sys.argv[2:]], capture_output=True)\n', (71, 126), False, 'import subprocess\n')] |
# -*- coding: utf-8 -*-
"""
# 3D Image Data Synthesis.
# Copyright (C) 2021 <NAME>, <NAME>, <NAME>, <NAME>, <NAME>
#
# 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 Liceense at
#
# http://www.apache.... | [
"numpy.clip",
"numpy.sqrt",
"numpy.array",
"scipy.ndimage.gaussian_filter",
"numpy.sin",
"numpy.gradient",
"numpy.arange",
"numpy.repeat",
"numpy.reshape",
"numpy.cross",
"os.path.split",
"numpy.dot",
"numpy.matmul",
"skimage.morphology.ball",
"numpy.maximum",
"pyshtools.SHCoeffs.from_... | [((2455, 2487), 'os.path.join', 'os.path.join', (['save_path', '"""masks"""'], {}), "(save_path, 'masks')\n", (2467, 2487), False, 'import os\n'), ((2580, 2621), 'numpy.random.randint', 'np.random.randint', (['min_radius', 'max_radius'], {}), '(min_radius, max_radius)\n', (2597, 2621), True, 'import numpy as np\n'), ((... |
# -*- coding: utf-8 -*-
from __future__ import division, print_function
__all__ = ["GP"]
try:
from itertools import izip
except ImportError:
izip = zip
import numpy as np
import scipy.optimize as op
from scipy.linalg import cho_factor, cho_solve, LinAlgError
from .utils import multivariate_gaussian_samples... | [
"numpy.diag_indices_from",
"scipy.linalg.cho_solve",
"numpy.atleast_2d",
"numpy.ones_like",
"scipy.linalg.cho_factor",
"scipy.optimize.minimize",
"numpy.log",
"numpy.diag",
"numpy.argsort",
"numpy.dot",
"numpy.isfinite",
"itertools.izip",
"numpy.zeros_like",
"numpy.arange",
"numpy.atleas... | [((2842, 2858), 'numpy.atleast_1d', 'np.atleast_1d', (['t'], {}), '(t)\n', (2855, 2858), True, 'import numpy as np\n'), ((3612, 3628), 'numpy.atleast_1d', 'np.atleast_1d', (['y'], {}), '(y)\n', (3625, 3628), True, 'import numpy as np\n'), ((5344, 5375), 'scipy.linalg.cho_factor', 'cho_factor', (['K'], {'overwrite_a': '... |
from surprise.model_selection import train_test_split
from surprise.model_selection import LeaveOneOut
from surprise import KNNBaseline
from surprise import Dataset, KNNBasic
from surprise import Reader
import heapq
from movies_analyzer.Movies import Movies, RATINGS, LINKS, MOVIES
from movies_recommender.utils import ... | [
"surprise.KNNBaseline",
"pandas.read_csv",
"surprise.model_selection.LeaveOneOut",
"surprise.Dataset.load_from_file",
"surprise.Dataset.load_from_df",
"surprise.model_selection.train_test_split",
"pandas.DataFrame.from_dict",
"movies_recommender.utils.get_popularity_ranking",
"surprise.Reader"
] | [((635, 679), 'pandas.read_csv', 'pd.read_csv', (['(movies.movielens_path / RATINGS)'], {}), '(movies.movielens_path / RATINGS)\n', (646, 679), True, 'import pandas as pd\n'), ((698, 769), 'surprise.Reader', 'Reader', ([], {'line_format': '"""user item rating timestamp"""', 'sep': '""","""', 'skip_lines': '(1)'}), "(li... |
# MIT License
#
# Copyright (c) 2018-2019 Red Hat, Inc.
# 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, m... | [
"packit_service.models.CoprBuild",
"packit.config.JobConfig",
"packit_service.config.ServiceConfig",
"packit.config.PackageConfig",
"ogr.abstract.GitService",
"packit_service.models.SRPMBuild",
"flexmock.flexmock"
] | [((2766, 2823), 'packit.config.PackageConfig', 'PackageConfig', ([], {'jobs': 'jobs', 'downstream_package_name': '"""dummy"""'}), "(jobs=jobs, downstream_package_name='dummy')\n", (2779, 2823), False, 'from packit.config import PackageConfig, JobConfig, JobType, JobConfigTriggerType\n'), ((4589, 4678), 'packit.config.J... |
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If ex... | [
"os.getcwd"
] | [((642, 653), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (651, 653), False, 'import os\n')] |
import unittest
from collections import defaultdict
import numpy as np
import enstat.mean
class Test_mean(unittest.TestCase):
"""
tests
"""
def test_scalar(self):
"""
Basic test of "mean" and "std" using a random sample.
"""
average = enstat.scalar()
averag... | [
"numpy.mean",
"numpy.prod",
"numpy.random.random",
"numpy.logical_not",
"numpy.array",
"collections.defaultdict",
"numpy.std",
"unittest.main"
] | [((5207, 5222), 'unittest.main', 'unittest.main', ([], {}), '()\n', (5220, 5222), False, 'import unittest\n'), ((4084, 4110), 'collections.defaultdict', 'defaultdict', (['enstat.scalar'], {}), '(enstat.scalar)\n', (4095, 4110), False, 'from collections import defaultdict\n'), ((4570, 4596), 'collections.defaultdict', '... |
"""Script for testing selfies against large datasets.
"""
import argparse
import pathlib
import pandas as pd
from rdkit import Chem
from tqdm import tqdm
import selfies as sf
parser = argparse.ArgumentParser()
parser.add_argument("--data_path", type=str, default="version.smi.gz")
parser.add_argument("--col_name", t... | [
"pandas.read_csv",
"argparse.ArgumentParser",
"pathlib.Path",
"tqdm.tqdm.write",
"tqdm.tqdm",
"rdkit.Chem.MolFromSmiles",
"rdkit.Chem.CanonSmiles",
"selfies.decoder",
"selfies.set_semantic_constraints",
"selfies.encoder"
] | [((188, 213), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (211, 213), False, 'import argparse\n'), ((501, 523), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (513, 523), False, 'import pathlib\n'), ((708, 765), 'pandas.read_csv', 'pd.read_csv', (['TEST_SET_PATH'], {'sep... |
from typing import List, Optional # NOQA
import chainer
from chainer import cuda
from chainer import functions
from chainer import links
import numpy # NOQA
class Set2Set(chainer.Chain):
r"""MPNN subsubmodule for readout part.
See: <NAME>+, \
Order Matters: Sequence to sequence for sets. November ... | [
"chainer.functions.transpose",
"chainer.functions.stack",
"chainer.cuda.get_array_module",
"chainer.functions.sum",
"chainer.functions.concat",
"chainer.functions.reshape",
"chainer.functions.softmax",
"chainer.functions.matmul",
"chainer.links.NStepLSTM",
"chainer.functions.separate",
"chainer.... | [((1290, 1314), 'chainer.cuda.get_array_module', 'cuda.get_array_module', (['h'], {}), '(h)\n', (1311, 1314), False, 'from chainer import cuda\n'), ((1727, 1745), 'chainer.functions.stack', 'functions.stack', (['q'], {}), '(q)\n', (1742, 1745), False, 'from chainer import functions\n'), ((1777, 1815), 'chainer.function... |
"""Console script for kanbanflow_prj_selector."""
import sys
import click
from .kanbanflow_prj_selector import start
@click.command()
@click.option('-f', '--board-token-path', help='Input file with board tokens to fetch', required=True)
def main(board_token_path):
"""Console script for kanbanflow_prj_selector.""... | [
"click.option",
"click.command"
] | [((121, 136), 'click.command', 'click.command', ([], {}), '()\n', (134, 136), False, 'import click\n'), ((138, 244), 'click.option', 'click.option', (['"""-f"""', '"""--board-token-path"""'], {'help': '"""Input file with board tokens to fetch"""', 'required': '(True)'}), "('-f', '--board-token-path', help=\n 'Input ... |
#
# Copyright (C) 2014-2015
# <NAME> (<EMAIL>)
#
# This Program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This Program is d... | [
"xbmcaddon.Addon"
] | [((1630, 1652), 'xbmcaddon.Addon', 'xbmcaddon.Addon', (['addon'], {}), '(addon)\n', (1645, 1652), False, 'import xbmcaddon\n'), ((1707, 1724), 'xbmcaddon.Addon', 'xbmcaddon.Addon', ([], {}), '()\n', (1722, 1724), False, 'import xbmcaddon\n')] |
import csv
import os
from os import mkdir
from os.path import isdir
from datetime import datetime
import ast
from configuration import Config
conf = Config()
traj_j = []
policy_per_plot = []
plot_policy = []
traj_j_ID = []
CSV_DIRECTORY_NAME = "Flights_trajectories"
BP_DIRECTORY_NAME = 'Best_policy/'
myfile = "./Bes... | [
"configuration.Config",
"csv.writer",
"os.path.isfile",
"datetime.datetime.now",
"ast.literal_eval",
"os.path.isdir",
"os.mkdir",
"csv.reader"
] | [((150, 158), 'configuration.Config', 'Config', ([], {}), '()\n', (156, 158), False, 'from configuration import Config\n'), ((520, 542), 'os.path.isfile', 'os.path.isfile', (['myfile'], {}), '(myfile)\n', (534, 542), False, 'import os\n'), ((3616, 3643), 'os.path.isfile', 'os.path.isfile', (['myfile_plot'], {}), '(myfi... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from client import Sample_Client
import time
import random
# Create client
client = Sample_Client('sample.cfg')
time.sleep(5)
# Simple exemple
while(True):
print('Sending updates')
client.publish('Sensor1', 'L1_Volts', random.uniform(207,253))
client.publish... | [
"random.uniform",
"client.Sample_Client",
"time.sleep"
] | [((133, 160), 'client.Sample_Client', 'Sample_Client', (['"""sample.cfg"""'], {}), "('sample.cfg')\n", (146, 160), False, 'from client import Sample_Client\n'), ((161, 174), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n', (171, 174), False, 'import time\n'), ((1021, 1035), 'time.sleep', 'time.sleep', (['(60)'], {})... |
# -*- coding:utf-8 -*-
"""
外键关联相关的选项：
- model: 关联的资产Model
- field：关联的字段，这个字段必须是unique，默认可选择id
- on_delete: 当关联的外键删除的时候的操作：cascade | set_null | disable
- on_update: 当关联的外键修改的时候: cascade | disable
这些功能/约束，都是用代码逻辑来实现的，其实尽量不要使用外键：
少用的话，其实可以把约束放到业务代码中
"""
from cmdb.types.base import BaseType
# 注意别循环引用了
from cmdb.models i... | [
"cmdb.models.Field.objects.filter",
"cmdb.models.Model.objects.filter"
] | [((885, 922), 'cmdb.models.Model.objects.filter', 'Model.objects.filter', ([], {'code': 'model_code'}), '(code=model_code)\n', (905, 922), False, 'from cmdb.models import Model, Field, Instance, Value\n'), ((1481, 1531), 'cmdb.models.Field.objects.filter', 'Field.objects.filter', ([], {'model': 'model', 'code': 'field_... |
# !/usr/bin/env python
# -*- coding: utf-8 -*-
import threading
import time
import urllib2
# SELECT "bmember" as type, COUNT(*) AS bmember FROM bmember WHERE isDownPics=0
# UNION ALL SELECT "memberby " as type, COUNT(*) AS memberby FROM memberby
# UNION ALL SELECT "membercontact" as type, C... | [
"urllib2.Request",
"threading.Thread",
"urllib2.urlopen",
"time.sleep"
] | [((729, 769), 'urllib2.Request', 'urllib2.Request', ([], {'url': 'url', 'headers': 'header'}), '(url=url, headers=header)\n', (744, 769), False, 'import urllib2\n'), ((798, 822), 'urllib2.urlopen', 'urllib2.urlopen', (['request'], {}), '(request)\n', (813, 822), False, 'import urllib2\n'), ((1038, 1051), 'time.sleep', ... |
import sys, psycopg2, psycopg2.extras
def generate(user_id, db):
try:
with db.cursor(cursor_factory = psycopg2.extras.DictCursor) as cursor:
cursor.execute("""
INSERT INTO minicloud_auths (user_id) VALUES (%s) RETURNING token
""", [int(user_id)])
data = curs... | [
"sys.stderr.write",
"sys.stderr"
] | [((449, 491), 'sys.stderr', 'sys.stderr', (["('%s\\n' % 'No token generated!')"], {}), "('%s\\n' % 'No token generated!')\n", (459, 491), False, 'import sys, psycopg2, psycopg2.extras\n'), ((778, 820), 'sys.stderr.write', 'sys.stderr.write', (['"""X-Auth-Token revoked\n"""'], {}), "('X-Auth-Token revoked\\n')\n", (794,... |
import graphene
from app.models import User
class RegisterMutation(graphene.Mutation):
class Arguments(object):
email = graphene.String()
username = graphene.String()
password = graphene.String()
is_success = graphene.Boolean()
message = graphene.String()
@staticmethod
... | [
"graphene.String",
"app.models.User",
"graphene.Boolean"
] | [((247, 265), 'graphene.Boolean', 'graphene.Boolean', ([], {}), '()\n', (263, 265), False, 'import graphene\n'), ((280, 297), 'graphene.String', 'graphene.String', ([], {}), '()\n', (295, 297), False, 'import graphene\n'), ((137, 154), 'graphene.String', 'graphene.String', ([], {}), '()\n', (152, 154), False, 'import g... |
from init_repo import init_repo
def find_commit(repo, local_repo, version, branch='master'):
"""
Find commit with specified version in the DESCRIPTION file in the xcms repo
This function checkout to specified version
:param repo: git.repo.base.Repo - repository object
:param local_repo: str - path... | [
"init_repo.init_repo"
] | [((1601, 1669), 'init_repo.init_repo', 'init_repo', ([], {'repo_clone_url': 'repo_clone_url', 'path': 'path', 'version': 'version'}), '(repo_clone_url=repo_clone_url, path=path, version=version)\n', (1610, 1669), False, 'from init_repo import init_repo\n')] |
"""Author: <NAME>, Copyright 2019"""
import numpy as np
import mineral as ml
from mineral.core.samplers.sampler import Sampler
class PathSampler(Sampler):
def __init__(
self,
env,
policies,
buffers,
time_skips=(1,),
**kwargs
):
Sampl... | [
"numpy.prod",
"mineral.core.samplers.sampler.Sampler.__init__",
"mineral.nested_apply"
] | [((315, 347), 'mineral.core.samplers.sampler.Sampler.__init__', 'Sampler.__init__', (['self'], {}), '(self, **kwargs)\n', (331, 347), False, 'from mineral.core.samplers.sampler import Sampler\n'), ((1194, 1230), 'numpy.prod', 'np.prod', (['self.time_skips[:level + 1]'], {}), '(self.time_skips[:level + 1])\n', (1201, 12... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2017-03-19 18:41
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('references', '0054_auto_20170308_2100'),
]
operations = [
migrations.Create... | [
"django.db.models.DateTimeField",
"django.db.models.AutoField",
"django.db.models.CharField"
] | [((403, 496), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (419, 496), False, 'from django.db import migrations, models\... |
from importlib import import_module
from django.db import models
from django.db.models.signals import post_save
from django.utils.translation import gettext_lazy as _
from django.utils.module_loading import import_string
from django.conf import settings
from django_otp import devices_for_user
from .services import Us... | [
"importlib.import_module",
"django_otp.devices_for_user",
"django.db.models.signals.post_save.connect",
"django.utils.translation.gettext_lazy",
"django.utils.module_loading.import_string"
] | [((4009, 4094), 'django.db.models.signals.post_save.connect', 'post_save.connect', (['UserServicesMixin._post_save'], {'sender': 'settings.AUTH_USER_MODEL'}), '(UserServicesMixin._post_save, sender=settings.AUTH_USER_MODEL\n )\n', (4026, 4094), False, 'from django.db.models.signals import post_save\n'), ((4090, 4177... |
from __future__ import unicode_literals
import unittest
from mock import Mock
from mopidy.models import Ref
from mopidy_oe1.library import OE1LibraryProvider, OE1LibraryUri, OE1UriType
class OE1LibraryUriTest(unittest.TestCase):
def test_parse_root_uri(self):
uri = 'oe1:directory'
result = OE1... | [
"mock.Mock",
"mopidy_oe1.library.OE1LibraryUri",
"mopidy_oe1.library.OE1LibraryProvider",
"mopidy_oe1.library.OE1LibraryUri.parse"
] | [((317, 341), 'mopidy_oe1.library.OE1LibraryUri.parse', 'OE1LibraryUri.parse', (['uri'], {}), '(uri)\n', (336, 341), False, 'from mopidy_oe1.library import OE1LibraryProvider, OE1LibraryUri, OE1UriType\n'), ((479, 503), 'mopidy_oe1.library.OE1LibraryUri.parse', 'OE1LibraryUri.parse', (['uri'], {}), '(uri)\n', (498, 503... |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
"""Integrate two files known as 'packages.xml'.
Usage:
python combine_packages_xml.py FPATH_1 FPATH_2 >result.xml
Description:
The script reads FPATH_1 and updates the data with FPATH_2.
Entries are sorted by 'version+language'. The file timestamp
is set... | [
"datetime.datetime.fromtimestamp",
"re.compile",
"sys.exit",
"codecs.open",
"time.time"
] | [((964, 1005), 'datetime.datetime.fromtimestamp', 'datetime.datetime.fromtimestamp', (['unixtime'], {}), '(unixtime)\n', (995, 1005), False, 'import datetime\n'), ((6808, 7021), 're.compile', 're.compile', (['"""\n <languagepack\n \\\\s+\n version="(?P<version>\\\\d+\\\\.\\\\d+\\\\.\\\\d+)"\n \\\\s+\n languag... |