code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from collections import deque
with open("day6.txt", "r") as f:
fish = list(map(int, f.readline().split(",")))
fish_ages = deque([0]*9)
for age in fish:
fish_ages[age] += 1
for _ in range(80):
new_fish = fish_ages[0]
fish_ages.rotate(-1)
fish_ages[6] += fish_ages[-1]
fish_ages[-1] = new_fish
... | [
"collections.deque"
] | [((129, 143), 'collections.deque', 'deque', (['([0] * 9)'], {}), '([0] * 9)\n', (134, 143), False, 'from collections import deque\n')] |
'''tzinfo timezone information for Africa/Mogadishu.'''
from pytz.tzinfo import DstTzInfo
from pytz.tzinfo import memorized_datetime as d
from pytz.tzinfo import memorized_ttinfo as i
class Mogadishu(DstTzInfo):
'''Africa/Mogadishu timezone definition. See datetime.tzinfo for details'''
zone = 'Africa/Mogadis... | [
"pytz.tzinfo.memorized_ttinfo",
"pytz.tzinfo.memorized_datetime"
] | [((355, 374), 'pytz.tzinfo.memorized_datetime', 'd', (['(1)', '(1)', '(1)', '(0)', '(0)', '(0)'], {}), '(1, 1, 1, 0, 0, 0)\n', (356, 374), True, 'from pytz.tzinfo import memorized_datetime as d\n'), ((371, 396), 'pytz.tzinfo.memorized_datetime', 'd', (['(1930)', '(12)', '(31)', '(21)', '(0)', '(0)'], {}), '(1930, 12, 3... |
from nltk.corpus import wordnet as wn
import nltk
import numpy as np
import pm4py
from pm4py.objects.log.log import EventLog
from nlp_label_quality.analysis import matrix_eval
from typing import Dict, List, Tuple, Union, Any
from nlp_label_quality.analysis.attribute_value import Attribute, AttributeValue
import tim... | [
"logging.getLogger",
"nlp_label_quality.analysis.matrix_eval.get_results_from_matrix",
"pm4py.filter_event_attribute_values"
] | [((348, 375), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (365, 375), False, 'import logging\n'), ((1124, 1198), 'pm4py.filter_event_attribute_values', 'pm4py.filter_event_attribute_values', (['log', 'attribute', 'values', 'level', 'retain'], {}), '(log, attribute, values, level, retai... |
import unittest
import numpy as np
import tensorflow as tf
import tensorflow.keras as K
from tensorflow.keras.layers import Dense, BatchNormalization, Dropout, Softmax
from sklearn.metrics import accuracy_score
from nncv.data_loader import *
from nncv.loss import *
class TestTFFunction(unittest.TestCase):
_xyz ... | [
"sklearn.metrics.accuracy_score",
"numpy.ones",
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.keras.backend.get_session",
"numpy.average",
"tensorflow.Session",
"tensorflow.keras.layers.Dropout",
"numpy.argmax",
"tensorflow.global_variables_initializer",
"tensorflow.gradients",
"tens... | [((322, 339), 'numpy.ones', 'np.ones', (['[100, 3]'], {}), '([100, 3])\n', (329, 339), True, 'import numpy as np\n'), ((684, 722), 'tensorflow.keras.Input', 'tf.keras.Input', ([], {'shape': '(self.nfeature,)'}), '(shape=(self.nfeature,))\n', (698, 722), True, 'import tensorflow as tf\n'), ((1319, 1357), 'tensorflow.ker... |
from pyecharts import options as opts
from pyecharts.charts import Scatter
from pyecharts.commons.utils import JsCode
from pyecharts.faker import Faker
c = (
Scatter()
.add_xaxis(Faker.choose())
.add_yaxis(
"商家A",
[list(z) for z in zip(Faker.values(), Faker.choose())],
label_opts=op... | [
"pyecharts.faker.Faker.values",
"pyecharts.options.TitleOpts",
"pyecharts.commons.utils.JsCode",
"pyecharts.charts.Scatter",
"pyecharts.options.VisualMapOpts",
"pyecharts.faker.Faker.choose"
] | [((520, 557), 'pyecharts.options.TitleOpts', 'opts.TitleOpts', ([], {'title': '"""Scatter-多维度数据"""'}), "(title='Scatter-多维度数据')\n", (534, 557), True, 'from pyecharts import options as opts\n'), ((760, 825), 'pyecharts.options.VisualMapOpts', 'opts.VisualMapOpts', ([], {'type_': '"""color"""', 'max_': '(150)', 'min_': '... |
'''
* @author <NAME>
* @email <EMAIL>
* @create date 01-01-2022 17:03:09
* @modify date 01-01-2022 17:03:09
* @desc This code generates a dataset containing data of chess games played on lichess.org
'''
import pandas as pd
import time
from pandas.core.frame import DataFrame
import constants as C
import json
impo... | [
"os.listdir",
"pickle.dump",
"pandas.read_csv",
"constants.CLIENT.games.export_by_player",
"pickle.load",
"time.sleep",
"json.load",
"os.path.isdir",
"os.mkdir",
"pandas.DataFrame",
"random.randint",
"json.dump",
"os.remove"
] | [((1010, 1036), 'pandas.read_csv', 'pd.read_csv', (['csv_file_path'], {}), '(csv_file_path)\n', (1021, 1036), True, 'import pandas as pd\n'), ((4555, 4897), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['Game ID', 'White Rating', 'Black Rating', 'Average Rating', 'Opening ECO',\n '# of Opening Ply', 'White ... |
from typing import Any, Dict, Mapping, Type
from vial.errors import ErrorHandlingAPI, MethodNotAllowedError, NotFoundError
from vial.json import Json, NativeJson
from vial.loggers import LoggerFactory
from vial.middleware import CallChain, MiddlewareAPI, MiddlewareChain
from vial.parsers import ParserAPI
from vial.req... | [
"vial.request.RequestContext",
"vial.types.Response",
"vial.types.MultiDict",
"vial.parsers.ParserAPI.register_parsers",
"vial.middleware.MiddlewareAPI.register_middlewares",
"vial.middleware.MiddlewareChain",
"vial.errors.NotFoundError",
"vial.errors.MethodNotAllowedError",
"vial.routes.RoutingAPI.... | [((1397, 1414), 'vial.types.Response', 'Response', (['*result'], {}), '(*result)\n', (1405, 1414), False, 'from vial.types import HTTPMethod, LambdaContext, MultiDict, Request, Response\n'), ((2381, 2418), 'vial.parsers.ParserAPI.register_parsers', 'ParserAPI.register_parsers', (['self', 'app'], {}), '(self, app)\n', (... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from baseline.pytorch.classify import ClassifierModelBase
from baseline.model import register_model
def ngrams(x, filtsz, mxlen):
chunks = []
for i in range(mxlen - filtsz + 1):
chunk = x[:, i:i+filtsz, :]
chunks += [chunk]
... | [
"torch.nn.Dropout",
"baseline.model.register_model",
"torch.stack",
"torch.nn.LSTM"
] | [((373, 416), 'baseline.model.register_model', 'register_model', ([], {'task': '"""classify"""', 'name': '"""rnf"""'}), "(task='classify', name='rnf')\n", (387, 416), False, 'from baseline.model import register_model\n'), ((329, 351), 'torch.stack', 'torch.stack', (['chunks', '(1)'], {}), '(chunks, 1)\n', (340, 351), F... |
# -*- coding: utf-8 -*-
"""
IPLoc
Retrieve location information for an IP
"""
import sys
from iploc import IpLoc
from flask import Flask, jsonify, abort, make_response
app = Flask(__name__)
@app.route("/<ip_addr>/")
def ip_search(ip_addr=None):
if ip_addr is None:
abort(make_response("Error: Miss... | [
"flask.jsonify",
"flask.make_response",
"iploc.IpLoc",
"flask.Flask"
] | [((184, 199), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (189, 199), False, 'from flask import Flask, jsonify, abort, make_response\n'), ((1479, 1504), 'iploc.IpLoc', 'IpLoc', (['loc_file', 'ips_file'], {}), '(loc_file, ips_file)\n', (1484, 1504), False, 'from iploc import IpLoc\n'), ((489, 506), 'flas... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Definition of the NSDE algorithm"""
import numpy as np
try:
from openmdao.utils.concurrent import concurrent_eval
except ModuleNotFoundError:
import warnings
warnings.warn("OpenMDAO is not installed. Concurrent evaluation is not available.")
from . import ... | [
"numpy.copy",
"numpy.abs",
"numpy.greater",
"numpy.ceil",
"numpy.random.default_rng",
"numpy.ones",
"numpy.asarray",
"numpy.min",
"numpy.any",
"numpy.max",
"numpy.empty_like",
"numpy.empty",
"numpy.concatenate",
"numpy.linalg.norm",
"warnings.warn",
"numpy.isnan",
"numpy.all",
"ope... | [((221, 309), 'warnings.warn', 'warnings.warn', (['"""OpenMDAO is not installed. Concurrent evaluation is not available."""'], {}), "(\n 'OpenMDAO is not installed. Concurrent evaluation is not available.')\n", (234, 309), False, 'import warnings\n'), ((3826, 3853), 'numpy.random.default_rng', 'np.random.default_rng... |
#!/usr/bin/env python3
# Copyright 2021 Canonincal Ltd.
# See LICENSE file for licensing details.
import logging
import os
import subprocess
from tempfile import NamedTemporaryFile
from ops.charm import CharmBase
from ops.framework import StoredState
from ops.main import main
from ops.model import ActiveStatus, Bloc... | [
"logging.getLogger",
"os.path.exists",
"ops.main.main",
"ops.model.ActiveStatus",
"ops.framework.StoredState",
"subprocess.run",
"os.chmod",
"ops.model.BlockedStatus",
"tempfile.NamedTemporaryFile"
] | [((379, 406), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (396, 406), False, 'import logging\n'), ((470, 483), 'ops.framework.StoredState', 'StoredState', ([], {}), '()\n', (481, 483), False, 'from ops.framework import StoredState\n'), ((5319, 5380), 'ops.main.main', 'main', (['Concour... |
'''
Another version of tree builder, converting list to tree.
where list is actually an array of tree.
@author: <NAME>
'''
from typing import List
from unittest import TestCase
class TreeNode(object):
'''
Definition for a binary tree node.
'''
def __init__(self, val=0, left=None, right=None):
... | [
"unittest.TestCase"
] | [((1408, 1418), 'unittest.TestCase', 'TestCase', ([], {}), '()\n', (1416, 1418), False, 'from unittest import TestCase\n')] |
from __future__ import annotations
from typing import Literal
from prettyqt import constants, core, widgets
from prettyqt.qt import QtWidgets
from prettyqt.utils import InvalidParamError, bidict
GESTURE_CANCEL_POLICY = bidict(
none=QtWidgets.QGesture.GestureCancelPolicy.CancelNone,
all_in_context=QtWidgets.... | [
"prettyqt.utils.InvalidParamError",
"prettyqt.utils.bidict",
"prettyqt.widgets.app"
] | [((223, 363), 'prettyqt.utils.bidict', 'bidict', ([], {'none': 'QtWidgets.QGesture.GestureCancelPolicy.CancelNone', 'all_in_context': 'QtWidgets.QGesture.GestureCancelPolicy.CancelAllInContext'}), '(none=QtWidgets.QGesture.GestureCancelPolicy.CancelNone,\n all_in_context=QtWidgets.QGesture.GestureCancelPolicy.Cancel... |
# -*- coding: utf-8 -*-
"""
Module implementing ProfileDialog.
"""
from PySide2.QtCore import Slot, Qt
from PySide2.QtWidgets import QDialog, QFileDialog, \
QMessageBox, QWidget, QApplication
import datetime
import os.path
from typing import Optional
from .ui_profile import Ui_Dialog
class ProfileDialog(QDial... | [
"PySide2.QtCore.Slot",
"datetime.datetime.now",
"PySide2.QtWidgets.QApplication.instance"
] | [((1038, 1044), 'PySide2.QtCore.Slot', 'Slot', ([], {}), '()\n', (1042, 1044), False, 'from PySide2.QtCore import Slot, Qt\n'), ((1617, 1623), 'PySide2.QtCore.Slot', 'Slot', ([], {}), '()\n', (1621, 1623), False, 'from PySide2.QtCore import Slot, Qt\n'), ((2807, 2830), 'datetime.datetime.now', 'datetime.datetime.now', ... |
from PyQt5.QtCore import QThreadPool, QRunnable, QMetaType, pyqtSignal, QObject
from openspectra.image import BandDescriptor, GreyscaleImage, RGBImage, Image
from openspectra.openspecrtra_tools import OpenSpectraImageTools
from openspectra.openspectra_file import OpenSpectraFile
from openspectra.utils import Logger, L... | [
"PyQt5.QtCore.pyqtSignal",
"openspectra.utils.LogHelper.logger",
"PyQt5.QtCore.QThreadPool.globalInstance",
"openspectra.openspecrtra_tools.OpenSpectraImageTools"
] | [((388, 426), 'openspectra.utils.LogHelper.logger', 'LogHelper.logger', (['"""GreyscaleImageTask"""'], {}), "('GreyscaleImageTask')\n", (404, 426), False, 'from openspectra.utils import Logger, LogHelper\n'), ((453, 479), 'PyQt5.QtCore.pyqtSignal', 'pyqtSignal', (['GreyscaleImage'], {}), '(GreyscaleImage)\n', (463, 479... |
# import json
import os
from ibm_watson import LanguageTranslatorV3
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from dotenv import load_dotenv
load_dotenv()
apikey = os.environ['apikey']
url = os.environ['url']
authenticator = IAMAuthenticator(apikey)
language_translator = LanguageTranslatorV3(
... | [
"ibm_watson.LanguageTranslatorV3",
"ibm_cloud_sdk_core.authenticators.IAMAuthenticator",
"dotenv.load_dotenv"
] | [((163, 176), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (174, 176), False, 'from dotenv import load_dotenv\n'), ((249, 273), 'ibm_cloud_sdk_core.authenticators.IAMAuthenticator', 'IAMAuthenticator', (['apikey'], {}), '(apikey)\n', (265, 273), False, 'from ibm_cloud_sdk_core.authenticators import IAMAuthent... |
import sys
import os
import numpy as np
import cv2
from PIL import Image
from skimage.morphology import binary_dilation
import time
def result_fusion(data_list,label_list=None,save_path=None):
len_ = len(os.listdir(data_list[0]))
count = 0
for item in os.scandir(data_list[0]):
img_list = [item.pat... | [
"skimage.morphology.binary_dilation",
"PIL.Image.fromarray",
"os.listdir",
"PIL.Image.open",
"os.scandir",
"numpy.zeros_like",
"os.path.join",
"numpy.argmax",
"time.time",
"sys.stdout.write"
] | [((266, 290), 'os.scandir', 'os.scandir', (['data_list[0]'], {}), '(data_list[0])\n', (276, 290), False, 'import os\n'), ((1172, 1194), 'sys.stdout.write', 'sys.stdout.write', (['"""\n"""'], {}), "('\\n')\n", (1188, 1194), False, 'import sys\n'), ((1360, 1384), 'os.scandir', 'os.scandir', (['data_list[0]'], {}), '(data... |
from flask.ext.sqlalchemy import SQLAlchemy
from sqlalchemy.dialects.postgresql import HSTORE
from sqlalchemy.ext.mutable import MutableDict
db = SQLAlchemy()
PersonType = db.Enum('driver', 'team-owner', 'crew-chief', 'vehicle-owner', 'team-principal',
'technical-chief', 'race-engineer', name='p... | [
"flask.ext.sqlalchemy.SQLAlchemy",
"sqlalchemy.ext.mutable.MutableDict.as_mutable"
] | [((147, 159), 'flask.ext.sqlalchemy.SQLAlchemy', 'SQLAlchemy', ([], {}), '()\n', (157, 159), False, 'from flask.ext.sqlalchemy import SQLAlchemy\n'), ((1455, 1485), 'sqlalchemy.ext.mutable.MutableDict.as_mutable', 'MutableDict.as_mutable', (['HSTORE'], {}), '(HSTORE)\n', (1477, 1485), False, 'from sqlalchemy.ext.mutabl... |
import numpy as np
import matplotlib.pyplot as plt
from .single_unit import PSTH
def shiftappend(arr, shift, end=None, direction='left'):
if isinstance(end, type(None)):
end = arr[-1]
if direction == 'left':
return np.hstack((arr[arr > shift]-shift, arr[arr < shift]+end-shift))
elif d... | [
"numpy.hstack",
"numpy.size",
"numpy.zeros_like",
"numpy.max",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.bar",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show"
] | [((246, 315), 'numpy.hstack', 'np.hstack', (['(arr[arr > shift] - shift, arr[arr < shift] + end - shift)'], {}), '((arr[arr > shift] - shift, arr[arr < shift] + end - shift))\n', (255, 315), True, 'import numpy as np\n'), ((1975, 2002), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(16, 4)'}), '(figsize=(... |
#Bot class & basic async events
import config
import log
import lottery
import server as server_
import discord
import sys
import re
class main:
def __init__(self, token, name, prefix): #Init bot variables
self.client = discord.Client()
self.token = token
self.name = name
self.... | [
"log.success",
"log.info",
"log.stop",
"lottery.play",
"re.findall",
"sys.exit",
"discord.Client",
"server.find"
] | [((562, 589), 'log.success', 'log.success', (['"""Started bot."""'], {}), "('Started bot.')\n", (573, 589), False, 'import log\n'), ((594, 615), 'log.info', 'log.info', (['"""Bot info:"""'], {}), "('Bot info:')\n", (602, 615), False, 'import log\n'), ((620, 650), 'log.info', 'log.info', (['bot.client.user.name'], {}), ... |
import Bases.ObjectHandler
import pygame
class SceneBase:
def __init__(self, il):
self.next = self
self.IL = il
self.OH = Bases.ObjectHandler.ObjectHandler()
self.interactive_events = None
self.pressed_keys = []
self.environment_type = "DEFAULT"
def process_inp... | [
"pygame.mouse.get_pos"
] | [((546, 568), 'pygame.mouse.get_pos', 'pygame.mouse.get_pos', ([], {}), '()\n', (566, 568), False, 'import pygame\n'), ((573, 595), 'pygame.mouse.get_pos', 'pygame.mouse.get_pos', ([], {}), '()\n', (593, 595), False, 'import pygame\n'), ((705, 727), 'pygame.mouse.get_pos', 'pygame.mouse.get_pos', ([], {}), '()\n', (725... |
# Copyright 2015 Google Inc. 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 applicable law or ... | [
"controllers.utils.LocalizedGlobalHandler._get_accept_language",
"os.path.join",
"common.users.AuthInterceptorWSGIApplication",
"controllers.utils.LocalizedGlobalHandler._get_locale"
] | [((792, 895), 'os.path.join', 'os.path.join', (['appengine_config.BUNDLE_ROOT', '"""tests"""', '"""functional"""', '"""controllers_utils"""', '"""templates"""'], {}), "(appengine_config.BUNDLE_ROOT, 'tests', 'functional',\n 'controllers_utils', 'templates')\n", (804, 895), False, 'import os\n'), ((1224, 1282), 'comm... |
# coding=utf-8
"""
Different utilities for TMDbie
"""
import logging
from .types import TVShow, Person, Movie
from .abstract import TMDbType
log = logging.getLogger(__name__)
log.setLevel(logging.INFO)
def dict_get_by_value(dict_: dict, value):
for k, v in dict_.items():
if v == value:
return... | [
"logging.getLogger"
] | [((148, 175), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (165, 175), False, 'import logging\n')] |
import copy
from mahjong.constants import EAST, FIVE_RED_MAN, FIVE_RED_PIN, FIVE_RED_SOU, TERMINAL_INDICES, CHUN
def is_aka_dora(tile, aka_enabled):
"""
:param tile: int 136 tiles format
:param aka_enabled: depends on table rules
:return: boolean
"""
if not aka_enabled:
return False
... | [
"copy.copy"
] | [((4313, 4331), 'copy.copy', 'copy.copy', (['hand_34'], {}), '(hand_34)\n', (4322, 4331), False, 'import copy\n')] |
import time
from breezycreate2 import Robot
#robot = create.Create('/dev/ttyUSB0')
#robot = Robot('/dev/ttyUSB0', "57600")
robot = Robot('sim')
def write_sensors():
#robot.robot.get_packet(19)
#robot.robot.get_packet(20)
print('distance: ', robot.robot.sensor_state['distance'])
print('angle: ', ro... | [
"breezycreate2.Robot",
"time.sleep"
] | [((132, 144), 'breezycreate2.Robot', 'Robot', (['"""sim"""'], {}), "('sim')\n", (137, 144), False, 'from breezycreate2 import Robot\n'), ((524, 537), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (534, 537), False, 'import time\n'), ((555, 568), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (565, 568), Fals... |
"""Base Class for a Solver. This class contains the different methods that
can be used to solve an environment/problem. There are methods for
mini-batch training, control, etc...
The idea is that this class will contain all the methods that the different
algorithms would need. Then we can simply call this class in the ... | [
"torch.load"
] | [((2223, 2237), 'torch.load', 'torch.load', (['fn'], {}), '(fn)\n', (2233, 2237), False, 'import torch\n')] |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
from functools import partial
import torch
from torch import nn
from timm.models.layers import DropPath
from einops.layers.torch import Reduce
from .layers import DWConv, SPATIAL_FUNC, ChannelMLP, STEM_LAYER
from .misc import reshape2n... | [
"timm.models.layers.DropPath",
"torch.nn.init.ones_",
"torch.nn.Sequential",
"torch.nn.init.xavier_uniform_",
"torch.nn.init.kaiming_normal_",
"torch.nn.init.zeros_",
"einops.layers.torch.Reduce",
"functools.partial",
"torch.nn.Linear",
"torch.nn.Identity",
"torch.nn.init.normal_",
"torch.ones... | [((509, 541), 'functools.partial', 'partial', (['nn.LayerNorm'], {'eps': '(1e-06)'}), '(nn.LayerNorm, eps=1e-06)\n', (516, 541), False, 'from functools import partial\n'), ((3175, 3207), 'functools.partial', 'partial', (['nn.LayerNorm'], {'eps': '(1e-06)'}), '(nn.LayerNorm, eps=1e-06)\n', (3182, 3207), False, 'from fun... |
"""
Middleware for managing internal server errors,
and response with a apt error message
"""
import falcon
class InternalServerErrorManager(object):
"""Middleware for managing internal server errors"""
def process_response(self, request, resp, resource, req_succeeded):
"""
Manages respon... | [
"falcon.HTTPInternalServerError"
] | [((855, 994), 'falcon.HTTPInternalServerError', 'falcon.HTTPInternalServerError', ([], {'title': '"""Internal Server Error"""', 'description': '"""Something went wrong on our side. Please try again later."""'}), "(title='Internal Server Error', description=\n 'Something went wrong on our side. Please try again later... |
#!/usr/bin/env python3
import unittest
import os
import sys
import requests
import utils_test
from multiprocessing import Process
import time
sys.path.append(os.path.abspath('engram'))
import engram
class EngramTestCase(unittest.TestCase):
def setUp(self):
self.process = Process(target = engram.cr... | [
"os.path.abspath",
"multiprocessing.Process",
"time.sleep"
] | [((164, 189), 'os.path.abspath', 'os.path.abspath', (['"""engram"""'], {}), "('engram')\n", (179, 189), False, 'import os\n'), ((294, 347), 'multiprocessing.Process', 'Process', ([], {'target': 'engram.create', 'args': "(':memory', True)"}), "(target=engram.create, args=(':memory', True))\n", (301, 347), False, 'from m... |
#-*- coding:utf-8; mode:python; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*-
import os.path as path
from bes.common.check import check
from bes.common.string_util import string_util
from bes.fs.file_util import file_util
from bes.fs.temp_file import temp_file
from .git import git
from .git_address_util ... | [
"bes.common.check.check.register_class",
"os.path.expanduser"
] | [((1005, 1063), 'bes.common.check.check.register_class', 'check.register_class', (['git_clone_manager'], {'include_seq': '(False)'}), '(git_clone_manager, include_seq=False)\n', (1025, 1063), False, 'from bes.common.check import check\n'), ((582, 607), 'os.path.expanduser', 'path.expanduser', (['root_dir'], {}), '(root... |
#!/usr/bin/python3
"""
This script sends status of the lb service to SLS
"""
import argparse
import re
import sys
import time
import logging
import logging.config
import json
from datetime import datetime
import os
import requests
def get_arguments():
""" Parse command line arguments"""
parser = argpars... | [
"logging.getLogger",
"logging.StreamHandler",
"argparse.ArgumentParser",
"logging.Formatter",
"json.dumps",
"requests.get",
"datetime.datetime.now",
"os.popen"
] | [((313, 381), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Gather heavy users of lxplus."""'}), "(description='Gather heavy users of lxplus.')\n", (336, 381), False, 'import argparse\n'), ((4368, 4395), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (4385... |
import os
import subprocess
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.nn.functional import interpolate
from loguru import logger
from tqdm import tqdm
import numpy as np
import wandb
from draw_concat import draw_concat
from generate_noise import generate... | [
"torch.optim.lr_scheduler.MultiStepLR",
"models.save_networks",
"numpy.mean",
"generate_noise.generate_spatial_noise",
"minecraft.level_utils.clear_empty_world",
"torch.nn.ReplicationPad3d",
"minecraft.level_renderer.render_minecraft",
"subprocess.call",
"models.calc_gradient_penalty",
"draw_conca... | [((1431, 1484), 'minecraft.level_utils.clear_empty_world', 'clear_empty_world', (['opt.output_dir', '"""Curr_Empty_World"""'], {}), "(opt.output_dir, 'Curr_Empty_World')\n", (1448, 1484), False, 'from minecraft.level_utils import one_hot_to_blockdata_level, save_level_to_world, clear_empty_world\n'), ((2866, 2970), 'to... |
# coding: utf-8
# Copyright (c) Materials Virtual Lab
# Distributed under the terms of the BSD License.
import joblib
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from veidt.abstract import Model
class MultiLayerPerceptron(Model):
"""
Basic neural netw... | [
"keras.optimizers.Adam",
"keras.models.load_model",
"sklearn.model_selection.train_test_split",
"keras.models.Sequential",
"sklearn.preprocessing.StandardScaler",
"joblib.load",
"keras.layers.Dense",
"joblib.dump"
] | [((1948, 1961), 'keras.optimizers.Adam', 'Adam', (['adam_lr'], {}), '(adam_lr)\n', (1952, 1961), False, 'from keras.optimizers import Adam\n'), ((2005, 2071), 'sklearn.model_selection.train_test_split', 'train_test_split', (['scaled_descriptors', 'outputs'], {'test_size': 'test_size'}), '(scaled_descriptors, outputs, t... |
import numpy as np
import tkinter as tk
from PIL import ImageTk, Image
class Colors:
YES = '#51b442'
NO = '#a03939'
NEUTRAL = '#cacaca'
BLACK = '#2e2e2e'
ALARM = '#c30b0b'
class Popup:
def __init__(self,
title='',
text='',
text_color=Colors.BL... | [
"PIL.Image.fromarray",
"PIL.Image.open",
"tkinter.Canvas",
"tkinter.Tk",
"tkinter.Label",
"tkinter.Frame",
"PIL.ImageTk.PhotoImage"
] | [((639, 646), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (644, 646), True, 'import tkinter as tk\n'), ((833, 868), 'tkinter.Frame', 'tk.Frame', (['self.root'], {'pady': '(4)', 'padx': '(6)'}), '(self.root, pady=4, padx=6)\n', (841, 868), True, 'import tkinter as tk\n'), ((989, 1075), 'tkinter.Label', 'tk.Label', (['text_... |
import dash_core_components as dcc
import dash_html_components as html
from plotly import graph_objs as go
def render():
return html.Div(children=[
html.H1(children='{{cookiecutter.project_slug}}'),
html.Div(children='Dash: A web application framework for Python.'),
dcc.Graph(
... | [
"plotly.graph_objs.Layout",
"plotly.graph_objs.Bar",
"dash_html_components.Div",
"dash_html_components.H1"
] | [((163, 212), 'dash_html_components.H1', 'html.H1', ([], {'children': '"""{{cookiecutter.project_slug}}"""'}), "(children='{{cookiecutter.project_slug}}')\n", (170, 212), True, 'import dash_html_components as html\n'), ((223, 289), 'dash_html_components.Div', 'html.Div', ([], {'children': '"""Dash: A web application fr... |
# uncompyle6 version 3.7.4
# Python bytecode 3.7 (3394)
# Decompiled from: Python 3.7.9 (tags/v3.7.9:13c94747c7, Aug 17 2020, 18:58:18) [MSC v.1900 64 bit (AMD64)]
# Embedded file name: T:\InGame\Gameplay\Scripts\Server\reservation\unreserve_object_element.py
# Compiled at: 2020-09-08 20:23:33
# Size of source mod 2**3... | [
"sims4.tuning.tunable.TunableSimMinute"
] | [((1641, 1786), 'sims4.tuning.tunable.TunableSimMinute', 'TunableSimMinute', ([], {'description': '"""The interaction will wait this amount of time after the beginning before running the element"""', 'default': '(2)'}), "(description=\n 'The interaction will wait this amount of time after the beginning before runnin... |
# coding=utf-8
# ------------------------------------------------------------------------
# Created by <NAME> on 2013-03-20
# Copyright (c) 2013 <NAME>. All rights reserved.
# ------------------------------------------------------------------------
from __future__ import absolute_import
import json
import logging
t... | [
"logging.getLogger",
"django.utils.translation.ugettext_lazy",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"feincms.module.medialibrary.thumbnail.admin_thumbnail",
"django.contrib.admin.site.register",
"json.dumps",
"django.utils.decorators.method_decorator",
"django.core.urlreso... | [((1303, 1331), 'logging.getLogger', 'logging.getLogger', (['app_label'], {}), '(app_label)\n', (1320, 1331), False, 'import logging\n'), ((7831, 7870), 'django.utils.decorators.method_decorator', 'method_decorator', (['staff_member_required'], {}), '(staff_member_required)\n', (7847, 7870), False, 'from django.utils.d... |
"""
Author: ~wy (https://github.com/wy)
Date: 25/01/2019
Description:
A simulator for the Three Dice game (Sic Bo) played in Macau casinos and elsewhere.
Important simplification is that all three dice are treated equally
which makes the maths a bit easier.
Key concepts:
Criteria - does a dice configuration match a bet... | [
"random.randint"
] | [((3553, 3573), 'random.randint', 'random.randint', (['(1)', '(6)'], {}), '(1, 6)\n', (3567, 3573), False, 'import random\n'), ((3575, 3595), 'random.randint', 'random.randint', (['(1)', '(6)'], {}), '(1, 6)\n', (3589, 3595), False, 'import random\n'), ((3597, 3617), 'random.randint', 'random.randint', (['(1)', '(6)'],... |
#!/usr/bin/python3
"""
Module for querying weather forecast data from OpenWeatherMap and storage in database
"""
import json
import requests
import datetime
# Set up logging
import logging
import logging_plus
logger = logging_plus.getLogger(__name__)
logger.addHandler(logging.NullHandler())
# Defaults
# Current / hou... | [
"logging.NullHandler",
"datetime.datetime.fromtimestamp",
"datetime.datetime.strptime",
"json.dumps",
"requests.get",
"datetime.datetime.now",
"logging_plus.getLogger",
"datetime.timedelta"
] | [((219, 251), 'logging_plus.getLogger', 'logging_plus.getLogger', (['__name__'], {}), '(__name__)\n', (241, 251), False, 'import logging_plus\n'), ((270, 291), 'logging.NullHandler', 'logging.NullHandler', ([], {}), '()\n', (289, 291), False, 'import logging\n'), ((1317, 1350), 'requests.get', 'requests.get', (['url'],... |
"""
This is the setup module for the example project.
Based on:
- https://packaging.python.org/distributing/
- https://github.com/pypa/sampleproject/blob/master/setup.py
- https://blog.ionelmc.ro/2014/05/25/python-packaging/#the-structure
"""
# Standard Python Libraries
from glob import glob
from os.path import base... | [
"os.path.basename",
"glob.glob"
] | [((2448, 2464), 'glob.glob', 'glob', (['"""src/*.py"""'], {}), "('src/*.py')\n", (2452, 2464), False, 'from glob import glob\n'), ((2417, 2431), 'os.path.basename', 'basename', (['path'], {}), '(path)\n', (2425, 2431), False, 'from os.path import basename, splitext\n')] |
"""
Data freshness:
--------------
Calculate freshness for all datasets in HDX.
"""
import datetime
import logging
import re
from parser import ParserError
from urllib.parse import urlparse
from dateutil import parser
from hdx.data.dataset import Dataset
from hdx.data.hdxobject import HDXError
from hdx.data.resource... | [
"logging.getLogger",
"hdx.freshness.testdata.serialize.serialize_hashresults",
"re.compile",
"sqlalchemy.exists",
"hdx.freshness.testdata.serialize.serialize_now",
"datetime.timedelta",
"sqlalchemy.and_",
"datetime.datetime",
"hdx.freshness.database.dbrun.DBRun.run_number.desc",
"hdx.freshness.dat... | [((1033, 1060), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1050, 1060), False, 'import logging\n'), ((1138, 1162), 're.compile', 're.compile', (['"""\\\\((.*)\\\\)"""'], {}), "('\\\\((.*)\\\\)')\n", (1148, 1162), False, 'import re\n'), ((4610, 4686), 'hdx.utilities.dictandlist.list_d... |
# -*- coding: utf-8 -*-
#
# views.py
# wide-language-index-demo
#
"""
Public facing frontpage.
"""
import json
import random
from flask import (Blueprint, request, render_template, redirect)
from . import forms
from ..index import util
blueprint = Blueprint('public', __name__, static_folder="../static")
@bluep... | [
"flask.render_template",
"flask.request.args.get",
"random.choice",
"json.dumps",
"flask.redirect",
"flask.Blueprint"
] | [((255, 311), 'flask.Blueprint', 'Blueprint', (['"""public"""', '__name__'], {'static_folder': '"""../static"""'}), "('public', __name__, static_folder='../static')\n", (264, 311), False, 'from flask import Blueprint, request, render_template, redirect\n'), ((388, 416), 'flask.request.args.get', 'request.args.get', (['... |
# ### Part 2 - The Northwind Database
# Using `sqlite3`, connect to the given `northwind_small.sqlite3` database.
import sqlite3
connection = sqlite3.connect('northwind_small.sqlite3')
cursor = connection.cursor()
print("CURSOR", cursor)
# 
# Above is an e... | [
"sqlite3.connect"
] | [((143, 185), 'sqlite3.connect', 'sqlite3.connect', (['"""northwind_small.sqlite3"""'], {}), "('northwind_small.sqlite3')\n", (158, 185), False, 'import sqlite3\n')] |
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any... | [
"qiskit.qobj.QobjHeader.from_dict",
"qiskit.qobj.PulseQobj.from_dict",
"qiskit.qobj.QasmQobj.from_dict"
] | [((2355, 2383), 'qiskit.qobj.QobjHeader.from_dict', 'QobjHeader.from_dict', (['config'], {}), '(config)\n', (2375, 2383), False, 'from qiskit.qobj import QobjHeader, QasmQobj, PulseQobj\n'), ((2825, 2854), 'qiskit.qobj.QasmQobj.from_dict', 'QasmQobj.from_dict', (['qobj_dict'], {}), '(qobj_dict)\n', (2843, 2854), False,... |
"""Main module."""
import warnings
import os
import sys
import re
from six.moves import input
from activelearner import dataset, models, strategies, labeler, utils
# Define active learning labeling modes
def interactive_mode(data, keywords, querier, oracle, save_every,
path, file_name, print_p... | [
"activelearner.labeler.AskOracle",
"six.moves.input",
"re.compile",
"os.path.join",
"os.getcwd",
"warnings.warn",
"activelearner.utils.save_object"
] | [((5402, 5440), 're.compile', 're.compile', (['"""activelearner.strategies"""'], {}), "('activelearner.strategies')\n", (5412, 5440), False, 'import re\n'), ((6618, 6716), 'activelearner.labeler.AskOracle', 'labeler.AskOracle', ([], {'feature_type': 'feature_type', 'label_name': 'label_name', 'feature_name': 'feature_n... |
from PIL import Image
import numpy as np
from skimage import transform
IMG_HEIGHT = 100
IMG_WIDTH = 100
def load(filename):
np_image = Image.open(filename)
np_image = np.array(np_image).astype('float32')/255
# (IMG_HEIGHT, IMG_WIDTH, 3))
np_image = transform.resize(np_image, (IMG_HEIGHT, IMG_WIDTH, 3... | [
"numpy.array",
"numpy.expand_dims",
"PIL.Image.open",
"skimage.transform.resize"
] | [((142, 162), 'PIL.Image.open', 'Image.open', (['filename'], {}), '(filename)\n', (152, 162), False, 'from PIL import Image\n'), ((268, 322), 'skimage.transform.resize', 'transform.resize', (['np_image', '(IMG_HEIGHT, IMG_WIDTH, 3)'], {}), '(np_image, (IMG_HEIGHT, IMG_WIDTH, 3))\n', (284, 322), False, 'from skimage imp... |
from __future__ import print_function
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
import sys
import json
SCOPES = ['https://www.googleapis.com/auth/d... | [
"googleapiclient.discovery.build",
"google.oauth2.credentials.Credentials.from_authorized_user_file",
"sys.exit"
] | [((1111, 1150), 'googleapiclient.discovery.build', 'build', (['"""drive"""', '"""v3"""'], {'credentials': 'creds'}), "('drive', 'v3', credentials=creds)\n", (1116, 1150), False, 'from googleapiclient.discovery import build\n'), ((649, 716), 'google.oauth2.credentials.Credentials.from_authorized_user_file', 'Credentials... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 1999-2017 Alibaba Group Holding Ltd.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENS... | [
"datetime.datetime",
"odps.models.Schema.from_lists",
"odps.compat.Decimal",
"odps.tests.core.TestBase.setUp",
"odps.compat.unittest.main",
"pstats.Stats",
"odps.tests.core.TestBase.teardown",
"cProfile.Profile",
"time.time"
] | [((5042, 5057), 'odps.compat.unittest.main', 'unittest.main', ([], {}), '()\n', (5055, 5057), False, 'from odps.compat import unittest, Decimal\n'), ((1295, 1315), 'odps.tests.core.TestBase.setUp', 'TestBase.setUp', (['self'], {}), '(self)\n', (1309, 1315), False, 'from odps.tests.core import TestBase\n'), ((1564, 1596... |
"""
Functions in this file allow redirecting stdout used by Fortran and C
extensions to a different file or devnull or stderr.
Example usage (same should work with stdout_redirect_1()):
# No print to stdout:
with stdout_redirect_2():
call_fortran_or_c_code()
# OR:
with stdout_redirect_1():
call_fortran_or_c_c... | [
"os.dup2",
"os.close",
"io.BytesIO",
"os.dup",
"sys.stdout.close",
"ctypes.CDLL",
"os.fdopen",
"tempfile.TemporaryFile",
"sys.stdout.fileno",
"ctypes.c_void_p.in_dll"
] | [((1741, 1758), 'ctypes.CDLL', 'ctypes.CDLL', (['None'], {}), '(None)\n', (1752, 1758), False, 'import ctypes\n'), ((1770, 1808), 'ctypes.c_void_p.in_dll', 'ctypes.c_void_p.in_dll', (['libc', '"""stdout"""'], {}), "(libc, 'stdout')\n", (1792, 1808), False, 'import ctypes\n'), ((906, 925), 'sys.stdout.fileno', 'sys.stdo... |
#!/usr/bin/env python
import csv, os
def writeOut(termdic,termcodes,fileout,type):
w = open(fileout,"w")
if type ==1:
wr = csv.writer(w,dialect='excel',delimiter="\t")
for term, code in zip(termdic,termcodes):
score = code[0][1]
codigo = code[0][0]
if code[0]... | [
"os.path.exists",
"csv.writer",
"os.makedirs"
] | [((1320, 1366), 'csv.writer', 'csv.writer', (['w'], {'dialect': '"""excel"""', 'delimiter': '"""\t"""'}), "(w, dialect='excel', delimiter='\\t')\n", (1330, 1366), False, 'import csv, os\n'), ((140, 186), 'csv.writer', 'csv.writer', (['w'], {'dialect': '"""excel"""', 'delimiter': '"""\t"""'}), "(w, dialect='excel', deli... |
#!/usr/bin/env python
import json
import os
import re
import numpy
from gem.cnvReport import BaseDocumentHtml,BaseStatistical
class BuildHtmlAssembly(BaseDocumentHtml):
"""Base Mapping step"""
def titleDocument(self):
'''Title Web Document'''
self.vContent.append(" <H1 id=\"title\"> <U>... | [
"os.path.abspath",
"os.path.basename",
"json.dump"
] | [((4762, 4796), 'os.path.basename', 'os.path.basename', (['self.source_file'], {}), '(self.source_file)\n', (4778, 4796), False, 'import os\n'), ((6982, 7016), 'os.path.basename', 'os.path.basename', (['self.source_file'], {}), '(self.source_file)\n', (6998, 7016), False, 'import os\n'), ((12653, 12694), 'json.dump', '... |
import argparse
import os
import importlib
import tensorflow as tf
from modules.compound_model import CompoundModel
from modules.regressor_trainer import train_regressor
from modules.compound_model_trainer import train_compound_model
from modules.training_helper import evaluate_regression_MSE, get_tensorflow_d... | [
"modules.experiment_helper.parse_experiment_settings",
"importlib.import_module",
"argparse.ArgumentParser",
"modules.compound_model.CompoundModel",
"tensorflow.config.experimental.set_memory_growth",
"tensorflow.summary.create_file_writer",
"os.path.isdir",
"os.mkdir",
"tensorflow.get_logger",
"t... | [((2466, 2540), 'modules.experiment_helper.parse_experiment_settings', 'parse_experiment_settings', (['experiment_path'], {'only_this_sub_exp': 'sub_exp_name'}), '(experiment_path, only_this_sub_exp=sub_exp_name)\n', (2491, 2540), False, 'from modules.experiment_helper import parse_experiment_settings\n'), ((3686, 3725... |
from bs4 import element
from lark import Lark
from parsers import SPEED_GRAMMAR
parser = Lark(SPEED_GRAMMAR)
class ParseError(Exception):
pass
class TableRowHelper:
"""A simplified interface around a set of table rows from bs4.
This abstracts all the evil stuff like rowspan and colspan so that the dat... | [
"lark.Lark"
] | [((91, 110), 'lark.Lark', 'Lark', (['SPEED_GRAMMAR'], {}), '(SPEED_GRAMMAR)\n', (95, 110), False, 'from lark import Lark\n')] |
import copy
import numpy as np
from PIL import Image
from torch.utils.data.dataset import Dataset
class CleanLabelDataset(Dataset):
"""Clean-label dataset.
Args:
dataset (Dataset): The dataset to be wrapped.
adv_dataset_path (str): The adversarially perturbed dataset path.
transform ... | [
"PIL.Image.fromarray",
"numpy.where",
"numpy.nonzero",
"copy.deepcopy",
"numpy.load"
] | [((688, 710), 'copy.deepcopy', 'copy.deepcopy', (['dataset'], {}), '(dataset)\n', (701, 710), False, 'import copy\n'), ((2366, 2386), 'PIL.Image.fromarray', 'Image.fromarray', (['img'], {}), '(img)\n', (2381, 2386), False, 'from PIL import Image\n'), ((735, 760), 'numpy.load', 'np.load', (['adv_dataset_path'], {}), '(a... |
import os
import sys
import json
cfg = xmlsettings.XMLSettings(os.path.join(sys.path[0],'settings.xml'))
with open(os.path.join(sys.path[0],'config.json')) as data_file:
data = json.load(data_file)
| [
"json.load",
"os.path.join"
] | [((64, 105), 'os.path.join', 'os.path.join', (['sys.path[0]', '"""settings.xml"""'], {}), "(sys.path[0], 'settings.xml')\n", (76, 105), False, 'import os\n'), ((187, 207), 'json.load', 'json.load', (['data_file'], {}), '(data_file)\n', (196, 207), False, 'import json\n'), ((117, 157), 'os.path.join', 'os.path.join', ([... |
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
"""This module demonstrates keras api and shows that the saved model should reproduce the same results as the
presaved model.
https://www.tensorflow.org/guide/keras/train_and_evaluate#training_evaluation_from_tfdata_datasets
""... | [
"tensorflow.data.Dataset.from_tensor_slices",
"tensorflow.keras.datasets.mnist.load_data",
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.keras.metrics.SparseCategoricalAccuracy",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.models.load_model",
"tensorflow.keras.Input",
"te... | [((1638, 1670), 'tensorflow.keras.datasets.mnist.load_data', 'keras.datasets.mnist.load_data', ([], {}), '()\n', (1668, 1670), False, 'from tensorflow import keras\n'), ((2201, 2255), 'tensorflow.data.Dataset.from_tensor_slices', 'tf.data.Dataset.from_tensor_slices', (['(x_train, y_train)'], {}), '((x_train, y_train))\... |
#!/usr/bin/python
import sqlite3
uId = 4
con = sqlite3.connect('ydb.db')
with con:
cur = con.cursor()
cur.execute("SELECT name, price FROM cars WHERE Id=:Id", {"Id": uId})
row = cur.fetchone()
print(f"{row[0]}, {row[1]}")
| [
"sqlite3.connect"
] | [((50, 75), 'sqlite3.connect', 'sqlite3.connect', (['"""ydb.db"""'], {}), "('ydb.db')\n", (65, 75), False, 'import sqlite3\n')] |
import numpy as np
from joblib import Memory
import typing
from typing import Union
from typing import Iterator
from typing import Tuple
from typing import TypeVar
try:
import typing_extensions # noqa
TYPING_EXTENSION_INSTALLED = True
except ImportError:
TYPING_EXTENSION_INSTALLED = False
if typing.TY... | [
"typing.TypeVar"
] | [((1001, 1021), 'typing.TypeVar', 'TypeVar', (['"""ArrayLike"""'], {}), "('ArrayLike')\n", (1008, 1021), False, 'from typing import TypeVar\n'), ((1038, 1062), 'typing.TypeVar', 'TypeVar', (['"""EstimatorType"""'], {}), "('EstimatorType')\n", (1045, 1062), False, 'from typing import TypeVar\n'), ((1071, 1087), 'typing.... |
import urllib.parse
import cachetools
from common import database as db
from sqlalchemy.orm import joinedload
FEED_LOOKUP_CACHE = cachetools.LRUCache(maxsize=200)
def patch_blogspot(innetloc):
assert isinstance(innetloc, str), "Expected str, recieved %s" % type(innetloc)
# Blogspot domains are coerced to ".co... | [
"sqlalchemy.orm.joinedload",
"cachetools.LRUCache"
] | [((137, 169), 'cachetools.LRUCache', 'cachetools.LRUCache', ([], {'maxsize': '(200)'}), '(maxsize=200)\n', (156, 169), False, 'import cachetools\n'), ((820, 844), 'sqlalchemy.orm.joinedload', 'joinedload', (['"""feed_entry"""'], {}), "('feed_entry')\n", (830, 844), False, 'from sqlalchemy.orm import joinedload\n')] |
# -*- coding: utf-8 -*-
# pylint: disable=too-many-lines
import heapq
from binascii import hexlify
from collections import namedtuple
from raiden.encoding.signing import recover_publickey
from raiden.transfer.architecture import TransitionResult
from raiden.transfer.balance_proof import signing_data
from raiden.transf... | [
"raiden.transfer.state.UnlockPartialProofState",
"raiden.transfer.mediated_transfer.events.SendBalanceProof",
"raiden.transfer.mediated_transfer.events.SendMediatedTransfer",
"binascii.hexlify",
"raiden.transfer.merkle_tree.merkleroot",
"raiden.transfer.architecture.TransitionResult",
"raiden.transfer.s... | [((1802, 1865), 'collections.namedtuple', 'namedtuple', (['"""TransactionOrder"""', "('block_number', 'transaction')"], {}), "('TransactionOrder', ('block_number', 'transaction'))\n", (1812, 1865), False, 'from collections import namedtuple\n'), ((3033, 3193), 'raiden.transfer.balance_proof.signing_data', 'signing_data... |
from pathlib import Path
from .build import DocBuilder
def finalize_builddir(repo_name):
'Bookkeeping on the docs build directory'
root = Path('_build') / repo_name
with open(root / '.nojekyll', 'w') as fh:
fh.write('')
def build_root(repo_name):
'''Build the top-level documentation.
Se... | [
"pathlib.Path"
] | [((148, 162), 'pathlib.Path', 'Path', (['"""_build"""'], {}), "('_build')\n", (152, 162), False, 'from pathlib import Path\n')] |
from django.contrib import admin
from blog.models import *
# Register your models here.
admin.site.register(Blog)
class TagAdmin(admin.ModelAdmin):
readonly = ['slug']
admin.site.register(Tag, TagAdmin)
| [
"django.contrib.admin.site.register"
] | [((90, 115), 'django.contrib.admin.site.register', 'admin.site.register', (['Blog'], {}), '(Blog)\n', (109, 115), False, 'from django.contrib import admin\n'), ((175, 209), 'django.contrib.admin.site.register', 'admin.site.register', (['Tag', 'TagAdmin'], {}), '(Tag, TagAdmin)\n', (194, 209), False, 'from django.contri... |
import random
def attack(attacker_i, defender_i, entities):
attacker = entities[attacker_i]
defender = entities[defender_i]
# Calculate values
hit_chance = attacker.accuracy * (1 - defender.evasion)
bypass_armor_chance = 1 - defender.armor
damage_normal = attacker.damage
damage_armor = at... | [
"random.random"
] | [((465, 480), 'random.random', 'random.random', ([], {}), '()\n', (478, 480), False, 'import random\n'), ((555, 570), 'random.random', 'random.random', ([], {}), '()\n', (568, 570), False, 'import random\n')] |
# name,level,published,created_on,review_count,avg_rating
# Product 1,1,True,2019-07-10,10,4.3
from dbexport.config import Session
from dbexport.models import Review, Product
from sqlalchemy.sql import func
import json
session = Session()
review_statement = (
session.query(
Review.product_id,
f... | [
"sqlalchemy.sql.func.avg",
"sqlalchemy.sql.func.count",
"json.dump",
"dbexport.config.Session"
] | [((233, 242), 'dbexport.config.Session', 'Session', ([], {}), '()\n', (240, 242), False, 'from dbexport.config import Session\n'), ((1084, 1106), 'json.dump', 'json.dump', (['products', 'f'], {}), '(products, f)\n', (1093, 1106), False, 'import json\n'), ((319, 334), 'sqlalchemy.sql.func.count', 'func.count', (['"""*""... |
from OpenDutchWordnet import Wn_grid_parser
from tqdm import tqdm
from typing import NamedTuple
class Lex(NamedTuple):
id: str
lemma: str
pos: str
sense_id: str
sense_nr: int
synset_id: str
Binary = tuple[str, str]
hypers: set[Binary] = set()
antos: set[Binary] = s... | [
"OpenDutchWordnet.Wn_grid_parser",
"tqdm.tqdm"
] | [((519, 554), 'OpenDutchWordnet.Wn_grid_parser', 'Wn_grid_parser', (['Wn_grid_parser.odwn'], {}), '(Wn_grid_parser.odwn)\n', (533, 554), False, 'from OpenDutchWordnet import Wn_grid_parser\n'), ((683, 696), 'tqdm.tqdm', 'tqdm', (['lex_gen'], {}), '(lex_gen)\n', (687, 696), False, 'from tqdm import tqdm\n'), ((1123, 113... |
'''
CVPR 2020 submission, Paper ID 6791
Source code for 'Learning to Cartoonize Using White-Box Cartoon Representations'
'''
import tensorflow as tf
import numpy as np
import tensorflow.contrib.slim as slim
def adaptive_instance_norm(content, style, epsilon=1e-5):
c_mean, c_var = tf.nn.moments(c... | [
"tensorflow.shape",
"tensorflow.variable_scope",
"tensorflow.transpose",
"tensorflow.nn.l2_normalize",
"tensorflow.nn.moments",
"tensorflow.random_normal_initializer",
"tensorflow.stop_gradient",
"tensorflow.sqrt",
"tensorflow.matmul",
"tensorflow.nn.softmax",
"tensorflow.reshape",
"tensorflow... | [((305, 356), 'tensorflow.nn.moments', 'tf.nn.moments', (['content'], {'axes': '[1, 2]', 'keep_dims': '(True)'}), '(content, axes=[1, 2], keep_dims=True)\n', (318, 356), True, 'import tensorflow as tf\n'), ((378, 427), 'tensorflow.nn.moments', 'tf.nn.moments', (['style'], {'axes': '[1, 2]', 'keep_dims': '(True)'}), '(s... |
# coding: utf-8
import logging
from behave import *
import foods.kebab # type: ignore
import foods.pizza # type: ignore
from foods.formula import Formula
logger = logging.getLogger(__name__)
use_step_matcher("parse")
foods_ = []
@given(
"Mister Patate's favorite foods (a {food} is represented by a {sauce} a... | [
"logging.getLogger",
"foods.formula.Formula"
] | [((168, 195), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (185, 195), False, 'import logging\n'), ((711, 741), 'foods.formula.Formula', 'Formula', (['context.drink', 'foods_'], {}), '(context.drink, foods_)\n', (718, 741), False, 'from foods.formula import Formula\n')] |
from data_warehouse.db import connect
from data_warehouse.sql_queries import copy_table_queries, insert_table_queries
def load_staging_tables(cur, conn):
for query in copy_table_queries:
cur.execute(query)
conn.commit()
def insert_tables(cur, conn):
for query in insert_table_queries:
... | [
"data_warehouse.db.connect"
] | [((392, 401), 'data_warehouse.db.connect', 'connect', ([], {}), '()\n', (399, 401), False, 'from data_warehouse.db import connect\n')] |
# import necessary libraries
from flask import Flask, render_template, request
import pickle
# create instance of Flask app
app = Flask(__name__)
# create route that renders index.html template
@app.route("/")
def home():
return render_template("index.html")
@app.route("/purpose")
def purpose():
return rend... | [
"flask.render_template",
"flask.Flask"
] | [((131, 146), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (136, 146), False, 'from flask import Flask, render_template, request\n'), ((236, 265), 'flask.render_template', 'render_template', (['"""index.html"""'], {}), "('index.html')\n", (251, 265), False, 'from flask import Flask, render_template, requ... |
from markov.chain import MarkovChain
def test_chain():
chain = MarkovChain([1, 2, 3, 1, 2])
assert len(chain.states) == 3
assert isinstance(chain.transition, dict)
assert isinstance(chain.transition[1], list)
assert chain.sample_next(1) == 2
assert len(chain.build_sequence(10, 1)) == 10
| [
"markov.chain.MarkovChain"
] | [((69, 97), 'markov.chain.MarkovChain', 'MarkovChain', (['[1, 2, 3, 1, 2]'], {}), '([1, 2, 3, 1, 2])\n', (80, 97), False, 'from markov.chain import MarkovChain\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.3 on 2018-08-01 03:24
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('mridata', '0012_auto_20180731_1714'),
]
operations = [
migrations.RemoveField(
... | [
"django.db.migrations.RemoveField"
] | [((292, 377), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""tempdata"""', 'name': '"""thumbnail_fftshift_along_z"""'}), "(model_name='tempdata', name='thumbnail_fftshift_along_z'\n )\n", (314, 377), False, 'from django.db import migrations\n')] |
#!/usr/bin/env python
from readVNADataSKRF import plot
# WARNING:
# Write file names ending in .vna
# Do not include .txt (do not use .vna.txt)
options = [
#['Redo_VNA', 'TP_1p4m_35_ChD0.vna'],
#['Redo_VNA', 'TP_1p4m_35_ChD1_redo_v1.vna'],
#['Redo_VNA', 'TP_1p4m_35_ChCMD_redo_v1.v... | [
"readVNADataSKRF.plot"
] | [((7989, 8035), 'readVNADataSKRF.plot', 'plot', (['basename', 'data_directory', 'plot_directory'], {}), '(basename, data_directory, plot_directory)\n', (7993, 8035), False, 'from readVNADataSKRF import plot\n')] |
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc
import commons_pb2 as commons__pb2
class DiagnosisDBStub(object):
"""Missing associated documentation comment in .proto file"""
def __init__(self, channel):
"""Constructor.
Args:
channel: A grpc.Ch... | [
"grpc.unary_stream_rpc_method_handler",
"grpc.method_handlers_generic_handler",
"grpc.unary_unary_rpc_method_handler",
"grpc.experimental.unary_stream",
"grpc.experimental.unary_unary"
] | [((3333, 3411), 'grpc.method_handlers_generic_handler', 'grpc.method_handlers_generic_handler', (['"""proto.DiagnosisDB"""', 'rpc_method_handlers'], {}), "('proto.DiagnosisDB', rpc_method_handlers)\n", (3369, 3411), False, 'import grpc\n'), ((2436, 2622), 'grpc.unary_unary_rpc_method_handler', 'grpc.unary_unary_rpc_met... |
# coding=utf-8
from __future__ import absolute_import, division, print_function, unicode_literals
from contextlib import contextmanager
from flask_sqlalchemy import SQLAlchemy
from webtest import TestApp
from scout_apm.compat import kwargs_only
from scout_apm.flask.sqlalchemy import instrument_sqlalchemy
from tests.... | [
"tests.integration.test_flask.app_with_scout",
"flask_sqlalchemy.SQLAlchemy",
"webtest.TestApp",
"scout_apm.flask.sqlalchemy.instrument_sqlalchemy"
] | [((451, 473), 'tests.integration.test_flask.app_with_scout', 'flask_app_with_scout', ([], {}), '()\n', (471, 473), True, 'from tests.integration.test_flask import app_with_scout as flask_app_with_scout\n'), ((625, 640), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (635, 640), False, 'from flas... |
# This file is mainly derived from https://github.com/openai/baselines.
from collections import deque
import os.path as osp
import time
import csv
import json
from gym.core import Wrapper
import numpy as np
from .vec_env import VecEnvWrapper
class Monitor(Wrapper):
EXT = "monitor.csv"
f = None
def __in... | [
"collections.deque",
"json.dumps",
"os.path.join",
"gym.core.Wrapper.__init__",
"numpy.zeros",
"os.path.isdir",
"time.time"
] | [((435, 466), 'gym.core.Wrapper.__init__', 'Wrapper.__init__', (['self'], {'env': 'env'}), '(self, env=env)\n', (451, 466), False, 'from gym.core import Wrapper\n'), ((490, 501), 'time.time', 'time.time', ([], {}), '()\n', (499, 501), False, 'import time\n'), ((4528, 4539), 'time.time', 'time.time', ([], {}), '()\n', (... |
# Generated by Django 3.0.8 on 2021-03-31 00:14
import datetime
from django.db import migrations, models
from django.utils.timezone import utc
class Migration(migrations.Migration):
dependencies = [
('modulector', '0031_auto_20210330_0044'),
]
operations = [
migrations.AlterField(
... | [
"datetime.datetime",
"django.db.models.CharField"
] | [((401, 444), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'null': '(True)'}), '(max_length=100, null=True)\n', (417, 444), False, 'from django.db import migrations, models\n'), ((610, 671), 'datetime.datetime', 'datetime.datetime', (['(2021)', '(3)', '(31)', '(0)', '(14)', '(25)', '(6... |
import datetime
from dateutil.relativedelta import relativedelta
from parlai.agents.programr.parser.template.nodes.base import TemplateNode
# from parlai.agents.programr.utils.logging.ylogger import YLogger
import parlai.utils.logging as logging
from parlai.agents.programr.utils.text.text import TextUtils
class Tem... | [
"dateutil.relativedelta.relativedelta",
"parlai.agents.programr.parser.template.nodes.base.TemplateNode.__init__",
"parlai.utils.logging.error",
"datetime.datetime.strptime",
"parlai.utils.logging.warning",
"parlai.utils.logging.debug",
"parlai.agents.programr.utils.text.text.TextUtils.tag_from_text"
] | [((386, 413), 'parlai.agents.programr.parser.template.nodes.base.TemplateNode.__init__', 'TemplateNode.__init__', (['self'], {}), '(self)\n', (407, 413), False, 'from parlai.agents.programr.parser.template.nodes.base import TemplateNode\n'), ((1439, 1487), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['... |
import os
from PIL import Image
def resize(file_path="./.tmp/bg.jpg", size=(128, 128)):
try:
file_name = os.path.basename(file_path).split(".")[0]
outfile = "./.tmp/{}_{}x{}.jpg".format(file_name, size[0], size[1])
im = Image.open(file_path)
im.thumbnail(size, Image.ANTIALIAS)
... | [
"PIL.Image.open",
"os.path.basename"
] | [((250, 271), 'PIL.Image.open', 'Image.open', (['file_path'], {}), '(file_path)\n', (260, 271), False, 'from PIL import Image\n'), ((119, 146), 'os.path.basename', 'os.path.basename', (['file_path'], {}), '(file_path)\n', (135, 146), False, 'import os\n')] |
#!/usr/bin/env python
# coding: utf-8
# # Uttar Pradesh Crime Analysis
# #By- <NAME>
# #Dated: July 12,2021
# In[1]:
from IPython.display import Image
Image(url='https://www.gannett-cdn.com/-mm-/4a94aaab8e826ca8563bd0e434c9fe36f1dc920f/c=0-0-399-300&r=x404&c=534x401/local/-/media/2016/07/20/FortMyers/FortMyers/6360... | [
"seaborn.set",
"seaborn.set_palette",
"pandas.read_csv",
"IPython.display.Image",
"matplotlib.pyplot.pie",
"seaborn.set_style",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.bar",
"seaborn.countplot",
"matplotlib.pyplot.title",
"seaborn.barplot",
"matplotlib.pyplot.show"
] | [((155, 363), 'IPython.display.Image', 'Image', ([], {'url': '"""https://www.gannett-cdn.com/-mm-/4a94aaab8e826ca8563bd0e434c9fe36f1dc920f/c=0-0-399-300&r=x404&c=534x401/local/-/media/2016/07/20/FortMyers/FortMyers/636046215443097272-CRIME-gen-NP.jpg"""'}), "(url=\n 'https://www.gannett-cdn.com/-mm-/4a94aaab8e826ca8... |
# coding: utf-8
from zeit.cms.checkout.helper import checked_out
from zeit.cms.repository.unknown import PersistentUnknownResource
from zeit.content.rawxml.rawxml import RawXML
import jinja2
import lxml.etree
import mock
import pkg_resources
import six
import transaction
import zeit.cms.testcontenttype.testcontenttype
... | [
"mock.patch",
"zeit.cms.checkout.helper.checked_out",
"zeit.content.dynamicfolder.folder.RepositoryDynamicFolder",
"jinja2.Template",
"pkg_resources.resource_string",
"transaction.commit",
"pkg_resources.resource_stream"
] | [((4016, 4041), 'zeit.content.dynamicfolder.folder.RepositoryDynamicFolder', 'RepositoryDynamicFolder', ([], {}), '()\n', (4039, 4041), False, 'from zeit.content.dynamicfolder.folder import RepositoryDynamicFolder\n'), ((9636, 9661), 'zeit.content.dynamicfolder.folder.RepositoryDynamicFolder', 'RepositoryDynamicFolder'... |
""" Unittest """
import unittest
import time
from wlmodem.simulator import WlModemSimulator
class TestWlModemSimulator(unittest.TestCase):
def _make_one(self):
return WlModemSimulator()
def test_connect_with_response_is_success(self):
modem = self._make_one()
self.assertTrue(modem.con... | [
"time.sleep",
"time.time",
"wlmodem.simulator.WlModemSimulator"
] | [((181, 199), 'wlmodem.simulator.WlModemSimulator', 'WlModemSimulator', ([], {}), '()\n', (197, 199), False, 'from wlmodem.simulator import WlModemSimulator\n'), ((1831, 1847), 'time.sleep', 'time.sleep', (['(0.01)'], {}), '(0.01)\n', (1841, 1847), False, 'import time\n'), ((1636, 1647), 'time.time', 'time.time', ([], ... |
try:
from mgrd import Skeleton as MGRDSkeleton
from mgrd import SkeletonNode as MGRDSkeletonNode
has_mgrd = True
except ImportError:
has_mgrd = False
pass
def convert_to_mgrd_skeleton(skeleton):
if not has_mgrd:
return None
def create_mgrd_node(mg_node, parent):
mgrd_node =... | [
"mgrd.SkeletonNode",
"mgrd.Skeleton"
] | [((848, 871), 'mgrd.Skeleton', 'MGRDSkeleton', (['root_node'], {}), '(root_node)\n', (860, 871), True, 'from mgrd import Skeleton as MGRDSkeleton\n'), ((321, 398), 'mgrd.SkeletonNode', 'MGRDSkeletonNode', (['mg_node.node_name', 'parent', 'mg_node.offset', 'mg_node.rotation'], {}), '(mg_node.node_name, parent, mg_node.o... |
# -*- coding: utf-8 -*-
"""
Created on Thu Feb 27 21:24:56 2020
@author: avtei
"""
import numpy as np
import lindemannindex as li
import matplotlib.pyplot as plt
#li.calc_xtc("")
import MDAnalysis
u = MDAnalysis.Universe("../gromacs/AA/AA_min.gro", "../gromacs/AA/AA_eq.xtc")
cd = li.calc_over_time(u, "AA_A")
print... | [
"lindemannindex.calc_over_time",
"MDAnalysis.Universe"
] | [((205, 279), 'MDAnalysis.Universe', 'MDAnalysis.Universe', (['"""../gromacs/AA/AA_min.gro"""', '"""../gromacs/AA/AA_eq.xtc"""'], {}), "('../gromacs/AA/AA_min.gro', '../gromacs/AA/AA_eq.xtc')\n", (224, 279), False, 'import MDAnalysis\n'), ((286, 314), 'lindemannindex.calc_over_time', 'li.calc_over_time', (['u', '"""AA_... |
import os
import tarfile
import glob
from mpi4py import MPI
def tarball_files_by_year(dir):
# create a tarball of the files in each year
files = os.listdir(dir)
pass
| [
"os.listdir"
] | [((155, 170), 'os.listdir', 'os.listdir', (['dir'], {}), '(dir)\n', (165, 170), False, 'import os\n')] |
import asyncio
from aiohttp import ClientSession
from pykoplenti import ApiClient
import sys
"""
Provides a simple example which reads two process data from the plenticore.
Must be called with host and password:
`python read_process_data.py 192.168.1.100 <PASSWORD>`
"""
async def async_main(host, passwd):
asy... | [
"pykoplenti.ApiClient",
"aiohttp.ClientSession",
"sys.exit"
] | [((826, 837), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (834, 837), False, 'import sys\n'), ((328, 343), 'aiohttp.ClientSession', 'ClientSession', ([], {}), '()\n', (341, 343), False, 'from aiohttp import ClientSession\n'), ((373, 397), 'pykoplenti.ApiClient', 'ApiClient', (['session', 'host'], {}), '(session, ho... |
import pytest
from abridger.dump_relations import main
from test.conftest import got_postgresql
@pytest.mark.skipif(not got_postgresql(), reason='Needs postgresql')
class TestDumpRelationsScriptForPostgresql(object):
def test_main(self, capsys, postgresql_database):
# This doesn't test the data itself, j... | [
"abridger.dump_relations.main",
"test.conftest.got_postgresql"
] | [((588, 599), 'abridger.dump_relations.main', 'main', (['[url]'], {}), '([url])\n', (592, 599), False, 'from abridger.dump_relations import main\n'), ((123, 139), 'test.conftest.got_postgresql', 'got_postgresql', ([], {}), '()\n', (137, 139), False, 'from test.conftest import got_postgresql\n')] |
from flaski.database import init_db
from flaski.database import db_session
from flaski.models import WikiContent
c1 = WikiContent("VisitorsBell", "VisitorsBell.gif")
db_session.add(c1)
db_session.commit()
| [
"flaski.database.db_session.commit",
"flaski.database.db_session.add",
"flaski.models.WikiContent"
] | [((119, 166), 'flaski.models.WikiContent', 'WikiContent', (['"""VisitorsBell"""', '"""VisitorsBell.gif"""'], {}), "('VisitorsBell', 'VisitorsBell.gif')\n", (130, 166), False, 'from flaski.models import WikiContent\n'), ((167, 185), 'flaski.database.db_session.add', 'db_session.add', (['c1'], {}), '(c1)\n', (181, 185), ... |
from flask import Flask, request, jsonify, render_template, send_from_directory, Blueprint
import os.path
from database.models import *
from app import app
from database import db
db.create_all()
@app.route("/")
def my_index():
return render_template("index.html")
@app.route('/<path:path>/')
def serve(path):
... | [
"flask.render_template",
"flask.send_from_directory",
"database.db.session.add",
"database.db.session.commit",
"app.app.route",
"database.db.create_all",
"flask.jsonify"
] | [((181, 196), 'database.db.create_all', 'db.create_all', ([], {}), '()\n', (194, 196), False, 'from database import db\n'), ((199, 213), 'app.app.route', 'app.route', (['"""/"""'], {}), "('/')\n", (208, 213), False, 'from app import app\n'), ((273, 299), 'app.app.route', 'app.route', (['"""/<path:path>/"""'], {}), "('/... |
#!/usr/bin/env python
import numpy as np
p = np.pi
def DH_to_T(DH):
"""!
Computes the transformation matrices given the DH table of the serial link.
@param DH: devavitt-hartemberg parameters.
@return T: transformation matrices of a joint with respect to previous joint.
"""
# Get the number of rows, to kn... | [
"numpy.sin",
"numpy.dot",
"numpy.cos"
] | [((1758, 1783), 'numpy.dot', 'np.dot', (['T_rel_ini[i]', 'Tel'], {}), '(T_rel_ini[i], Tel)\n', (1764, 1783), True, 'import numpy as np\n'), ((2206, 2232), 'numpy.dot', 'np.dot', (['T[i - 1]', 'T_rel[i]'], {}), '(T[i - 1], T_rel[i])\n', (2212, 2232), True, 'import numpy as np\n'), ((431, 447), 'numpy.cos', 'np.cos', (['... |
# Python imports
# Third party imports
import boto3
# Self imports
class DjangoCloudWatchHandler:
def __init__(
self,
log_level: str,
log_group_name: str,
cloud_watch_aws_id: str,
cloud_watch_aws_key: str,
cloud_watch_aws_region: str,
) -> None:
sel... | [
"boto3.client"
] | [((1030, 1191), 'boto3.client', 'boto3.client', (['"""logs"""'], {'aws_access_key_id': 'self.cloud_watch_aws_id', 'aws_secret_access_key': 'self.cloud_watch_aws_key', 'region_name': 'self.cloud_watch_aws_region'}), "('logs', aws_access_key_id=self.cloud_watch_aws_id,\n aws_secret_access_key=self.cloud_watch_aws_key,... |
import script
from script import *
import shlex
import edition
import layout
import query
import player
import test
import graph
import opendns
class Color(script.Script):
def __init__(self, console):
super(Color, self).__init__(console)
self.colors = {
"red" : [ 1.0, 0.0, 0.0, 1.0 ],
"green" : [ 0.0, ... | [
"query.Query",
"shlex.shlex",
"query.Select",
"layout.Layout",
"edition.Load",
"edition.Info",
"graph.Topology",
"edition.Remove",
"edition.Map",
"player.Stop",
"test.Test",
"player.Play",
"edition.Clear",
"query.Filter",
"edition.Save",
"edition.Get",
"opendns.OpenDNS",
"edition.S... | [((7686, 7718), 'shlex.shlex', 'shlex.shlex', (['command'], {'posix': '(True)'}), '(command, posix=True)\n', (7697, 7718), False, 'import shlex\n'), ((6604, 6622), 'edition.Info', 'edition.Info', (['self'], {}), '(self)\n', (6616, 6622), False, 'import edition\n'), ((6637, 6655), 'edition.Load', 'edition.Load', (['self... |
from sklearn.base import BaseEstimator
import yake
from ._prep import TextPrep
class YakeTextPrep(TextPrep, BaseEstimator):
"""
Remove all text except meaningful key-phrases. Uses [yake](https://github.com/LIAAD/yake).
Arguments:
top_n: number of key-phrases to select
unique: only return... | [
"yake.KeywordExtractor"
] | [((865, 902), 'yake.KeywordExtractor', 'yake.KeywordExtractor', ([], {'top': 'self.top_n'}), '(top=self.top_n)\n', (886, 902), False, 'import yake\n')] |
import os
from typing import List
from D_PostProcessSOMResults.accuracy_calculator import compute_accuracy
from F_Experiments_Helper.db import get_all_runs, update_run_entry
from F_Experiments_Helper.run_instance import RunInstance
def main():
run_instances: List[RunInstance] = get_all_runs(criteria="WHERE preck... | [
"F_Experiments_Helper.db.update_run_entry",
"F_Experiments_Helper.db.get_all_runs",
"os.path.join"
] | [((286, 357), 'F_Experiments_Helper.db.get_all_runs', 'get_all_runs', ([], {'criteria': '"""WHERE preckar is NULL and end_time is not NULL"""'}), "(criteria='WHERE preckar is NULL and end_time is not NULL')\n", (298, 357), False, 'from F_Experiments_Helper.db import get_all_runs, update_run_entry\n'), ((750, 769), 'F_E... |
import re
import read_export
import pywikibot
comments = {
"<!-- or {{wowapievent}}, {{luapi}}, {{widgethandler}}, {{widgetmethod}}, {{framexmlfunc}} -->",
"<!-- Describe the purpose of the function as concisely as possible. -->\n",
"<!-- Describe the purpose of the function, exhausting detail can be saved for a la... | [
"pywikibot.Page",
"pywikibot.Site",
"read_export.main"
] | [((2423, 2455), 'read_export.main', 'read_export.main', (['parse_wikitext'], {}), '(parse_wikitext)\n', (2439, 2455), False, 'import read_export\n'), ((2464, 2496), 'pywikibot.Site', 'pywikibot.Site', (['"""en"""', '"""wowpedia"""'], {}), "('en', 'wowpedia')\n", (2478, 2496), False, 'import pywikibot\n'), ((2542, 2568)... |
from flask import Blueprint
from ctflorals.controllers import HomeController
from ctflorals.controllers import AboutController
from ctflorals.controllers import GalleryController
from ctflorals.controllers import TestimonialsController
ctflorals = Blueprint('ctflorals', __name__,
template_folder... | [
"ctflorals.controllers.GalleryController",
"ctflorals.controllers.HomeController",
"ctflorals.controllers.TestimonialsController",
"ctflorals.controllers.AboutController",
"flask.Blueprint"
] | [((250, 342), 'flask.Blueprint', 'Blueprint', (['"""ctflorals"""', '__name__'], {'template_folder': '"""views"""', 'static_folder': '"""../resources"""'}), "('ctflorals', __name__, template_folder='views', static_folder=\n '../resources')\n", (259, 342), False, 'from flask import Blueprint\n'), ((429, 445), 'ctflora... |
import math, pygame
from pygame.locals import *
#############################################
## Standard colors (RGB)
BLACK = (20, 20, 40)
WHITE = (255, 255, 255)
BLUE = (0, 0, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
#############################################
## Customize plot here
def function_to_print(x):
... | [
"pygame.display.set_caption",
"pygame.init",
"pygame.draw.lines",
"pygame.quit",
"pygame.draw.line",
"pygame.display.set_mode",
"pygame.event.get",
"pygame.time.Clock",
"pygame.display.update"
] | [((4349, 4400), 'pygame.draw.lines', 'pygame.draw.lines', (['screen', 'plot_color', '(False)', 'pp', '(3)'], {}), '(screen, plot_color, False, pp, 3)\n', (4366, 4400), False, 'import math, pygame\n'), ((4799, 4856), 'pygame.draw.lines', 'pygame.draw.lines', (['screen', 'grid_color', '(False)', 'x_points', '(2)'], {}), ... |
""" Seeding the db """
import os, json, crud, server, model
os.system('dropdb radlist')
os.system('createdb radlist')
model.connect_to_db(server.app)
model.db.create_all()
# # Create users
# create_user(fname, lname, email, password)
alex = crud.create_user('alex', 'sanchez', '<EMAIL>', 'asanch')
pollo = crud.crea... | [
"os.system",
"model.db.create_all",
"model.connect_to_db",
"crud.create_user"
] | [((63, 90), 'os.system', 'os.system', (['"""dropdb radlist"""'], {}), "('dropdb radlist')\n", (72, 90), False, 'import os, json, crud, server, model\n'), ((91, 120), 'os.system', 'os.system', (['"""createdb radlist"""'], {}), "('createdb radlist')\n", (100, 120), False, 'import os, json, crud, server, model\n'), ((122,... |
"""modify_tag_history_column
Revision ID: 96a7e3a61347
Revises: <PASSWORD>
Create Date: 2021-10-06 11:55:30.187627
"""
from alembic import op
import sqlalchemy as sa
from sqlalchemy.dialects import postgresql
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = '<PASSWORD>'
branch_labels = Non... | [
"sqlalchemy.Text",
"alembic.op.drop_column"
] | [((555, 601), 'alembic.op.drop_column', 'op.drop_column', (['"""issue_tag_history"""', '"""history"""'], {}), "('issue_tag_history', 'history')\n", (569, 601), False, 'from alembic import op\n'), ((864, 911), 'alembic.op.drop_column', 'op.drop_column', (['"""issue_tag_history"""', '"""historys"""'], {}), "('issue_tag_h... |
from django.core.management.base import BaseCommand
from orcamentos.crm.models import Employee
class Command(BaseCommand):
help = ''' Cria um usuário admin. '''
def handle(self, *args, **kwargs):
'''
Cria um Employee.
Precisamos de Employee para fazer todas as transações no sistema.
... | [
"orcamentos.crm.models.Employee.objects.create"
] | [((456, 572), 'orcamentos.crm.models.Employee.objects.create', 'Employee.objects.create', ([], {'username': 'username', 'first_name': 'first_name', 'last_name': 'last_name', 'email': 'email', 'gender': '"""I"""'}), "(username=username, first_name=first_name, last_name\n =last_name, email=email, gender='I')\n", (479,... |
# Copyright (c) 2020 <NAME> OpenDigitalStudio.net
#
# 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 ag... | [
"burren.db.crud.list_sessions",
"fastapi.HTTPException",
"burren.db.crud.get_user",
"fastapi.APIRouter",
"burren.db.crud.create_session",
"burren.db.crud.get_session",
"fastapi.Depends"
] | [((848, 859), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (857, 859), False, 'from fastapi import APIRouter\n'), ((1012, 1036), 'fastapi.Depends', 'Depends', (['database.get_db'], {}), '(database.get_db)\n', (1019, 1036), False, 'from fastapi import Depends\n'), ((1054, 1100), 'burren.db.crud.list_sessions', 'c... |