code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import time
import matplotlib.pyplot as plt
from joblib import dump, load
from sklearn.model_selection import *
# A custom-made library for reporting
from my_eval_functions import set_seeds, get_clf_eval, dingdong, printtimer
# Written by <NAME>, MD. Dec 2021.
##### BEGIN
print('Loading dataframe, base, and ensemble c... | [
"my_eval_functions.printtimer",
"my_eval_functions.dingdong",
"my_eval_functions.set_seeds",
"time.time",
"joblib.load"
] | [((370, 384), 'my_eval_functions.set_seeds', 'set_seeds', (['(123)'], {}), '(123)\n', (379, 384), False, 'from my_eval_functions import set_seeds, get_clf_eval, dingdong, printtimer\n'), ((408, 431), 'joblib.load', 'load', (['"""df_final.joblib"""'], {}), "('df_final.joblib')\n", (412, 431), False, 'from joblib import ... |
import requests
url = 'http://source.darkarmy.xyz/'
r = requests.get(url, headers={
'user-agent': '9e9',
})
print(r.text)
# darkCTF{changeing_http_user_agent_is_easy} | [
"requests.get"
] | [((58, 106), 'requests.get', 'requests.get', (['url'], {'headers': "{'user-agent': '9e9'}"}), "(url, headers={'user-agent': '9e9'})\n", (70, 106), False, 'import requests\n')] |
import csv
import os
import logging
import argparse
import random
import collections
import operator
from tqdm import tqdm, trange
import numpy as np
import torch
from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler
from torch.utils.data.distributed import DistributedSampler
from p... | [
"numpy.sum",
"argparse.ArgumentParser",
"numpy.random.seed",
"numpy.argmax",
"csv.reader",
"torch.utils.data.RandomSampler",
"pytorch_pretrained_bert.optimization.BertAdam",
"pytorch_pretrained_bert.tokenization.BertTokenizer.from_pretrained",
"seaborn.heatmap",
"torch.cat",
"torch.cuda.device_c... | [((535, 570), 'seaborn.set_context', 'seaborn.set_context', ([], {'context': '"""talk"""'}), "(context='talk')\n", (554, 570), False, 'import seaborn\n'), ((572, 715), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s - %(levelname)s - %(name)s - %(message)s"""', 'datefmt': '"""%m/%d/%Y %H... |
from typing import Any, Dict, List
from mypy_extensions import TypedDict
from typing_extensions import Protocol
ActionPayload = List[Dict[str, Any]]
ActionPayloadWithLabel = TypedDict(
"ActionPayloadWithLabel", {"action": str, "data": ActionPayload}
)
Payload = List[ActionPayloadWithLabel]
ActionResult = TypedDi... | [
"mypy_extensions.TypedDict"
] | [((176, 251), 'mypy_extensions.TypedDict', 'TypedDict', (['"""ActionPayloadWithLabel"""', "{'action': str, 'data': ActionPayload}"], {}), "('ActionPayloadWithLabel', {'action': str, 'data': ActionPayload})\n", (185, 251), False, 'from mypy_extensions import TypedDict\n'), ((313, 373), 'mypy_extensions.TypedDict', 'Type... |
import numpy as np
import os
import re
import cPickle
class read_cifar10(object):
def __init__(self, data_path=None, is_training=True):
self.data_path = data_path
self.is_training = is_training
def load_data(self):
files = os.listdir(self.data_path)
if self.is_training is True:
pattern = ... | [
"cPickle.load",
"numpy.hstack",
"os.listdir",
"numpy.vstack",
"re.compile"
] | [((243, 269), 'os.listdir', 'os.listdir', (['self.data_path'], {}), '(self.data_path)\n', (253, 269), False, 'import os\n'), ((320, 348), 're.compile', 're.compile', (['"""(data_batch_)."""'], {}), "('(data_batch_).')\n", (330, 348), False, 'import re\n'), ((655, 670), 'numpy.vstack', 'np.vstack', (['data'], {}), '(dat... |
# Generated by Django 2.1.4 on 2019-01-25 12:49
import datetime
import django.contrib.postgres.fields.jsonb
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('assessment', '0007_answer_is_correct_choice'),
]
operations = [
migrations.Remov... | [
"django.db.migrations.RemoveField",
"django.db.models.CharField",
"datetime.date",
"django.db.models.BooleanField",
"django.db.models.DecimalField"
] | [((304, 373), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""question"""', 'name': '"""correct_choices"""'}), "(model_name='question', name='correct_choices')\n", (326, 373), False, 'from django.db import migrations, models\n'), ((526, 560), 'django.db.models.BooleanField', 'model... |
"""API views for social_network."""
from rest_framework import viewsets
from rest_framework.decorators import api_view, detail_route
from rest_framework.response import Response
from rest_framework.reverse import reverse
from .models import Profile, Post, Vote
from .serializers import ProfileSerializer, PostSerialize... | [
"rest_framework.reverse.reverse",
"rest_framework.decorators.api_view",
"rest_framework.response.Response",
"rest_framework.decorators.detail_route"
] | [((325, 342), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (333, 342), False, 'from rest_framework.decorators import api_view, detail_route\n'), ((1327, 1384), 'rest_framework.decorators.detail_route', 'detail_route', ([], {'methods': "['POST', 'DELETE']", 'url_path': '"""vote"""'... |
from .Dataset import Dataset
from pathlib import Path
def check_multi(folder):
pathlist = Path(folder).glob('**/*.nc')
for path in pathlist:
outfile = Path(str(path).replace(".nc", ".check"))
try:
with Dataset(path) as i_data:
i_data.uc2_check()
i_... | [
"pathlib.Path"
] | [((96, 108), 'pathlib.Path', 'Path', (['folder'], {}), '(folder)\n', (100, 108), False, 'from pathlib import Path\n')] |
import ast
from collections import OrderedDict
from .codegen import to_source
from .function_compiler_ast import timeshift, StandardizeDatesSimple
from dolo.compiler.recipes import recipes
from numba import njit
class NumericModel:
calibration = None
calibration_dict = None
covariances = None
markov_c... | [
"dolo.compiler.function_compiler_ast.compile_function_ast",
"dolo.algos.dtmscc.steady_state.residuals",
"dolo.misc.termcolor.colored",
"dolo.compiler.eval_formula.eval_formula",
"dolo.compiler.misc.calibration_to_vector",
"dolo.compiler.triangular_solver.solve_triangular_system",
"numpy.array",
"dolo.... | [((11083, 11113), 're.compile', 're.compile', (['"""(.*)<=(.*)<=(.*)"""'], {}), "('(.*)<=(.*)<=(.*)')\n", (11093, 11113), False, 'import re\n'), ((1256, 1287), 'dolo.compiler.triangular_solver.solve_triangular_system', 'solve_triangular_system', (['system'], {}), '(system)\n', (1279, 1287), False, 'from dolo.compiler.t... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""Tests for the file system implementation using gzip."""
import os
import unittest
from dfvfs.path import gzip_path_spec
from dfvfs.path import os_path_spec
from dfvfs.resolver import context
from dfvfs.vfs import gzip_file_system
class GzipFileSystemTest(unittest.TestCas... | [
"unittest.main",
"dfvfs.resolver.context.Context",
"dfvfs.path.os_path_spec.OSPathSpec",
"dfvfs.vfs.gzip_file_system.GzipFileSystem",
"dfvfs.path.gzip_path_spec.GzipPathSpec",
"os.path.join"
] | [((2286, 2301), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2299, 2301), False, 'import unittest\n'), ((491, 508), 'dfvfs.resolver.context.Context', 'context.Context', ([], {}), '()\n', (506, 508), False, 'from dfvfs.resolver import context\n'), ((525, 565), 'os.path.join', 'os.path.join', (['u"""test_data"""'... |
#!/usr/bin/env python3
import ta_vision
from vision.camera import Camera
from color_detection import ColorDetection
import cv2 as cv
import rospy
import time
import math
from geometry_msgs.msg import PointStamped
from gazebo_msgs.msg import ModelStates
from gazebo_msgs.srv import SetModelState
from gazebo_msgs.msg i... | [
"rospy.Subscriber",
"rospy.ServiceProxy",
"rospy.Time",
"gazebo_msgs.msg.ModelState",
"cv2.imshow",
"rospy.Time.now",
"rospy.Rate",
"rospy.is_shutdown",
"rospy.init_node",
"math.cos",
"cv2.destroyAllWindows",
"geometry_msgs.msg.Pose",
"cv2.circle",
"csv.writer",
"cv2.waitKey",
"math.si... | [((845, 864), 'csv.writer', 'csv.writer', (['cam_csv'], {}), '(cam_csv)\n', (855, 864), False, 'import csv\n'), ((879, 899), 'csv.writer', 'csv.writer', (['real_csv'], {}), '(real_csv)\n', (889, 899), False, 'import csv\n'), ((1091, 1104), 'rospy.Time', 'rospy.Time', (['(0)'], {}), '(0)\n', (1101, 1104), False, 'import... |
from turtle import Turtle, Screen
my_turtle = Turtle()
screen = Screen()
my_turtle.shape('arrow')
def forward():
my_turtle.forward(10)
def backward():
my_turtle.back(10)
def right():
my_turtle.right(10)
def left():
my_turtle.left(10)
def clear_screen():
my_turtle.penup()
my_turtle.home... | [
"turtle.Screen",
"turtle.Turtle"
] | [((47, 55), 'turtle.Turtle', 'Turtle', ([], {}), '()\n', (53, 55), False, 'from turtle import Turtle, Screen\n'), ((65, 73), 'turtle.Screen', 'Screen', ([], {}), '()\n', (71, 73), False, 'from turtle import Turtle, Screen\n')] |
"""
`pytest <https://docs.pytest.org/en/latest/>`_ client library integration.
Implements some utilities for mocking out ``xjsonrpc`` library clients.
"""
import asyncio
import collections
import functools as ft
import json
import unittest.mock
from typing import Any, Callable, Dict, Optional, Union
import pytest
im... | [
"functools.partial",
"xjsonrpc.BatchResponse",
"json.loads",
"xjsonrpc.Response",
"asyncio.iscoroutinefunction",
"xjsonrpc.Request.from_json",
"collections.defaultdict",
"xjsonrpc.exc.MethodNotFoundError",
"xjsonrpc.BatchRequest.from_json"
] | [((8518, 8605), 'functools.partial', 'ft.partial', (['PjRpcMocker'], {'target': '"""xjsonrpc.client.backend.requests.Client._request"""'}), "(PjRpcMocker, target=\n 'xjsonrpc.client.backend.requests.Client._request')\n", (8528, 8605), True, 'import functools as ft\n'), ((8622, 8708), 'functools.partial', 'ft.partial... |
# load in data
import helper
import numpy as np
import torch
import torch.nn as nn
from string import punctuation
from collections import Counter
from torch.utils.data import TensorDataset, DataLoader
data_dir = './data/Seinfeld_Scripts.txt'
text = helper.load_data(data_dir)
# Check for a GPU
train_on_gpu = torch.cu... | [
"torch.nn.Dropout",
"torch.nn.Embedding",
"numpy.full",
"torch.utils.data.DataLoader",
"helper.save_model",
"helper.load_preprocess",
"torch.nn.Linear",
"collections.Counter",
"torch.nn.LSTM",
"numpy.average",
"numpy.roll",
"torch.cuda.is_available",
"torch.from_numpy",
"helper.load_data",... | [((251, 277), 'helper.load_data', 'helper.load_data', (['data_dir'], {}), '(data_dir)\n', (267, 277), False, 'import helper\n'), ((312, 337), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (335, 337), False, 'import torch\n'), ((1432, 1509), 'helper.preprocess_and_save_data', 'helper.preprocess... |
import rospy
import service_utils as su
from nao_interaction_msgs.srv import BehaviorManagerControl, BehaviorManagerControlRequest
from nao_interaction_msgs.srv import BehaviorManagerInfo, BehaviorManagerInfoRequest
def start_behaviour(name):
su.call_service(
"/naoqi_driver/behaviour_manager/start_behavio... | [
"nao_interaction_msgs.srv.BehaviorManagerControlRequest",
"rospy.is_shutdown",
"nao_interaction_msgs.srv.BehaviorManagerInfoRequest",
"rospy.sleep"
] | [((365, 405), 'nao_interaction_msgs.srv.BehaviorManagerControlRequest', 'BehaviorManagerControlRequest', ([], {'name': 'name'}), '(name=name)\n', (394, 405), False, 'from nao_interaction_msgs.srv import BehaviorManagerControl, BehaviorManagerControlRequest\n'), ((559, 599), 'nao_interaction_msgs.srv.BehaviorManagerCont... |
# -*- coding: utf-8 -*-
"""Next-Word Prediction using Universal Sentence Encoder.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1r2ma5P7w2LE30L1o5mAyNPLE7Qi3JxoL
# **Google drive for local storage**
_NB: All comments are written to facilitate s... | [
"tensorflow_hub.load",
"numpy.save",
"numpy.argmax",
"gdown.download",
"sklearn.model_selection.train_test_split",
"keras.callbacks.LambdaCallback",
"keras.layers.Dense",
"numpy.array",
"google.colab.drive.mount",
"keras.models.Sequential"
] | [((690, 712), 'google.colab.drive.mount', 'drive.mount', (['"""/gdrive"""'], {}), "('/gdrive')\n", (701, 712), False, 'from google.colab import drive\n'), ((1704, 1744), 'gdown.download', 'gdown.download', (['url', 'output'], {'quiet': '(False)'}), '(url, output, quiet=False)\n', (1718, 1744), False, 'import gdown\n'),... |
# Copyright (c) 2020 PaddlePaddle 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 appl... | [
"paddle2onnx.graph.graph_helper.append_fetch_ops",
"paddle.fluid.layers.utils.pack_sequence_as",
"paddle.fluid.dygraph.dygraph_to_static.program_translator.ProgramTranslator",
"paddle.fluid.io._get_valid_program",
"paddle.fluid.core.save_op_version_info",
"paddle.fluid.dygraph.jit.declarative",
"paddle.... | [((3606, 3619), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (3617, 3619), False, 'from collections import OrderedDict\n'), ((3635, 3651), 'paddle.fluid.layers.utils.flatten', 'flatten', (['outputs'], {}), '(outputs)\n', (3642, 3651), False, 'from paddle.fluid.layers.utils import flatten, pack_sequence_a... |
import requests
import ujson
# from b2b_app.config import CONFIG
class Hubspot:
def __init__(self, hub_id, refresh_token):
self.hub_id = hub_id
self.refresh_token = refresh_token
self.access_token = self.get_access_token(refresh_token)
self._lists_url = 'https://api.hubapi.com/conta... | [
"ujson.dumps",
"requests.request"
] | [((1166, 1214), 'requests.request', 'requests.request', (['"""GET"""', 'url'], {'params': 'querystring'}), "('GET', url, params=querystring)\n", (1182, 1214), False, 'import requests\n'), ((1766, 1814), 'requests.request', 'requests.request', (['"""GET"""', 'url'], {'params': 'querystring'}), "('GET', url, params=query... |
import os
from .. import FileBuilder
from .file_builder_test import FileBuilderTest
class LambdaTest(FileBuilderTest):
"""Tests that ``FileBuilder`` methods accept lambda arguments.
Tests that ``FileBuilder`` methods accept lambdas for arguments that
must be callables.
"""
def _build_file(self,... | [
"os.path.join",
"os.listdir"
] | [((566, 599), 'os.path.join', 'os.path.join', (['dir_', '"""Output1.txt"""'], {}), "(dir_, 'Output1.txt')\n", (578, 599), False, 'import os\n'), ((673, 706), 'os.path.join', 'os.path.join', (['dir_', '"""Output2.txt"""'], {}), "(dir_, 'Output2.txt')\n", (685, 706), False, 'import os\n'), ((938, 974), 'os.path.join', 'o... |
#!/usr/bin/env python
# coding: utf-8
def scrape():
import pandas as pd
from splinter import Browser
from bs4 import BeautifulSoup
import time
#dictionary with all data
mars_data={}
executable_path = {'executable_path': 'chromedriver.exe'}
browser = Browser('chrome', **executable... | [
"bs4.BeautifulSoup",
"splinter.Browser",
"pandas.read_html",
"time.sleep"
] | [((290, 402), 'splinter.Browser', 'Browser', (['"""chrome"""'], {'headless': '(True)', 'user_agent': '"""Mozilla/5.0 (Windows NT 10.0; Win64; x64)"""'}), "('chrome', **executable_path, headless=True, user_agent=\n 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)')\n", (297, 402), False, 'from splinter import Browser\n'), ... |
from mpkg.common import Soft
from mpkg.utils import Search
class Package(Soft):
ID = 'python'
def _prepare(self):
data = self.data
links = {'32bit': 'https://www.python.org/ftp/python/{ver}/python-{ver}.exe',
'64bit': 'https://www.python.org/ftp/python/{ver}/python-{ver}-amd6... | [
"mpkg.utils.Search"
] | [((387, 430), 'mpkg.utils.Search', 'Search', (['url', '"""Latest: .*Python ([\\\\d\\\\.]+)"""'], {}), "(url, 'Latest: .*Python ([\\\\d\\\\.]+)')\n", (393, 430), False, 'from mpkg.utils import Search\n'), ((556, 589), 'mpkg.utils.Search', 'Search', ([], {'links': 'links', 'ver': 'data.ver'}), '(links=links, ver=data.ver... |
# Copyright 2014 eNovance
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, so... | [
"keystoneauth1.loading.get_auth_plugin_conf_options",
"keystoneauth1.loading.get_auth_common_conf_options",
"socket.gethostname",
"itertools.chain",
"oslo_config.cfg.IntOpt"
] | [((2378, 2500), 'oslo_config.cfg.IntOpt', 'cfg.IntOpt', (['"""http_timeout"""'], {'default': '(600)', 'help': '"""Timeout seconds for HTTP requests. Set it to None to disable timeout."""'}), "('http_timeout', default=600, help=\n 'Timeout seconds for HTTP requests. Set it to None to disable timeout.')\n", (2388, 250... |
# -*- coding: utf-8 -*-
import json
import os
import random
from shutil import copyfile
from flask import url_for, current_app as app
from flask_login import UserMixin
from sqlalchemy import func, desc
# from vktrainer import db, app, login_manager
from vktrainer import db, login_manager
from vktrainer.utils import... | [
"vktrainer.db.ForeignKey",
"random.randint",
"vktrainer.db.session.add",
"json.loads",
"vktrainer.db.backref",
"vktrainer.db.relation",
"vktrainer.utils.get_md5",
"flask.url_for",
"vktrainer.db.Column",
"os.path.splitext",
"vktrainer.db.session.commit",
"shutil.copyfile",
"sqlalchemy.func.co... | [((563, 602), 'vktrainer.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (572, 602), False, 'from vktrainer import db, login_manager\n'), ((1122, 1161), 'vktrainer.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=Tr... |
import argparse
import os
from scipy.special import erf
from scipy.stats import truncnorm
import numpy as np
import data
def build_vector_cache(glove_filename, vec_cache_filename, vocab):
print("Building vector cache...")
with open(glove_filename) as f, open(vec_cache_filename, "w") as f2:
for line i... | [
"numpy.sum",
"data.Configs.base_config",
"numpy.ceil",
"scipy.stats.truncnorm",
"numpy.floor",
"numpy.zeros",
"data.Configs.sick_config",
"os.path.dirname",
"numpy.arange",
"numpy.exp",
"numpy.sign",
"os.path.join",
"numpy.sqrt"
] | [((952, 978), 'numpy.sign', 'np.sign', (['(tgt_loc - (b - a))'], {}), '(tgt_loc - (b - a))\n', (959, 978), True, 'import numpy as np\n'), ((1065, 1128), 'scipy.stats.truncnorm', 'truncnorm', (['((a - x) / sigma)', '((b - x) / sigma)'], {'loc': 'x', 'scale': 'sigma'}), '((a - x) / sigma, (b - x) / sigma, loc=x, scale=si... |
import pandas as pd
import matplotlib.pyplot as plt
from tqdm import tqdm
import numpy as np
pipelines = pd.read_csv('OntoGasGrid/pipeline_owl_generator/pipeline_split.csv').to_numpy()
offtakes = pd.read_csv('OntoGasGrid/grid_component_owl_generator/grid_component_data.csv').to_numpy()
n_offt = len(offtakes[:,0... | [
"pandas.read_csv",
"numpy.zeros",
"pandas.DataFrame",
"numpy.sqrt"
] | [((373, 408), 'numpy.zeros', 'np.zeros', (['(n_offt, 2)'], {'dtype': 'object'}), '((n_offt, 2), dtype=object)\n', (381, 408), True, 'import numpy as np\n'), ((110, 178), 'pandas.read_csv', 'pd.read_csv', (['"""OntoGasGrid/pipeline_owl_generator/pipeline_split.csv"""'], {}), "('OntoGasGrid/pipeline_owl_generator/pipelin... |
import logging
import time
import os
import subprocess as sp
from governor.etcd import Client as Etcd
from governor.postgresql import Postgresql
from governor.ha import Ha
import etcd
class Governor:
INIT_SCRIPT_DIR = '/docker-entrypoint-initdb.d'
def __init__(self, config, psql_config):
self.advert... | [
"logging.error",
"governor.etcd.Client",
"os.path.isdir",
"logging.warn",
"governor.ha.Ha",
"time.sleep",
"governor.postgresql.Postgresql",
"logging.info",
"os.path.isfile",
"subprocess.call",
"os.path.join",
"os.listdir"
] | [((451, 482), 'governor.postgresql.Postgresql', 'Postgresql', (['config', 'psql_config'], {}), '(config, psql_config)\n', (461, 482), False, 'from governor.postgresql import Postgresql\n'), ((501, 525), 'governor.ha.Ha', 'Ha', (['self.psql', 'self.etcd'], {}), '(self.psql, self.etcd)\n', (503, 525), False, 'from govern... |
#!/usr/bin/env python3
import random
import unittest
import networkit as nk
class TestMatchingAlgorithms(unittest.TestCase):
def generateRandomWeights(self, g):
if not g.isWeighted():
g = nk.graphtools.toWeighted(g)
for e in g.iterEdges():
g.setWeight(e[0], e[1], random.random())
return g
def setUp(s... | [
"unittest.main",
"networkit.graphtools.sortEdgesByWeight",
"networkit.matching.PathGrowingMatcher",
"random.random",
"networkit.graphtools.toWeighted",
"networkit.readGraph",
"networkit.matching.SuitorMatcher"
] | [((1312, 1327), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1325, 1327), False, 'import unittest\n'), ((337, 395), 'networkit.readGraph', 'nk.readGraph', (['"""input/PGPgiantcompo.graph"""', 'nk.Format.METIS'], {}), "('input/PGPgiantcompo.graph', nk.Format.METIS)\n", (349, 395), True, 'import networkit as nk\n... |
#The heart of the bot.
#--------- Libaries ---------#
import discord, os, settings
from tools.logging import ABLog
from discord.ext import commands
#--------- Variables ---------#
INTENTS = discord.Intents.all()
client = commands.Bot(command_prefix = settings.ABPrefixes, intents = INTENTS, help_command=None)
client... | [
"discord.Activity",
"tools.logging.ABLog",
"discord.ext.commands.Bot",
"os.listdir",
"discord.Intents.all"
] | [((194, 215), 'discord.Intents.all', 'discord.Intents.all', ([], {}), '()\n', (213, 215), False, 'import discord, os, settings\n'), ((225, 313), 'discord.ext.commands.Bot', 'commands.Bot', ([], {'command_prefix': 'settings.ABPrefixes', 'intents': 'INTENTS', 'help_command': 'None'}), '(command_prefix=settings.ABPrefixes... |
# -*- coding: utf-8 -*-
from frontera.contrib.backends.remote.codecs.json import Encoder as JsonEncoder, Decoder as JsonDecoder
from frontera.contrib.backends.remote.codecs.msgpack import Encoder as MsgPackEncoder, Decoder as MsgPackDecoder
from frontera.core.models import Request, Response
import pytest
@pytest.mar... | [
"frontera.core.models.Request",
"pytest.mark.parametrize",
"frontera.core.models.Response"
] | [((310, 425), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["('encoder', 'decoder')", '[(MsgPackEncoder, MsgPackDecoder), (JsonEncoder, JsonDecoder)]'], {}), "(('encoder', 'decoder'), [(MsgPackEncoder,\n MsgPackDecoder), (JsonEncoder, JsonDecoder)])\n", (333, 425), False, 'import pytest\n'), ((706, 800), '... |
import keras
'''
Helper methods and variables for mnist models and manifolds
'''
color_list = [
"red",
"orange",
"yellow",
"lime",
"green",
"cyan",
"blue",
"purple",
"fuchsia",
"peru",
]
# # Returns 4D np array (1, HEIGHT, WIDTH, 1)
# def tensor_to_numpy(t):
# sess = K.g... | [
"keras.layers.Input",
"keras.models.Model"
] | [((575, 638), 'keras.layers.Input', 'keras.layers.Input', ([], {'batch_shape': 'seq_model.layers[0].input_shape'}), '(batch_shape=seq_model.layers[0].input_shape)\n', (593, 638), False, 'import keras\n'), ((792, 839), 'keras.models.Model', 'keras.models.Model', (['[input_layer]', '[prev_layer]'], {}), '([input_layer], ... |
# package imports
import dash
import dash_bootstrap_components as dbc
import dash_html_components as html
import dash_core_components as dcc
from dash.dependencies import Input, Output, State
from dash import no_update
from flask import session
# local imports
from auth import authenticate_user, validate_login_session... | [
"dash_html_components.H6",
"dash_bootstrap_components.Input",
"auth.authenticate_user",
"dash_html_components.Br",
"dash_core_components.Location",
"server.ui.run",
"dash_bootstrap_components.ModalBody",
"dash_html_components.Div",
"dash_bootstrap_components.Alert",
"dash.dependencies.State",
"d... | [((3416, 3450), 'dash.dependencies.Output', 'Output', (['"""page-content"""', '"""children"""'], {}), "('page-content', 'children')\n", (3422, 3450), False, 'from dash.dependencies import Input, Output, State\n'), ((4363, 4393), 'auth.authenticate_user', 'authenticate_user', (['credentials'], {}), '(credentials)\n', (4... |
from random import shuffle
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import load_iris
import numpy as np
iris = load_iris()
print(type(iris), len(iris.data))
def test1():
XY = np.array(zip(iris.data, iris.target))
np.random.shuffl... | [
"sklearn.datasets.load_iris",
"numpy.mean",
"numpy.random.shuffle",
"sklearn.ensemble.RandomForestRegressor"
] | [((192, 203), 'sklearn.datasets.load_iris', 'load_iris', ([], {}), '()\n', (201, 203), False, 'from sklearn.datasets import load_iris\n'), ((304, 325), 'numpy.random.shuffle', 'np.random.shuffle', (['XY'], {}), '(XY)\n', (321, 325), True, 'import numpy as np\n'), ((628, 651), 'sklearn.ensemble.RandomForestRegressor', '... |
# -*- coding:utf-8 -*-
from __future__ import absolute_import
import codecs
from setuptools import setup
with codecs.open('README.rst') as readme_file:
readme = readme_file.read()
with codecs.open('HISTORY.rst') as history_file:
history = history_file.read()
setup(
name='cfn-resource-timeout',
ver... | [
"codecs.open",
"setuptools.setup"
] | [((273, 1214), 'setuptools.setup', 'setup', ([], {'name': '"""cfn-resource-timeout"""', 'version': '"""1.2.0"""', 'description': '"""Wrapper decorators for building CloudFormation custom resources"""', 'long_description': "(readme + '\\n\\n' + history)", 'url': '"""https://github.com/timeoutdigital/cfn-resource-timeout... |
import os
import argparse
import datetime
import numpy as np
from glob import glob
from typing import List, Set, Tuple
"""
Author: <NAME> (<EMAIL>)
Computes character-level Cohen's kappa and percentage
agreement for a set of brat annotated files from two
annotators for a sequence labeling task (e.g. NER).
"""
clas... | [
"numpy.sum",
"os.path.basename",
"numpy.std",
"numpy.zeros",
"datetime.datetime.now",
"numpy.isclose",
"numpy.mean",
"numpy.max",
"numpy.min",
"numpy.arange",
"glob.glob",
"os.path.join",
"doctest.testmod"
] | [((8150, 8166), 'numpy.zeros', 'np.zeros', (['n_docs'], {}), '(n_docs)\n', (8158, 8166), True, 'import numpy as np\n'), ((8180, 8196), 'numpy.zeros', 'np.zeros', (['n_docs'], {}), '(n_docs)\n', (8188, 8196), True, 'import numpy as np\n'), ((11195, 11235), 'numpy.isclose', 'np.isclose', (['kappas[0]', '(0.629)'], {'atol... |
import datetime
import os
import keras
import numpy as np
import pandas as pd
from base_model import BaseModel
from multivariate_container import MultivariateContainer
from typing import Union
class MultivariateLSTM(BaseModel):
def __init__(
self,
container: MultivariateContainer,
... | [
"numpy.stack",
"pandas.DataFrame",
"keras.Model",
"keras.Sequential",
"keras.layers.LSTM",
"numpy.transpose",
"os.system",
"keras.utils.plot_model",
"keras.models.model_from_json",
"keras.layers.Dense",
"numpy.array",
"keras.layers.Input",
"keras.utils.print_summary",
"datetime.datetime.no... | [((1417, 1518), 'keras.layers.Input', 'keras.layers.Input', ([], {'shape': '(self.time_steps, self.num_fea)', 'dtype': '"""float32"""', 'name': '"""input_sequence"""'}), "(shape=(self.time_steps, self.num_fea), dtype='float32',\n name='input_sequence')\n", (1435, 1518), False, 'import keras\n'), ((2002, 2057), 'kera... |
from django.contrib import admin
from .models import Post
from . models import Query
from .models import Solution
# Register your models here.
admin.site.register(Post)
admin.site.register(Query)
# admin.site.register(Services)
# admin.site.register(Contact)
admin.site.register(Solution) | [
"django.contrib.admin.site.register"
] | [((150, 175), 'django.contrib.admin.site.register', 'admin.site.register', (['Post'], {}), '(Post)\n', (169, 175), False, 'from django.contrib import admin\n'), ((177, 203), 'django.contrib.admin.site.register', 'admin.site.register', (['Query'], {}), '(Query)\n', (196, 203), False, 'from django.contrib import admin\n'... |
# ----------------------------------------------------------------------------
# board.py
# Pin definitions
#
# The MIT License (MIT)
# Copyright (c) 2020 <NAME>
# 2020-11-21, v1
# ----------------------------------------------------------------------------
from micropython import const
# Spectrometer (CM12880MA)
TRG ... | [
"micropython.const"
] | [((333, 342), 'micropython.const', 'const', (['(14)'], {}), '(14)\n', (338, 342), False, 'from micropython import const\n'), ((360, 369), 'micropython.const', 'const', (['(15)'], {}), '(15)\n', (365, 369), False, 'from micropython import const\n'), ((387, 396), 'micropython.const', 'const', (['(21)'], {}), '(21)\n', (3... |
from application import app
# Starts the application
if __name__ == "__main__":
app.run() | [
"application.app.run"
] | [((85, 94), 'application.app.run', 'app.run', ([], {}), '()\n', (92, 94), False, 'from application import app\n')] |
import re
import nltk
from string import punctuation
from nltk.tokenize import TweetTokenizer
from nltk.corpus import stopwords
#nltk.download('rslp')
#nltk.download('stopwords')
#nltk.download('punkt')
class PreProcessor(object):
stemmer = nltk.stem.RSLPStemmer()
tokenizer = TweetTokenizer(reduce_len=True,... | [
"nltk.stem.RSLPStemmer",
"nltk.tokenize.TweetTokenizer",
"nltk.corpus.stopwords.words",
"re.sub",
"re.compile"
] | [((249, 272), 'nltk.stem.RSLPStemmer', 'nltk.stem.RSLPStemmer', ([], {}), '()\n', (270, 272), False, 'import nltk\n'), ((289, 341), 'nltk.tokenize.TweetTokenizer', 'TweetTokenizer', ([], {'reduce_len': '(True)', 'preserve_case': '(False)'}), '(reduce_len=True, preserve_case=False)\n', (303, 341), False, 'from nltk.toke... |
import os
from static import SQLITE_DIR_PATH, USE_MYSQL, MYSQL_USERNAME, MYSQL_PASSWORD, MYSQL_HOST, MYSQL_DATABASE_NAME
def db_path_validate():
assert os.path.exists(SQLITE_DIR_PATH), "{path} is not exists.".format(path=SQLITE_DIR_PATH)
if USE_MYSQL:
assert MYSQL_USERNAME is not None, "MYSQL_USERNAME... | [
"os.path.exists"
] | [((158, 189), 'os.path.exists', 'os.path.exists', (['SQLITE_DIR_PATH'], {}), '(SQLITE_DIR_PATH)\n', (172, 189), False, 'import os\n')] |
# Before running, make sure avspeech_train.csv and avspeech_test.csv are in catalog.
# if not, see the requirement.txt
# download and preprocess the data from AVspeech dataset
import sys
sys.path.append("../lib")
import AVHandler as avh
import pandas as pd
import multiprocessing
from multiprocessing import Process
de... | [
"sys.path.append",
"AVHandler.mkdir",
"pandas.read_csv",
"AVHandler.download",
"multiprocessing.Process",
"AVHandler.cut"
] | [((187, 212), 'sys.path.append', 'sys.path.append', (['"""../lib"""'], {}), "('../lib')\n", (202, 212), False, 'import sys\n'), ((1250, 1291), 'pandas.read_csv', 'pd.read_csv', (['"""catalog/avspeech_train.csv"""'], {}), "('catalog/avspeech_train.csv')\n", (1261, 1291), True, 'import pandas as pd\n'), ((1454, 1478), 'A... |
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
df = pd.read_csv('medals_data.csv')
df[['Gold','Silver','Bronze']].plot(kind='bar',stacked=True)
plt.title('India Olympics Medal')
plt.xlabel('Years')
plt.ylabel('Medals')
n = len(df['Games'])
labels = df.Games.str.slice(0,4)
plt.xticks(np.arange... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"pandas.read_csv",
"numpy.arange",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel"
] | [((78, 108), 'pandas.read_csv', 'pd.read_csv', (['"""medals_data.csv"""'], {}), "('medals_data.csv')\n", (89, 108), True, 'import pandas as pd\n'), ((171, 204), 'matplotlib.pyplot.title', 'plt.title', (['"""India Olympics Medal"""'], {}), "('India Olympics Medal')\n", (180, 204), True, 'import matplotlib.pyplot as plt\... |
import requests
import requests
import urllib3
import webbrowser
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
cookies = {
}
headers = {
}
sites_200 = []
sites_403 = []
def printPage(response):
with open('test.html', "w") as output:
badchars = ['\\n', '\\t', 'b\'']... | [
"urllib3.disable_warnings",
"requests.get"
] | [((71, 138), 'urllib3.disable_warnings', 'urllib3.disable_warnings', (['urllib3.exceptions.InsecureRequestWarning'], {}), '(urllib3.exceptions.InsecureRequestWarning)\n', (95, 138), False, 'import urllib3\n'), ((1408, 1478), 'requests.get', 'requests.get', (['page_url'], {'headers': 'headers', 'cookies': 'cookies', 've... |
# set keyboard mode for ios device
#from kivy.config import Config
#Config.set('kivy', 'keyboard_mode', 'dock')
from kivy.lang.builder import Builder
from kivymd.uix.bottomnavigation import MDBottomNavigation
from kivy.clock import Clock
from functools import partial
import SecondScreen
import FirstScreen
import ThirdS... | [
"Mdialog.GraphDialog",
"storage.Storage",
"kivy.properties.StringProperty",
"kivy.lang.builder.Builder.load_string",
"class_mydb.Mydb"
] | [((2063, 2082), 'kivy.properties.StringProperty', 'StringProperty', (['"""0"""'], {}), "('0')\n", (2077, 2082), False, 'from kivy.properties import StringProperty\n'), ((2270, 2297), 'storage.Storage', 'Storage', (['self.user_data_dir'], {}), '(self.user_data_dir)\n', (2277, 2297), False, 'from storage import Storage\n... |
import os
import pickle
import logging
from src.jets.data_ops.DataLoader import DataLoader
from src.jets.data_ops.Dataset import Dataset
import numpy as np
from .io import load_jets_from_pickle
w_vs_qcd = 'w-vs-qcd'
quark_gluon = 'quark-gluon'
DATASETS = {
'w':(w_vs_qcd,'antikt-kt'),
'wp':(w_vs_qcd + '/pileu... | [
"os.makedirs",
"logging.warning",
"os.path.exists",
"src.jets.data_ops.Dataset.Dataset",
"os.path.join",
"src.jets.data_ops.DataLoader.DataLoader"
] | [((854, 883), 'os.path.join', 'os.path.join', (['data_dir', '"""raw"""'], {}), "(data_dir, 'raw')\n", (866, 883), False, 'import os\n'), ((907, 945), 'os.path.join', 'os.path.join', (['data_dir', '"""preprocessed"""'], {}), "(data_dir, 'preprocessed')\n", (919, 945), False, 'import os\n'), ((973, 1013), 'os.path.join',... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('corpus', '0002_data_migration_dont_know_skip_merge'),
]
operations = [
migrations.AlterField(
model_name='eviden... | [
"django.db.models.CharField"
] | [((409, 626), 'django.db.models.CharField', 'models.CharField', ([], {'default': '"""SK"""', 'null': '(True)', 'max_length': '(2)', 'choices': "[('YE', 'Yes, relation is present'), ('NO', 'No relation present'), ('NS',\n 'Evidence is nonsense'), ('SK', 'Skipped labeling of this evidence')]"}), "(default='SK', null=T... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'response_info.ui',
# licensing of 'response_info.ui' applies.
#
# Created: Sun Feb 17 10:16:18 2019
# by: pyside2-uic running on PySide2 5.12.1
#
# WARNING! All changes made in this file will be lost!
from PySide2 import QtCore, QtGui... | [
"PySide2.QtCore.QMetaObject.connectSlotsByName",
"PySide2.QtWidgets.QLabel",
"PySide2.QtWidgets.QSpacerItem",
"PySide2.QtWidgets.QSizePolicy",
"PySide2.QtWidgets.QHBoxLayout"
] | [((510, 598), 'PySide2.QtWidgets.QSizePolicy', 'QtWidgets.QSizePolicy', (['QtWidgets.QSizePolicy.Minimum', 'QtWidgets.QSizePolicy.Minimum'], {}), '(QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.\n Minimum)\n', (531, 598), False, 'from PySide2 import QtCore, QtGui, QtWidgets\n'), ((840, 875), 'PySide2.QtWidget... |
# -*- coding: utf-8 -*
""" DSFP modifications spy, looks for save file modifications
.. module:: watcher
:platform: Linux, Windows, MacOS X
:synopsis: watches for dark souls save file modifications and prints
any modified data in console
.. moduleauthor:: Tarvitz <<EMAIL>>
"""
from __future__ import u... | [
"argparse.ArgumentParser",
"textwrap.wrap",
"os.walk",
"dsfp.utils.chunks",
"struct.unpack",
"datetime.datetime.now",
"time.sleep",
"struct.pack",
"os.scandir",
"sys.exit",
"os.path.join",
"os.getenv",
"os.lstat",
"argparse.FileType"
] | [((571, 605), 'os.path.join', 'os.path.join', (['PROJECT_ROOT', '"""dsfp"""'], {}), "(PROJECT_ROOT, 'dsfp')\n", (583, 605), False, 'import os\n'), ((666, 698), 'os.path.join', 'os.path.join', (['PROJECT_ROOT', 'path'], {}), '(PROJECT_ROOT, path)\n', (678, 698), False, 'import os\n'), ((6932, 6964), 'os.path.join', 'os.... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, print_function
import os, sys, pkgutil, json, glob
from distutils.command.clean import clean as CleanCommand
from setuptools import setup, find_packages, Command
#from setuptools import Extension # for Swig extension
from builtins import open, dict
PROJE... | [
"pkgutil.get_data",
"fnmatch.filter",
"os.remove",
"os.getcwd",
"builtins.open",
"os.path.dirname",
"distutils.command.clean.clean.run",
"os.walk",
"os.path.exists",
"os.path.isdir",
"builtins.dict",
"os.environ.get",
"shutil.rmtree",
"os.path.join",
"setuptools.find_packages"
] | [((4509, 4560), 'pkgutil.get_data', 'pkgutil.get_data', (['PROJECT', '"""resources/pkginfo.json"""'], {}), "(PROJECT, 'resources/pkginfo.json')\n", (4525, 4560), False, 'import os, sys, pkgutil, json, glob\n'), ((368, 393), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (383, 393), False, 'im... |
# This file is loaded by py.test to discover API tests
import pytest
from apitest import APITest
from loader import yaml_load
def pytest_collect_file(parent, path):
if path.ext == ".yaml" and path.basename.startswith("test"):
return APITestFile(path, parent)
class APITestFile(pytest.File):
def col... | [
"apitest.APITest"
] | [((808, 847), 'apitest.APITest', 'APITest', (['self.api_test', 'self.api_config'], {}), '(self.api_test, self.api_config)\n', (815, 847), False, 'from apitest import APITest\n')] |
#Import the libraries
#Pygame
import pygame
pygame.init()
#os to access files
import os
#Inits
#import win | [
"pygame.init"
] | [((44, 57), 'pygame.init', 'pygame.init', ([], {}), '()\n', (55, 57), False, 'import pygame\n')] |
'''
This code was written by following the following tutorial:
Link: https://medium.com/@martinpella/how-to-use-pre-trained-word-embeddings-in-pytorch-71ca59249f76
This script processes and generates GloVe embeddings
'''
# coding: utf-8
import pickle
from preprocess import Vocabulary
import numpy as np
import json
fr... | [
"numpy.zeros",
"pickle.load",
"numpy.array",
"numpy.random.normal",
"bcolz.open"
] | [((1372, 1399), 'numpy.zeros', 'np.zeros', (['(matrix_len, 300)'], {}), '((matrix_len, 300))\n', (1380, 1399), True, 'import numpy as np\n'), ((411, 422), 'numpy.zeros', 'np.zeros', (['(1)'], {}), '(1)\n', (419, 422), True, 'import numpy as np\n'), ((1039, 1053), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (105... |
import sys
import sqlite3
from tableinfo import TableInfo
class DbInfo(object):
def __init__(self, name):
self.name = name
self.conn = sqlite3.connect(name)
self.tables = {}
self.conn.text_factory = lambda x: str(x, 'utf-8', 'ignore')
cursor = self.conn.cursor()
curs... | [
"tableinfo.TableInfo",
"sqlite3.connect"
] | [((156, 177), 'sqlite3.connect', 'sqlite3.connect', (['name'], {}), '(name)\n', (171, 177), False, 'import sqlite3\n'), ((659, 690), 'tableinfo.TableInfo', 'TableInfo', (['self.conn', 'tableName'], {}), '(self.conn, tableName)\n', (668, 690), False, 'from tableinfo import TableInfo\n')] |
#!/usr/bin/env python
import sys
import copy
import rospy
import moveit_commander
import moveit_msgs.msg
import geometry_msgs.msg
from math import pi
from std_msgs.msg import String
from moveit_commander.conversions import pose_to_list
import tf
def all_close(goal, actual, tolerance):
"""
Convenience method... | [
"moveit_commander.RobotCommander",
"rospy.Subscriber",
"moveit_commander.PlanningSceneInterface",
"moveit_commander.MoveGroupCommander",
"rospy.init_node",
"moveit_commander.conversions.pose_to_list",
"rospy.spin",
"moveit_commander.roscpp_initialize"
] | [((1774, 1818), 'moveit_commander.roscpp_initialize', 'moveit_commander.roscpp_initialize', (['sys.argv'], {}), '(sys.argv)\n', (1808, 1818), False, 'import moveit_commander\n'), ((1831, 1864), 'moveit_commander.RobotCommander', 'moveit_commander.RobotCommander', ([], {}), '()\n', (1862, 1864), False, 'import moveit_co... |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
from __future__ import print_function
import argparse
import functools
import re
import shlex
import threading
import time
import traceback
import kdpserver
import lldb
import lldbagilityutils
import stubvm
vm = None
def _exec_cmd(debugger, command, capture_output=Fal... | [
"threading.Thread",
"kdpserver.KDPServer",
"argparse.ArgumentParser",
"shlex.split",
"time.sleep",
"stubvm.STUBVM",
"functools.wraps",
"lldb.SBCommandReturnObject"
] | [((1092, 1134), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""fdp-attach"""'}), "(prog='fdp-attach')\n", (1115, 1134), False, 'import argparse\n'), ((1495, 1538), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""vmsn-attach"""'}), "(prog='vmsn-attach')\n", (1518, 1538), ... |
#signal fired after an obj is saved in this cas when a user is created
from django.db.models.signals import post_save
#post to sende the signal
from .models import Post
#reciever of the signal
from django.dispatch import receiver
from .models import Review
@receiver(post_save,sender=Post)
def create_review(sender,i... | [
"django.dispatch.receiver"
] | [((262, 294), 'django.dispatch.receiver', 'receiver', (['post_save'], {'sender': 'Post'}), '(post_save, sender=Post)\n', (270, 294), False, 'from django.dispatch import receiver\n')] |
from setuptools import setup, find_packages
setup(
name = 'multiresunet',
version = '0.1',
description = 'MultiResUNet implementation in PyTorch; MultiResUNet: Rethinking the U-Net Architecture for Multimodal',
author = '<NAME>',
author_email = '<EMAIL>',
inst... | [
"setuptools.find_packages"
] | [((360, 375), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (373, 375), False, 'from setuptools import setup, find_packages\n')] |
"""
====================================
Data set of Markov transition fields
====================================
A Markov transition field is an image obtained from a time series, representing
a field of transition probabilities for a discretized time series.
Different strategies can be used to bin time series.
It i... | [
"mpl_toolkits.axes_grid1.ImageGrid",
"matplotlib.pyplot.show",
"pyts.datasets.load_gunpoint",
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.figure",
"pyts.image.MarkovTransitionField"
] | [((983, 1013), 'pyts.datasets.load_gunpoint', 'load_gunpoint', ([], {'return_X_y': '(True)'}), '(return_X_y=True)\n', (996, 1013), False, 'from pyts.datasets import load_gunpoint\n'), ((1072, 1103), 'pyts.image.MarkovTransitionField', 'MarkovTransitionField', ([], {'n_bins': '(8)'}), '(n_bins=8)\n', (1093, 1103), False... |
#!/usr/bin/env python3.5
import os
import dlib
import numpy as np
import cv2
import time
import darknet
from ctypes import *
import math
import random
class YOLO_NN:
def __init__(self, yoloDataFolder):
self.configPath = yoloDataFolder + "/cfg/yolov3-tiny.cfg"
self.weightPath = yoloDataFolder + "/... | [
"numpy.linalg.norm",
"cv2.rectangle",
"darknet.network_height",
"dlib.shape_predictor",
"cv2.imshow",
"os.path.abspath",
"cv2.cvtColor",
"os.path.exists",
"cv2.destroyAllWindows",
"re.search",
"cv2.waitKey",
"cv2.addWeighted",
"dlib.face_recognition_model_v1",
"dlib.get_frontal_face_detect... | [((7846, 7865), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(1)'], {}), '(1)\n', (7862, 7865), False, 'import cv2\n'), ((8035, 8120), 'cv2.CascadeClassifier', 'cv2.CascadeClassifier', (["(rn.data_dir + '/dlib/haarcascade_frontalface_default.xml')"], {}), "(rn.data_dir + '/dlib/haarcascade_frontalface_default.xml'\n )... |
# import all the required python libaries: graphics and random
from graphics import *
import random
# create the graphics window and set background colour
win = GraphWin("Colour Guessing Game", 1000, 500)
win.setBackground('#232323')
# create a title for your game
titleBg = Rectangle(Point(0, 0), Point(1000, 135))
ti... | [
"random.randint"
] | [((914, 934), 'random.randint', 'random.randint', (['(0)', '(3)'], {}), '(0, 3)\n', (928, 934), False, 'import random\n'), ((743, 765), 'random.randint', 'random.randint', (['(0)', '(255)'], {}), '(0, 255)\n', (757, 765), False, 'import random\n'), ((783, 805), 'random.randint', 'random.randint', (['(0)', '(255)'], {})... |
#!/usr/bin/python3
import nvidia_smi
import json
mydict = nvidia_smi.JsonDeviceQuery()
# Example print JSON
print(json.dumps(mydict, indent=2))
| [
"nvidia_smi.JsonDeviceQuery",
"json.dumps"
] | [((59, 87), 'nvidia_smi.JsonDeviceQuery', 'nvidia_smi.JsonDeviceQuery', ([], {}), '()\n', (85, 87), False, 'import nvidia_smi\n'), ((116, 144), 'json.dumps', 'json.dumps', (['mydict'], {'indent': '(2)'}), '(mydict, indent=2)\n', (126, 144), False, 'import json\n')] |
import datetime
import json
import redis
redis_device_key = 'redis_device_key'
device_expire_second = 60
class RedisProxy(object):
def __init__(self, host='127.0.0.1', port=6379):
self.redis_pool = redis.ConnectionPool(host=host, port=port, db=0)
def connect(self):
return redis.Redis(connect... | [
"redis.Redis",
"json.loads",
"json.dumps",
"redis.ConnectionPool",
"datetime.datetime.now"
] | [((213, 261), 'redis.ConnectionPool', 'redis.ConnectionPool', ([], {'host': 'host', 'port': 'port', 'db': '(0)'}), '(host=host, port=port, db=0)\n', (233, 261), False, 'import redis\n'), ((301, 345), 'redis.Redis', 'redis.Redis', ([], {'connection_pool': 'self.redis_pool'}), '(connection_pool=self.redis_pool)\n', (312,... |
from flask_cors import CORS
cors = CORS(resources={r"/maskmap/*": {"origins": "*"}})
def init_app(app):
cors.init_app(app)
| [
"flask_cors.CORS"
] | [((37, 85), 'flask_cors.CORS', 'CORS', ([], {'resources': "{'/maskmap/*': {'origins': '*'}}"}), "(resources={'/maskmap/*': {'origins': '*'}})\n", (41, 85), False, 'from flask_cors import CORS\n')] |
import numpy as np
image_dimensions = (25, 6)
def load(image_dims, path: str = "input/08.txt"):
with open(path) as file:
return np.array([c for c in file.read()]).reshape((-1, image_dims[0] * image_dims[1]))
def number_of_values_in_layer(layer, value):
return np.count_nonzero(layer == value)
def ... | [
"numpy.array",
"numpy.count_nonzero"
] | [((281, 313), 'numpy.count_nonzero', 'np.count_nonzero', (['(layer == value)'], {}), '(layer == value)\n', (297, 313), True, 'import numpy as np\n'), ((590, 611), 'numpy.array', 'np.array', (['final_layer'], {}), '(final_layer)\n', (598, 611), True, 'import numpy as np\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Date : Jan-02-21 20:43
# @Author : <NAME> (<EMAIL>)
import tensorflow as tf
from tensorflow.python.keras import keras_parameterized
from tensorflow.python.platform import test
from tensorflow.keras.utils import plot_model
from senet.keras_fn.se_resnet import SE_Re... | [
"tensorflow.python.platform.test.main",
"senet.keras_fn.se_resnet.SE_ResNet_50",
"senet.keras_fn.se_resnet.SE_ResNet_18",
"tensorflow.keras.utils.plot_model",
"senet.keras_fn.se_resnet.SE_ResNet_101",
"senet.keras_fn.se_resnet.SE_ResNet_152"
] | [((1953, 1964), 'tensorflow.python.platform.test.main', 'test.main', ([], {}), '()\n', (1962, 1964), False, 'from tensorflow.python.platform import test\n'), ((581, 675), 'senet.keras_fn.se_resnet.SE_ResNet_18', 'SE_ResNet_18', ([], {'include_top': '(True)', 'weights': 'None', 'input_shape': 'input_shape', 'classes': '... |
"""
Usage:
- From Spark 3.1.1 base container with Python bindings:
docker run --rm -it --name test_pyspark spark-ingest:latest /bin/bash
./bin/spark-submit spark-ingest/main.py --filepath ./examples/src/main/python/pi.py
- From binaries:
./pyspark --packages io.delta:delta-core_2.12:1.0.0 \
--conf "spark.sql.extens... | [
"spark_etl.etl.load_vitals",
"shutil.rmtree",
"spark_etl.logger.info",
"click.option",
"spark_etl.etl.cache_mpmi",
"pyspark.sql.SparkSession.builder.appName",
"spark_etl.etl.time_travel",
"spark_etl.etl.upsert_vitals",
"click.group",
"datetime.datetime.now"
] | [((4160, 4173), 'click.group', 'click.group', ([], {}), '()\n', (4171, 4173), False, 'import click\n'), ((4256, 4326), 'click.option', 'click.option', (['"""--filepath"""'], {'required': '(False)', 'help': '"""The input file path"""'}), "('--filepath', required=False, help='The input file path')\n", (4268, 4326), False... |
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from runner.tasks import start_flow_task
class RunnerStartFlow(APIView):
def post(self, request):
flow_uuid = request.POST.get('flow_uuid', None)
flow_repo_url = request.POST.get... | [
"rest_framework.response.Response",
"runner.tasks.start_flow_task.delay"
] | [((487, 534), 'runner.tasks.start_flow_task.delay', 'start_flow_task.delay', (['flow_uuid', 'flow_repo_url'], {}), '(flow_uuid, flow_repo_url)\n', (508, 534), False, 'from runner.tasks import start_flow_task\n'), ((551, 604), 'rest_framework.response.Response', 'Response', (['"""Received"""'], {'status': 'status.HTTP_2... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import json
import warnings
import pulumi
import pulumi.runtime
from typing import Union
from .. import utilities, tables
class GetDef... | [
"pulumi.runtime.invoke",
"pulumi.InvokeOptions"
] | [((2860, 2882), 'pulumi.InvokeOptions', 'pulumi.InvokeOptions', ([], {}), '()\n', (2880, 2882), False, 'import pulumi\n'), ((2973, 3089), 'pulumi.runtime.invoke', 'pulumi.runtime.invoke', (['"""gcp:compute/getDefaultServiceAccount:getDefaultServiceAccount"""', '__args__'], {'opts': 'opts'}), "(\n 'gcp:compute/getDef... |
import math
def calculate_power_luminance(ambient_area):
#area in m^2
potency = 0
if ambient_area <= 6:
print('Lighting Potency: '+ str(100) +' (VA)')
potency = 100
else:
print('extra potency: ' + str((ambient_area - 6)))
potency = 100 + 60 * int((ambient_area - 6)/4)
print('Lighting Poten... | [
"math.ceil"
] | [((866, 892), 'math.ceil', 'math.ceil', (['(perimeter / 3.5)'], {}), '(perimeter / 3.5)\n', (875, 892), False, 'import math\n'), ((1151, 1175), 'math.ceil', 'math.ceil', (['(perimeter / 5)'], {}), '(perimeter / 5)\n', (1160, 1175), False, 'import math\n')] |
import pandas as pd
SUPPORT = 0.005
CONF = 0.5
def csv2list():
df = pd.read_csv("./实验三/数据/Groceries.csv")
itemsets = []
for itemset_str in df["items"]:
itemsets.append(set(itemset_str[1:-1].split(",")))
return itemsets
itemsets = csv2list()
itemsets_len = itemsets.__len__()
def build1d... | [
"pandas.read_csv"
] | [((75, 112), 'pandas.read_csv', 'pd.read_csv', (['"""./实验三/数据/Groceries.csv"""'], {}), "('./实验三/数据/Groceries.csv')\n", (86, 112), True, 'import pandas as pd\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
-------------------------------------------------
@ Author : pengj
@ date : 2019/12/10 15:45
@ IDE : PyCharm
@ GitHub : https://github.com/JackyPJB
@ Contact : <EMAIL>
--------------------------------... | [
"app.models.db.StringField",
"app.models.db.ReferenceField",
"app.models.db.BooleanField",
"app.models.db.DateTimeField"
] | [((564, 623), 'app.models.db.ReferenceField', 'db.ReferenceField', (['User'], {'required': '(True)', 'verbose_name': '"""用户id"""'}), "(User, required=True, verbose_name='用户id')\n", (581, 623), False, 'from app.models import db\n'), ((641, 705), 'app.models.db.StringField', 'db.StringField', ([], {'max_length': '(512)',... |
from pyflink.datastream import StreamExecutionEnvironment, TimeCharacteristic
from pyflink.table import StreamTableEnvironment, DataTypes, EnvironmentSettings
from pyflink.table.descriptors import (
Schema,
Kafka,
Json,
Rowtime,
OldCsv,
FileSystem,
)
from pyflink.table.udf import udf
s_env = St... | [
"json.load",
"pyflink.table.EnvironmentSettings.new_instance",
"tensorflow.Session",
"pyflink.table.descriptors.OldCsv",
"pyflink.table.DataTypes.STRING",
"pyflink.table.descriptors.Kafka",
"tensorflow.gfile.GFile",
"pyflink.table.descriptors.Schema",
"tensorflow.Graph",
"tensorflow.import_graph_d... | [((318, 372), 'pyflink.datastream.StreamExecutionEnvironment.get_execution_environment', 'StreamExecutionEnvironment.get_execution_environment', ([], {}), '()\n', (370, 372), False, 'from pyflink.datastream import StreamExecutionEnvironment, TimeCharacteristic\n'), ((1358, 1377), 'tensorflow.Session', 'tf.Session', ([]... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11 on 2017-05-24 12:07
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('servers', '0003_auto_20170523_1409'),
]
operations =... | [
"django.db.models.ForeignKey"
] | [((442, 563), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""servers"""', 'to': '"""servers.OperatingSystem"""'}), "(on_delete=django.db.models.deletion.CASCADE, related_name\n ='servers', to='servers.OperatingSystem')\n", (459, 563), F... |
# Solution of;
# Project Euler Problem 558: Irrational base
# https://projecteuler.net/problem=558
#
# Let r be the real root of the equation x3 = x2 + 1. Every positive integer
# can be written as the sum of distinct increasing powers of r. If we require
# the number of terms to be finite and the difference between... | [
"timed.caller"
] | [((1197, 1231), 'timed.caller', 'timed.caller', (['dummy', 'n', 'i', 'prob_id'], {}), '(dummy, n, i, prob_id)\n', (1209, 1231), False, 'import timed\n')] |
import argparse
import numpy as np
from benchmark_statistics import Statistics
from benchmark_containers import BenchmarkResultsContainer
##############################################################################
def createBenchmarkResults(benchmark_samples, operation):
benchmark_results = BenchmarkResults... | [
"benchmark_containers.BenchmarkResultsContainer",
"benchmark_statistics.Statistics.getTukeyFences",
"benchmark_statistics.Statistics.getStdErr",
"argparse.ArgumentParser",
"benchmark_statistics.Statistics.getKurtosis",
"benchmark_statistics.Statistics.getIQR",
"numpy.fromfile",
"benchmark_statistics.S... | [((304, 331), 'benchmark_containers.BenchmarkResultsContainer', 'BenchmarkResultsContainer', ([], {}), '()\n', (329, 331), False, 'from benchmark_containers import BenchmarkResultsContainer\n'), ((439, 483), 'benchmark_statistics.Statistics.getTukeyFences', 'Statistics.getTukeyFences', (['benchmark_samples'], {}), '(be... |
#!/usr/bin/env python
#
# hardware.py - OVFHardware class
#
# June 2016, <NAME>
# Copyright (c) 2013-2016, 2019 the COT project developers.
# See the COPYRIGHT.txt file at the top-level directory of this distribution
# and at https://github.com/glennmatthews/cot/blob/master/COPYRIGHT.txt.
#
# This file is part of the C... | [
"copy.deepcopy",
"COT.xml_file.XML.add_child",
"COT.data_validation.natural_sort",
"logging.getLogger"
] | [((1007, 1034), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1024, 1034), False, 'import logging\n'), ((5097, 5125), 'COT.data_validation.natural_sort', 'natural_sort', (['self.item_dict'], {}), '(self.item_dict)\n', (5109, 5125), False, 'from COT.data_validation import natural_sort\n'... |
import json
#Convert from JSON to Python
# some JSON:
x = '{ "name":"John", "age":30, "city":"New York"}'
# parse x:
y = json.loads(x)
# the result is a Python dictionary:
print(y["name"])
#Convert from Python to JSON
# a Python object (dict):
x = {
"name": "John",
"age": 30,
"city": "New York"
}
# convert in... | [
"json.loads",
"json.dumps"
] | [((123, 136), 'json.loads', 'json.loads', (['x'], {}), '(x)\n', (133, 136), False, 'import json\n'), ((333, 346), 'json.dumps', 'json.dumps', (['x'], {}), '(x)\n', (343, 346), False, 'import json\n'), ((817, 866), 'json.dumps', 'json.dumps', (['x'], {'indent': '(4)', 'separators': "('. ', ' = ')"}), "(x, indent=4, sepa... |
"""Calendar_widget.py"""
import re
import curses
import random
import calendar
import itertools
import source.config as config
from collections import namedtuple
date = namedtuple("Date", "Year Month Day")
def iter_months_years(startDate: object, endDate: object) -> tuple:
"""Returns years and months based on giv... | [
"curses.wrapper",
"re.match",
"calendar.TextCalendar",
"collections.namedtuple",
"curses.curs_set"
] | [((170, 206), 'collections.namedtuple', 'namedtuple', (['"""Date"""', '"""Year Month Day"""'], {}), "('Date', 'Year Month Day')\n", (180, 206), False, 'from collections import namedtuple\n'), ((2020, 2043), 'calendar.TextCalendar', 'calendar.TextCalendar', ([], {}), '()\n', (2041, 2043), False, 'import calendar\n'), ((... |
from flask import Flask, Request, Response, request
import json
def devices():
dict_device = request.get_data(as_text=True)
dados_device = json.loads(dict_device)
| [
"flask.request.get_data",
"json.loads"
] | [((102, 132), 'flask.request.get_data', 'request.get_data', ([], {'as_text': '(True)'}), '(as_text=True)\n', (118, 132), False, 'from flask import Flask, Request, Response, request\n'), ((153, 176), 'json.loads', 'json.loads', (['dict_device'], {}), '(dict_device)\n', (163, 176), False, 'import json\n')] |
import sys
from urllib import request, parse, error
from multiprocessing import Process
urls = [
'https://github.com/',
'https://twitter.com/',
'https://hub.docker.com/v2/users/'
]
def inspect_status_code(url):
try:
response = request.urlopen(url)
return response.code
except error... | [
"multiprocessing.Process",
"urllib.request.urlopen",
"urllib.parse.urlparse"
] | [((254, 274), 'urllib.request.urlopen', 'request.urlopen', (['url'], {}), '(url)\n', (269, 274), False, 'from urllib import request, parse, error\n'), ((443, 462), 'urllib.parse.urlparse', 'parse.urlparse', (['url'], {}), '(url)\n', (457, 462), False, 'from urllib import request, parse, error\n'), ((777, 821), 'multipr... |
import torch
import numpy as np
from torch.utils.data import DataLoader
from torchvision import transforms
from data_loader.datasets_custom import TextImageDataset, COCOTextImageDataset
from base import BaseDataLoader
def text_image_collate_fn(data):
collate_data = {}
# Sort a data list by right caption lengt... | [
"numpy.stack",
"data_loader.datasets_custom.COCOTextImageDataset",
"torch.stack",
"torchvision.transforms.RandomHorizontalFlip",
"torch.LongTensor",
"data_loader.datasets_custom.TextImageDataset",
"torchvision.transforms.Normalize",
"torch.tensor",
"torchvision.transforms.ToTensor"
] | [((2042, 2081), 'torch.LongTensor', 'torch.LongTensor', (['right_caption_lengths'], {}), '(right_caption_lengths)\n', (2058, 2081), False, 'import torch\n'), ((2567, 2606), 'torch.LongTensor', 'torch.LongTensor', (['wrong_caption_lengths'], {}), '(wrong_caption_lengths)\n', (2583, 2606), False, 'import torch\n'), ((289... |
import pytest
from sqlalchemy.exc import ProgrammingError
from sqlalchemy_continuum.utils import count_versions
from kokon.orm import Guest
from kokon.utils.db import DB
from tests.helpers import admin_session
def test_app_user():
with admin_session() as session:
session.execute("TRUNCATE guests_version... | [
"tests.helpers.admin_session",
"sqlalchemy_continuum.utils.count_versions",
"kokon.orm.Guest",
"kokon.utils.db.DB",
"pytest.raises"
] | [((244, 259), 'tests.helpers.admin_session', 'admin_session', ([], {}), '()\n', (257, 259), False, 'from tests.helpers import admin_session\n'), ((636, 913), 'kokon.orm.Guest', 'Guest', ([], {'guid': 'guid', 'full_name': '"""<NAME>"""', 'email': '"""<EMAIL>"""', 'phone_number': '"""100-330-497"""', 'people_in_group': '... |
import torch
import torch.nn as nn
from torchvision import transforms as ttf
class RandAugment(nn.Module):
def __init__(self, N, M):
super().__init__()
"""
rotate
shear x
shear y
translate y
translate x
autoContrast
sharpness
identity... | [
"torchvision.transforms.functional.solarize",
"torchvision.transforms.functional.adjust_contrast",
"torchvision.transforms.functional.rotate",
"torch.nn.Sequential",
"torch.nn.ModuleList",
"torchvision.transforms.functional.autocontrast",
"torchvision.transforms.functional.equalize",
"torchvision.tran... | [((818, 835), 'torch.nn.ModuleList', 'nn.ModuleList', (['[]'], {}), '([])\n', (831, 835), True, 'import torch.nn as nn\n'), ((972, 1006), 'torch.nn.Sequential', 'nn.Sequential', (['*self.augmentations'], {}), '(*self.augmentations)\n', (985, 1006), True, 'import torch.nn as nn\n'), ((1233, 1271), 'torchvision.transform... |
# -*- coding: utf-8 -*-
"""
Copyright 2019 CS Systèmes d'Information
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... | [
"ikats.exceptions.IkatsConflictError",
"ikats.lib.check_type",
"ikats.lib.MDType",
"ikats.client.opentsdb_stub.OpenTSDBStub",
"ikats.client.opentsdb_client.OpenTSDBClient",
"ikats.client.datamodel_client.DatamodelClient",
"ikats.exceptions.IkatsNotFoundError",
"ikats.lib.check_is_valid_epoch",
"ikat... | [((1181, 1221), 're.compile', 're.compile', (['"""^qual(.)*|ikats(.)*|funcId"""'], {}), "('^qual(.)*|ikats(.)*|funcId')\n", (1191, 1221), False, 'import re\n'), ((3260, 3306), 'ikats.objects.Timeseries', 'Timeseries', ([], {'api': 'self.api', 'tsuid': 'tsuid', 'fid': 'fid'}), '(api=self.api, tsuid=tsuid, fid=fid)\n', (... |
import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"] = "1"
import tensorflow as tf
from keras.models import model_from_json
import json
from sklearn.metrics import roc_curve, auc, confusion_matrix
import numpy as np
import pandas as pd
from copy import deepcop... | [
"copy.deepcopy",
"json.load",
"matplotlib.pyplot.show",
"utils.load_data",
"sklearn.metrics.roc_curve",
"tensorflow.keras.backend.clear_session",
"sklearn.metrics.auc",
"matplotlib.pyplot.figure",
"keras.models.model_from_json",
"numpy.arange",
"numpy.interp",
"sklearn.metrics.confusion_matrix... | [((669, 703), 'keras.models.model_from_json', 'model_from_json', (['loaded_model_json'], {}), '(loaded_model_json)\n', (684, 703), False, 'from keras.models import model_from_json\n'), ((948, 980), 'tensorflow.keras.backend.clear_session', 'tf.keras.backend.clear_session', ([], {}), '()\n', (978, 980), True, 'import te... |
# coding: utf-8
import pprint
import six
from enum import Enum
class SubscriptionVersion:
swagger_types = {
'activated_on': 'datetime',
'billing_currency': 'str',
'component_configurations': 'list[SubscriptionComponentConfiguration]',
'created_on': 'datetime',
'expec... | [
"six.iteritems"
] | [((16159, 16192), 'six.iteritems', 'six.iteritems', (['self.swagger_types'], {}), '(self.swagger_types)\n', (16172, 16192), False, 'import six\n')] |
"""
Example to demonstrate creating a pivot table from the output of zonal stats CLI
"""
import time
import pandas
# Return a pipe-delimited combination of value from every column up through zone
def get_key(row):
key_parts = []
for col in row.keys():
if col == 'zone':
return... | [
"pandas.read_csv",
"time.time"
] | [((397, 408), 'time.time', 'time.time', ([], {}), '()\n', (406, 408), False, 'import time\n'), ((447, 474), 'pandas.read_csv', 'pandas.read_csv', (['infilename'], {}), '(infilename)\n', (462, 474), False, 'import pandas\n'), ((977, 988), 'time.time', 'time.time', ([], {}), '()\n', (986, 988), False, 'import time\n')] |
import abc
import asyncio
from typing import Collection
class Job(abc.ABC):
__slots__ = ()
@property
@abc.abstractmethod
def is_running(self) -> bool:
...
@abc.abstractmethod
async def close(self, *, timeout: float = 0.5) -> bool:
...
class SingleTaskJob(Job):
__slots__... | [
"asyncio.wait"
] | [((655, 698), 'asyncio.wait', 'asyncio.wait', (['{self._task}'], {'timeout': 'timeout'}), '({self._task}, timeout=timeout)\n', (667, 698), False, 'import asyncio\n')] |
# provide status of all jobs
import ulmodb
dbname = "ulmodb.db"
db = ulmodb.UlmoDB(dbname)
| [
"ulmodb.UlmoDB"
] | [((74, 95), 'ulmodb.UlmoDB', 'ulmodb.UlmoDB', (['dbname'], {}), '(dbname)\n', (87, 95), False, 'import ulmodb\n')] |
import numpy as np
import nimfa
V = np.random.rand(40, 100)
nmf = nimfa.Nmf(V, seed="nndsvd", rank=10, max_iter=12, update='euclidean',
objective='fro')
nmf_fit = nmf()
| [
"numpy.random.rand",
"nimfa.Nmf"
] | [((38, 61), 'numpy.random.rand', 'np.random.rand', (['(40)', '(100)'], {}), '(40, 100)\n', (52, 61), True, 'import numpy as np\n'), ((68, 158), 'nimfa.Nmf', 'nimfa.Nmf', (['V'], {'seed': '"""nndsvd"""', 'rank': '(10)', 'max_iter': '(12)', 'update': '"""euclidean"""', 'objective': '"""fro"""'}), "(V, seed='nndsvd', rank... |
#!/usr/bin/env python
import os
import json
import sys
import argparse
def _find_config_file():
config = 'etc/minicondas.json'
while not os.path.isfile(config):
config = '../{}'.format(config)
if len(config) > 70:
raise Exception('Cannot locate config file "etc/minicondas.json"... | [
"os.path.isfile",
"json.load",
"argparse.ArgumentParser"
] | [((1189, 1214), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1212, 1214), False, 'import argparse\n'), ((150, 172), 'os.path.isfile', 'os.path.isfile', (['config'], {}), '(config)\n', (164, 172), False, 'import os\n'), ((484, 501), 'json.load', 'json.load', (['reader'], {}), '(reader)\n', (4... |
from transformers import GPT2Tokenizer
tokenizer = GPT2Tokenizer.from_pretrained('gpt2', bos_token='<|startoftext|>', eos_token='<|endoftext|>', pad_token='<|pad|>')
tokenizer.pad_token = tokenizer.eos_token
| [
"transformers.GPT2Tokenizer.from_pretrained"
] | [((51, 169), 'transformers.GPT2Tokenizer.from_pretrained', 'GPT2Tokenizer.from_pretrained', (['"""gpt2"""'], {'bos_token': '"""<|startoftext|>"""', 'eos_token': '"""<|endoftext|>"""', 'pad_token': '"""<|pad|>"""'}), "('gpt2', bos_token='<|startoftext|>',\n eos_token='<|endoftext|>', pad_token='<|pad|>')\n", (80, 169... |
import matplotlib.pyplot as plt
from CuteFlower2.data_loading import cd
import os
def save_hist_plot(history, name="test", path=None):
train_errors = history.history['loss']
val_errors = history.history['val_loss']
plt.style.use('bmh')
plt.plot(range(len(train_errors)), train_errors, 'g-', label="Tr... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.clf",
"os.getcwd",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ion",
"matplotlib.pyplot.style.use",
"CuteFlower2.data_loading.cd",
"matplotlib.pyplot.pause"
] | [((231, 251), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""bmh"""'], {}), "('bmh')\n", (244, 251), True, 'import matplotlib.pyplot as plt\n'), ((398, 410), 'matplotlib.pyplot.legend', 'plt.legend', ([], {}), '()\n', (408, 410), True, 'import matplotlib.pyplot as plt\n'), ((659, 679), 'matplotlib.pyplot.style.u... |
# Imports
import pandas as pd
import numpy as np
import torch
from torch import nn
from torch import optim
import torch.nn.functional as F
import torch.utils.data
from torchvision import datasets, models, transforms
from collections import OrderedDict
import os
import argparse
# Functions
def arg_parser():
''... | [
"torch.nn.Dropout",
"argparse.ArgumentParser",
"torch.nn.NLLLoss",
"torchvision.transforms.Normalize",
"torch.no_grad",
"torch.utils.data.DataLoader",
"torchvision.transforms.RandomRotation",
"torch.exp",
"torch.nn.Linear",
"torchvision.models.vgg16",
"torch.nn.LogSoftmax",
"torchvision.datase... | [((435, 496), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""ImageClassifier Params"""'}), "(description='ImageClassifier Params')\n", (458, 496), False, 'import argparse\n'), ((6141, 6153), 'torch.nn.NLLLoss', 'nn.NLLLoss', ([], {}), '()\n', (6151, 6153), False, 'from torch import nn\n'... |
import argparse
import sys
from os.path import join
from os import chdir
import subprocess
if __name__ == '__main__':
parser = argparse.ArgumentParser()
parser.add_argument('-s', '--sge', type=str, default='nosge')
parser.add_argument('-l', '--filelist', type=str, default='')
parser.add_argument('-zr_root', '--... | [
"argparse.ArgumentParser",
"os.chdir"
] | [((131, 156), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (154, 156), False, 'import argparse\n'), ((438, 457), 'os.chdir', 'chdir', (['args.zr_root'], {}), '(args.zr_root)\n', (443, 457), False, 'from os import chdir\n')] |
#!/usr/bin/env python3
import re
from gensim.models import word2vec
from gensim.models import KeyedVectors
from operator import itemgetter
filePath = '/home/ubuntu/danmu/corpusSegRecentWords.txt'
fileTrainRead = []
#read the file by line
with open(filePath) as fileTrainRaw:
for line in fileTrainRaw:
fileT... | [
"operator.itemgetter",
"re.match",
"gensim.models.KeyedVectors.load_word2vec_format"
] | [((393, 484), 'gensim.models.KeyedVectors.load_word2vec_format', 'KeyedVectors.load_word2vec_format', (['"""/home/ubuntu/danmu/corpusWord2Vec.bin"""'], {'binary': '(True)'}), "('/home/ubuntu/danmu/corpusWord2Vec.bin',\n binary=True)\n", (426, 484), False, 'from gensim.models import KeyedVectors\n'), ((931, 1053), 'r... |
import torch
import torch.nn as nn
from torch.autograd import Variable
from Param import nc, nz, device
class Model512(nn.Module):
def __init__(self,nz=nz,nef=8,ngf=8,nc=nc):
super(Model512, self).__init__()
self.nz=nz
self.nc=nc
## Encoder Part ##
self.encode = nn.Se... | [
"torch.nn.ReLU",
"torch.nn.ConvTranspose2d",
"torch.nn.Tanh",
"torch.autograd.Variable",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d",
"torch.nn.Linear",
"torch.nn.LeakyReLU",
"torch.nn.Sigmoid"
] | [((4241, 4250), 'torch.nn.Tanh', 'nn.Tanh', ([], {}), '()\n', (4248, 4250), True, 'import torch.nn as nn\n'), ((8780, 8789), 'torch.nn.Tanh', 'nn.Tanh', ([], {}), '()\n', (8787, 8789), True, 'import torch.nn as nn\n'), ((8824, 8841), 'torch.nn.Linear', 'nn.Linear', (['nz', '(64)'], {}), '(nz, 64)\n', (8833, 8841), True... |
import time
import sys
import ibmiotf.application
import ibmiotf.device
import random
import json
#Provide your IBM Watson Device Credentials
organization = "1tzgh7"
deviceType = "iotdevice"
deviceId = "0000"
authMethod = "token"
authToken = "<PASSWORD>"
# Initialize the device client\
def myComman... | [
"sys.exit",
"time.sleep"
] | [((2220, 2233), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (2230, 2233), False, 'import time\n'), ((1492, 1502), 'sys.exit', 'sys.exit', ([], {}), '()\n', (1500, 1502), False, 'import sys\n')] |
import numpy as np
import pandas as pd
from sklearn import model_selection
import tensorflow as tf
from pathlib import Path
"""
<NAME>, WAK2116, ELEN-E6889, Spring 2019
Final Project
This python file trains a neural network that predicts an activity level
based on a jpg image from a traffic camera
... | [
"tensorflow.image.crop_to_bounding_box",
"tensorflow.keras.layers.Conv2D",
"tensorflow.keras.layers.MaxPooling2D",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.Dense",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"numpy.empty",
"tensorflow.Session",
"numpy.expand_d... | [((568, 608), 'pandas.read_csv', 'pd.read_csv', (['"""./labeled_data/labels.txt"""'], {}), "('./labeled_data/labels.txt')\n", (579, 608), True, 'import pandas as pd\n'), ((642, 693), 'sklearn.model_selection.train_test_split', 'model_selection.train_test_split', (['df'], {'test_size': '(0.1)'}), '(df, test_size=0.1)\n'... |
"""
Tools for Some Platformer Game
Created by sheepy0125
02/10/2021
"""
from pathlib import Path
###############
### Globals ###
###############
ROOT_PATH: Path = Path(__file__).parent.parent
####################
### Logger class ###
####################
class Logger:
"""Log messages with ease"""
colors: di... | [
"pathlib.Path"
] | [((165, 179), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (169, 179), False, 'from pathlib import Path\n')] |