code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# pip install psycopg
import psycopg
# Connect to database
client = psycopg.connect("postgres://username:password@127.0.0.1")
cursor = client.cursor()
# Create table
cursor.execute(
"""
CREATE TABLE table_name(
sku integer,
name varchar(255),
description text,
category varchar(... | [
"psycopg.connect"
] | [((69, 126), 'psycopg.connect', 'psycopg.connect', (['"""postgres://username:password@127.0.0.1"""'], {}), "('postgres://username:password@127.0.0.1')\n", (84, 126), False, 'import psycopg\n')] |
import autocomplete_light
from party.functions import portfolio_render_reference
from party.models import Portfolio
class PortfolioAutocomplete(autocomplete_light.AutocompleteModelBase):
choices = Portfolio.objects.filter().order_by('-ordering')
search_fields = ['title']
display_edit_link = True
fie... | [
"party.functions.portfolio_render_reference",
"autocomplete_light.register",
"party.models.Portfolio.objects.filter"
] | [((631, 692), 'autocomplete_light.register', 'autocomplete_light.register', (['Portfolio', 'PortfolioAutocomplete'], {}), '(Portfolio, PortfolioAutocomplete)\n', (658, 692), False, 'import autocomplete_light\n'), ((396, 471), 'party.functions.portfolio_render_reference', 'portfolio_render_reference', (['choice', 'self.... |
'''
Reinforcement learning Enviroment Definition for Network anomaly detection
'''
import logging.config
from gym import spaces
import gym
from helpers_data_preprocessing import data_cls
class NetworkClassificationEnv(gym.Env,data_cls):
'''
Environment class definition. It represents the dynamics of the A... | [
"helpers_data_preprocessing.data_cls.__init__",
"gym.spaces.Discrete"
] | [((1371, 1428), 'helpers_data_preprocessing.data_cls.__init__', 'data_cls.__init__', (['self', 'train_test', 'attack_map'], {}), '(self, train_test, attack_map, **kwargs)\n', (1388, 1428), False, 'from helpers_data_preprocessing import data_cls\n'), ((1747, 1782), 'gym.spaces.Discrete', 'spaces.Discrete', (['self.data_... |
"""Quirks for Develco Products A/S."""
from zigpy import types as t
from zigpy.quirks import CustomCluster
from zigpy.zcl.clusters.security import IasZone
from zhaquirks import PowerConfigurationCluster
FRIENT = "frient A/S"
DEVELCO = "Develco Products A/S"
class DevelcoPowerConfiguration(PowerConfigurationCluster... | [
"zigpy.types.Optional"
] | [((673, 694), 'zigpy.types.Optional', 't.Optional', (['t.bitmap8'], {}), '(t.bitmap8)\n', (683, 694), True, 'from zigpy import types as t\n'), ((712, 733), 'zigpy.types.Optional', 't.Optional', (['t.uint8_t'], {}), '(t.uint8_t)\n', (722, 733), True, 'from zigpy import types as t\n'), ((751, 773), 'zigpy.types.Optional'... |
from PIL import Image, ImageDraw, ImageFont
import numpy as np
import random
from phi.fluidformat import *
def text_to_pixels(text, size=10, binary=False, as_numpy_array=True):
image = Image.new("1" if binary else "L", (len(text)*size*3//4, size), 0)
draw = ImageDraw.Draw(image)
try:
font = ImageF... | [
"random.choice",
"PIL.ImageFont.truetype",
"numpy.sum",
"numpy.array",
"PIL.ImageDraw.Draw",
"numpy.zeros",
"numpy.linspace",
"numpy.all",
"random.randint"
] | [((268, 289), 'PIL.ImageDraw.Draw', 'ImageDraw.Draw', (['image'], {}), '(image)\n', (282, 289), False, 'from PIL import Image, ImageDraw, ImageFont\n'), ((861, 876), 'numpy.zeros', 'np.zeros', (['shape'], {}), '(shape)\n', (869, 876), True, 'import numpy as np\n'), ((1620, 1635), 'numpy.zeros', 'np.zeros', (['shape'], ... |
from schematics import Model
from schematics.types import ListType, StringType, PolyModelType, DictType
from .base import BaseResponse
class RegionResource(Model):
name = StringType(default="")
region_code = StringType()
provider = StringType(default="azure")
tags = DictType(StringType)
class Region... | [
"schematics.types.PolyModelType",
"schematics.types.StringType",
"schematics.types.DictType",
"schematics.types.ListType"
] | [((177, 199), 'schematics.types.StringType', 'StringType', ([], {'default': '""""""'}), "(default='')\n", (187, 199), False, 'from schematics.types import ListType, StringType, PolyModelType, DictType\n'), ((218, 230), 'schematics.types.StringType', 'StringType', ([], {}), '()\n', (228, 230), False, 'from schematics.ty... |
# Copyright (C) 2015-2021 by Vd.
# This file is part of Rocketgram, the modern Telegram bot framework.
# Rocketgram is released under the MIT License (see LICENSE).
from dataclasses import dataclass
from typing import Optional
from .input_message_content import InputMessageContent
@dataclass(frozen=True)
class Inp... | [
"dataclasses.dataclass"
] | [((288, 310), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (297, 310), False, 'from dataclasses import dataclass\n')] |
import sys
from typing import Callable, Dict, Optional, Tuple, Union
import numpy as np
import scipy.sparse
import scipy.sparse.linalg
from datafold.utils.general import is_symmetric_matrix, sort_eigenpairs
class NumericalMathError(Exception):
"""Use for numerical problems/issues, such as singular matrices or t... | [
"numpy.ones",
"datafold.utils.general.is_symmetric_matrix",
"numpy.any",
"numpy.real",
"datafold.utils.general.sort_eigenpairs",
"numpy.isfinite",
"numpy.linalg.norm"
] | [((8006, 8040), 'datafold.utils.general.sort_eigenpairs', 'sort_eigenpairs', (['eigvals', 'eigvects'], {}), '(eigvals, eigvects)\n', (8021, 8040), False, 'from datafold.utils.general import is_symmetric_matrix, sort_eigenpairs\n'), ((7519, 7572), 'numpy.any', 'np.any', (['(eigvals.imag > 100.0 * sys.float_info.epsilon)... |
# Licensed Materials - Property of IBM
# Copyright IBM Corp. 2016
import unittest
import sys
import dill
import pickle
import datetime
import time
import random
from streamsx.spl.types import Timestamp
from streamsx.topology import schema
class TestTypes(unittest.TestCase):
def test_Timestamp(self):
s = rand... | [
"pickle.dumps",
"streamsx.spl.types.Timestamp.from_datetime",
"datetime.datetime.now",
"streamsx.spl.types.Timestamp.now",
"streamsx.spl.types.Timestamp.from_time",
"streamsx.spl.types.Timestamp",
"dill.dumps",
"time.time",
"random.randint"
] | [((316, 347), 'random.randint', 'random.randint', (['(0)', '(999999999999)'], {}), '(0, 999999999999)\n', (330, 347), False, 'import random\n'), ((359, 388), 'random.randint', 'random.randint', (['(0)', '(1000000000)'], {}), '(0, 1000000000)\n', (373, 388), False, 'import random\n'), ((401, 426), 'random.randint', 'ran... |
# Zope Imports
from zope.interface import implementer
# Twisted Imports
from twisted.internet import reactor, defer, serialport
from twisted.internet.endpoints import TCP4ClientEndpoint
from twisted.internet.interfaces import IAddress
from twisted.python.util import FancyEqMixin
#
# Transports have a connect() functi... | [
"twisted.internet.endpoints.TCP4ClientEndpoint",
"zope.interface.implementer"
] | [((713, 734), 'zope.interface.implementer', 'implementer', (['IAddress'], {}), '(IAddress)\n', (724, 734), False, 'from zope.interface import implementer\n'), ((535, 574), 'twisted.internet.endpoints.TCP4ClientEndpoint', 'TCP4ClientEndpoint', (['reactor', 'host', 'port'], {}), '(reactor, host, port)\n', (553, 574), Fal... |
# Copyright 2018 Google LLC
#
# 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, ... | [
"sys.path.insert",
"tensorflow.compat.v1.gfile.GFile",
"re.compile",
"sgf_wrapper.get_sgf_root_node",
"coords.from_flat",
"sys.exit",
"json.dumps",
"absl.flags.DEFINE_boolean",
"absl.app.run",
"coords.from_sgf",
"tensorflow.compat.v1.gfile.ListDirectory",
"collections.namedtuple",
"os.path.s... | [((1213, 1236), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""."""'], {}), "(0, '.')\n", (1228, 1236), False, 'import sys\n'), ((1467, 1593), 'collections.namedtuple', 'collections.namedtuple', (['"""DebugRow"""', "['move', 'action', 'Q', 'U', 'prior', 'orig_prior', 'N', 'soft_N',\n 'p_delta', 'p_rel']"], {}), ... |
########################################
__author__ = "<NAME>"
__license__ = "GNU GPLv3"
__version__ = "0.1"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
########################################
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.parameter import Parameter
from torch.nn... | [
"torch.nn.functional.conv2d",
"torch.nn.parameter.Parameter",
"torch.rand",
"numpy.arange",
"torch.nn.init.xavier_uniform_",
"torch.unsqueeze",
"torch.Tensor",
"torch.exp",
"torch.nn.init.kaiming_uniform_",
"torch.nn.functional.sigmoid",
"torch.nn.functional.softplus",
"torch.sum",
"scipy.st... | [((1536, 1581), 'torch.nn.functional.max_pool2d', 'F.max_pool2d', (['c1', 'ds', 'ds'], {'return_indices': '(True)'}), '(c1, ds, ds, return_indices=True)\n', (1548, 1581), True, 'import torch.nn.functional as F\n'), ((2012, 2060), 'torch.nn.functional.max_pool2d', 'F.max_pool2d', (['c2_ds', 'ds', 'ds'], {'return_indices... |
import os
import tempfile
def load_model(path, compile=True):
import train
return train._load_model(path, compile=compile)
def copy_weights(from_model, to_model, by_name=True):
with tempfile.TemporaryDirectory(dir='.') as d:
path = os.path.join(d, 'weights.h5')
from_model.save_weights(pa... | [
"tempfile.TemporaryDirectory",
"train._load_model",
"os.path.join"
] | [((92, 132), 'train._load_model', 'train._load_model', (['path'], {'compile': 'compile'}), '(path, compile=compile)\n', (109, 132), False, 'import train\n'), ((198, 234), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {'dir': '"""."""'}), "(dir='.')\n", (225, 234), False, 'import tempfile\n'), ((256... |
import logging
import praw
import redis
import threading
from rusertracker.stream import Stream
class SubredditWorker(threading.Thread):
def __init__(self, evt: threading.Event, subreddit: str, user_agent: str, user: str, redis_kwargs: dict,
ttl: int=7 * 86400):
self._logger = logging.get... | [
"logging.getLogger",
"rusertracker.stream.Stream",
"praw.Reddit",
"redis.Redis"
] | [((309, 362), 'logging.getLogger', 'logging.getLogger', (['f"""rusertracker.worker.{subreddit}"""'], {}), "(f'rusertracker.worker.{subreddit}')\n", (326, 362), False, 'import logging\n'), ((598, 625), 'redis.Redis', 'redis.Redis', ([], {}), '(**redis_kwargs)\n', (609, 625), False, 'import redis\n'), ((821, 871), 'praw.... |
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='Bookmark',
... | [
"django.db.migrations.AlterUniqueTogether",
"django.db.migrations.swappable_dependency",
"django.db.models.AutoField",
"django.db.models.ForeignKey"
] | [((165, 222), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (196, 222), False, 'from django.db import migrations, models\n'), ((889, 978), 'django.db.migrations.AlterUniqueTogether', 'migrations.AlterUniqueTogether', (... |
"""Trace Logger Class"""
# standard library
import logging
from inspect import getframeinfo, stack
# Create trace logging level
logging.TRACE = logging.DEBUG - 5
logging.addLevelName(logging.TRACE, 'TRACE')
class TraceLogger(logging.Logger):
"""Add trace level to logging"""
# supports updated call for Pytho... | [
"inspect.stack",
"logging.addLevelName"
] | [((163, 207), 'logging.addLevelName', 'logging.addLevelName', (['logging.TRACE', '"""TRACE"""'], {}), "(logging.TRACE, 'TRACE')\n", (183, 207), False, 'import logging\n'), ((804, 811), 'inspect.stack', 'stack', ([], {}), '()\n', (809, 811), False, 'from inspect import getframeinfo, stack\n')] |
import pendulum
import pytest
from toggl.api import TimeEntry
from toggl import exceptions
class TestTimeEntries:
def test_ls(self, cmd, fake, factories):
midpoint = pendulum.now(tz='utc') - pendulum.duration(days=2)
start = fake.date_time_between(start_date="-5d", end_date=midpoint,)
... | [
"toggl.api.TimeEntry.objects.current",
"toggl.api.TimeEntry.objects.filter",
"pendulum.duration",
"toggl.api.TimeEntry.start_and_save",
"pendulum.now"
] | [((5499, 5539), 'toggl.api.TimeEntry.objects.current', 'TimeEntry.objects.current', ([], {'config': 'config'}), '(config=config)\n', (5524, 5539), False, 'from toggl.api import TimeEntry\n'), ((5759, 5799), 'toggl.api.TimeEntry.objects.current', 'TimeEntry.objects.current', ([], {'config': 'config'}), '(config=config)\... |
import time, os, django, pathlib, pandas as pd
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "xna2.settings")
django.setup()
from noma.models import NomaSet, NomaFunc, NomaStrMap, NomaStrMapSet, NomaSetAct as sa
from noma.utils import nomaMain, nomaCreateTbl, nomaExecT
from django.db import connection, connections
i... | [
"os.environ.setdefault",
"noma.models.NomaSetAct",
"django.setup",
"pathlib.Path",
"noma.models.NomaFunc.objects.get",
"noma.utils.nomaCreateTbl",
"pandas.ExcelFile",
"noma.models.NomaSet",
"noma.utils.nomaMain",
"time.time",
"noma.models.NomaStrMap.objects.all"
] | [((47, 111), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""xna2.settings"""'], {}), "('DJANGO_SETTINGS_MODULE', 'xna2.settings')\n", (68, 111), False, 'import time, os, django, pathlib, pandas as pd\n'), ((112, 126), 'django.setup', 'django.setup', ([], {}), '()\n', (124, 126),... |
# Computing player vs player statistics by parsing over all the IPL yaml files downloaded from the cricsheet.org
import yaml
import re
import csv
import os
playerStatistics = {} # Player statistics is the ditionary which will have all the player vs player statistics.
playerList = []
ok = 1
def probabilityFunction(fi... | [
"os.listdir",
"re.compile",
"csv.writer",
"os.path.join",
"yaml.load"
] | [((7121, 7144), 'csv.writer', 'csv.writer', (['filePointer'], {}), '(filePointer)\n', (7131, 7144), False, 'import csv\n'), ((7664, 7687), 'csv.writer', 'csv.writer', (['filePointer'], {}), '(filePointer)\n', (7674, 7687), False, 'import csv\n'), ((569, 593), 're.compile', 're.compile', (['"""dates:(.*)"""'], {}), "('d... |
import os
from askapdev.rbuild.builders import Autotools as Builder
import askapdev.rbuild.utils as utils
builder = Builder(buildsubdir="build_unix",
confcommand='../dist/configure')
builder.remote_archive = "db-5.3.21.NC.tar.gz"
if os.uname()[4] == 'x86_64':
builder.add_option('--with-pic')
#... | [
"os.environ.get",
"askapdev.rbuild.builders.Autotools",
"askapdev.rbuild.utils.get_platform",
"os.environ.has_key",
"os.uname"
] | [((118, 184), 'askapdev.rbuild.builders.Autotools', 'Builder', ([], {'buildsubdir': '"""build_unix"""', 'confcommand': '"""../dist/configure"""'}), "(buildsubdir='build_unix', confcommand='../dist/configure')\n", (125, 184), True, 'from askapdev.rbuild.builders import Autotools as Builder\n'), ((746, 766), 'askapdev.rb... |
import unittest
from pychess.core.gamer import Game
from pychess.element.squarer import Square
from pychess.element.piecer import Piece
from pychess import constant as c
from pychess.core.mover import Move
def _check_win(game):
if game.is_game_over:
winner = str(game.winner.name).capitalize()
pr... | [
"pychess.element.piecer.Piece",
"pychess.core.gamer.Game.parse_move_spec",
"pychess.core.gamer.Game",
"unittest.main",
"pychess.element.squarer.Square"
] | [((11835, 11850), 'unittest.main', 'unittest.main', ([], {}), '()\n', (11848, 11850), False, 'import unittest\n'), ((801, 807), 'pychess.core.gamer.Game', 'Game', ([], {}), '()\n', (805, 807), False, 'from pychess.core.gamer import Game\n'), ((4687, 4734), 'pychess.element.piecer.Piece', 'Piece', (['c.PieceType.pawn', ... |
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# pyre-unsafe
from typing import Any, Dict, List, Optional, Sequence, Tuple, Type
from libcst._exceptions import PartialParserSyntaxError
f... | [
"libcst._nodes.expression.Name",
"libcst._parser.types.partials.ImportPartial",
"libcst._parser.whitespace_parser.parse_parenthesizable_whitespace",
"libcst._parser.types.partials.SimpleStatementPartial",
"libcst._parser.types.partials.WithLeadingWhitespace",
"libcst._parser.production_decorator.with_prod... | [((2513, 2560), 'libcst._parser.production_decorator.with_production', 'with_production', (['"""stmt_input"""', '"""stmt ENDMARKER"""'], {}), "('stmt_input', 'stmt ENDMARKER')\n", (2528, 2560), False, 'from libcst._parser.production_decorator import with_production\n'), ((2693, 2752), 'libcst._parser.production_decorat... |
import scrapy
from locations.items import GeojsonPointItem
import json
class FarmersInsuranceSpider(scrapy.Spider):
name = "farmers-insurance"
start_urls = ["https://agents.farmers.com/"]
def get_hours(self, hours_json):
days = json.loads(hours_json)
out_hours = []
for day in da... | [
"json.loads",
"scrapy.Request",
"locations.items.GeojsonPointItem"
] | [((252, 274), 'json.loads', 'json.loads', (['hours_json'], {}), '(hours_json)\n', (262, 274), False, 'import json\n'), ((910, 962), 'scrapy.Request', 'scrapy.Request', ([], {'url': 'path', 'callback': 'self.parse_cities'}), '(url=path, callback=self.parse_cities)\n', (924, 962), False, 'import scrapy\n'), ((1194, 1246)... |
import discord
from discord.ext import commands
class Example(commands.Cog):
def __init__(self , Client):
self.Client = Client
@commands.command()
async def helloworld(self , ctx):
ctx.send('Hello World!')
def setup(Client):
Client.add_cog(Example(Client))
| [
"discord.ext.commands.command"
] | [((147, 165), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (163, 165), False, 'from discord.ext import commands\n')] |
# Copyright 2018, <NAME> LLC
# License: Apache License Version 2.0
# -------------------------------------------------------------------------
# logger.py - basic wrapper around Python standard logging just so in
# case we need to change this behavior it is all in one place
# -------------------------------------... | [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((830, 858), 'logging.getLogger', 'logging.getLogger', (['"""vespene"""'], {}), "('vespene')\n", (847, 858), False, 'import logging\n'), ((919, 942), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (940, 942), False, 'import logging\n'), ((967, 1040), 'logging.Formatter', 'logging.Formatter', (['""... |
from collections import Counter
from pathlib import Path
from typing import List, Dict
def calculate_triangular_value(count: int) -> int:
result: int = 0
for i in range(count):
result += i
return result
class CrabCollection:
def __init__(self, initial_lineup: List[int]):
self.lineup ... | [
"pathlib.Path"
] | [((1046, 1076), 'pathlib.Path', 'Path', (['"""../input/day7_test.txt"""'], {}), "('../input/day7_test.txt')\n", (1050, 1076), False, 'from pathlib import Path\n'), ((1098, 1125), 'pathlib.Path', 'Path', (['"""../input/day7_1.txt"""'], {}), "('../input/day7_1.txt')\n", (1102, 1125), False, 'from pathlib import Path\n')] |
# -*- coding: utf-8 -*-
import six
from abc import ABCMeta, abstractmethod
@six.add_metaclass(ABCMeta)
class SettingBase(object):
@abstractmethod
def generate(self, args):
"""
Generate setting file
:param dict args: setting parameter
:raises ParseError:
""... | [
"six.add_metaclass"
] | [((79, 105), 'six.add_metaclass', 'six.add_metaclass', (['ABCMeta'], {}), '(ABCMeta)\n', (96, 105), False, 'import six\n')] |
# --------------------------------------------------------------------------
# Source file provided under Apache License, Version 2.0, January 2004,
# http://www.apache.org/licenses/
# (c) Copyright IBM Corp. 2015, 2016
# --------------------------------------------------------------------------
# gendoc: ignore
from... | [
"docplex.mp.utils.is_string",
"docplex.mp.internal.mloader.import_class",
"docplex.mp.error_handler.docplex_fatal",
"docplex.mp.docloud_engine.DOcloudEngine",
"inspect.isclass",
"docplex.mp.context.has_credentials"
] | [((4201, 4240), 'docplex.mp.context.has_credentials', 'has_credentials', (['context.solver.docloud'], {}), '(context.solver.docloud)\n', (4216, 4240), False, 'from docplex.mp.context import has_credentials\n'), ((4997, 5027), 'docplex.mp.docloud_engine.DOcloudEngine', 'DOcloudEngine', (['model'], {}), '(model, **kwargs... |
import threading
from unittest import TestCase
import multiprocessing
import multiprocessing_utils
class LocalTestCaseMixin(object):
def test_local(self):
local = multiprocessing_utils.local()
self.assertFalse(hasattr(local, 'value'))
self.assertRaises(AttributeError, getattr, local, 'va... | [
"multiprocessing_utils.local"
] | [((179, 208), 'multiprocessing_utils.local', 'multiprocessing_utils.local', ([], {}), '()\n', (206, 208), False, 'import multiprocessing_utils\n')] |
# GitHub URL: https://github.com/giswqs/qgis-earthengine-examples/tree/master/Visualization/random_color_visualizer.py
import ee
from ee_plugin import Map
dataset = ee.Image('USGS/NLCD/NLCD2016')
landcover = ee.Image(dataset.select('landcover'))
Map.setCenter(-95, 38, 5)
Map.addLayer(landcover.randomVisualizer(), {}... | [
"ee.Image",
"ee_plugin.Map.setCenter"
] | [((167, 197), 'ee.Image', 'ee.Image', (['"""USGS/NLCD/NLCD2016"""'], {}), "('USGS/NLCD/NLCD2016')\n", (175, 197), False, 'import ee\n'), ((249, 274), 'ee_plugin.Map.setCenter', 'Map.setCenter', (['(-95)', '(38)', '(5)'], {}), '(-95, 38, 5)\n', (262, 274), False, 'from ee_plugin import Map\n')] |
from collections import deque
class Process:
def __init__(self):
self.burst_times = deque([])
self.wait_times = deque([])
def create(self, filename):
inputfile = open(filename)
lines = inputfile.readlines()
self.pid = int(lines[0].rstrip('\n'))
self.arrival_time... | [
"collections.deque"
] | [((97, 106), 'collections.deque', 'deque', (['[]'], {}), '([])\n', (102, 106), False, 'from collections import deque\n'), ((133, 142), 'collections.deque', 'deque', (['[]'], {}), '([])\n', (138, 142), False, 'from collections import deque\n')] |
import json
import logging
from django.http import HttpResponse
from pollaris.app.models import SearchLog
def log_failed_search(request):
"""API route to log searches that failed on FE to the Pollaris DB"""
body = json.loads(request.body)
logging.info(f"Logging failed search: {body}")
address_json =... | [
"django.http.HttpResponse",
"json.loads",
"logging.info",
"logging.error"
] | [((226, 250), 'json.loads', 'json.loads', (['request.body'], {}), '(request.body)\n', (236, 250), False, 'import json\n'), ((255, 301), 'logging.info', 'logging.info', (['f"""Logging failed search: {body}"""'], {}), "(f'Logging failed search: {body}')\n", (267, 301), False, 'import logging\n'), ((792, 816), 'django.htt... |
# Copyright (C) 2013 Google Inc. All rights reserved.
# coding=utf-8
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of cond... | [
"v8_utilities.runtime_enabled_feature_name",
"v8_methods.is_secure_context",
"v8_globals.includes.add",
"v8_utilities.cpp_name_or_partial",
"v8_globals.includes.update",
"v8_utilities.v8_class_name_or_partial",
"idl_types.inherits_interface",
"v8_attributes.filter_accessors",
"v8_attributes.filter_d... | [((9837, 9853), 'v8_globals.includes.clear', 'includes.clear', ([], {}), '()\n', (9851, 9853), False, 'from v8_globals import includes\n'), ((9858, 9897), 'v8_globals.includes.update', 'includes.update', (['INTERFACE_CPP_INCLUDES'], {}), '(INTERFACE_CPP_INCLUDES)\n', (9873, 9897), False, 'from v8_globals import include... |
# -*- coding: utf-8 -*-
import pandas as pd
import numpy as np
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
"""
Ler
"""
df_train = pd.read_csv('./data_train_test/df_train_imbd.csv')
df_test = pd.read_csv('./data_train_test/df_test_imbd.csv')
"""
Vetoriz... | [
"sklearn.feature_extraction.text.CountVectorizer",
"sklearn.naive_bayes.MultinomialNB",
"pandas.read_csv"
] | [((196, 246), 'pandas.read_csv', 'pd.read_csv', (['"""./data_train_test/df_train_imbd.csv"""'], {}), "('./data_train_test/df_train_imbd.csv')\n", (207, 246), True, 'import pandas as pd\n'), ((257, 306), 'pandas.read_csv', 'pd.read_csv', (['"""./data_train_test/df_test_imbd.csv"""'], {}), "('./data_train_test/df_test_im... |
# 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, software
# distribut... | [
"inspect.currentframe"
] | [((1733, 1755), 'inspect.currentframe', 'inspect.currentframe', ([], {}), '()\n', (1753, 1755), False, 'import inspect\n'), ((2224, 2246), 'inspect.currentframe', 'inspect.currentframe', ([], {}), '()\n', (2244, 2246), False, 'import inspect\n'), ((2727, 2749), 'inspect.currentframe', 'inspect.currentframe', ([], {}), ... |
import setuptools
setuptools.setup(
name="ngboost",
version="0.1.3",
author="<NAME>",
author_email="<EMAIL>",
description="Library for probabilistic predictions via gradient boosting.",
long_description="Please see Github for full description.",
long_description_content_type="text/markdown"... | [
"setuptools.find_packages"
] | [((423, 449), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (447, 449), False, 'import setuptools\n')] |
'''
Solve stokes equation for a moving sphere
- In practical applications the grid must be denser
'''
import mesh
import FBEM
output_folder = 'data/sphere/'
position = (0, 0, 0)
radius = 1
velocity = (2, 0, 0)
angular = (0, 0, 3)
sphere_grid = 4 # Mesh consisting of 4x4 nodes
#---
sphere = mesh.sphere_create('sphere'... | [
"mesh.sphere_create",
"FBEM.read_all_triangulation_input",
"matplotlib.pyplot.axes",
"FBEM.run",
"matplotlib.pyplot.show"
] | [((293, 371), 'mesh.sphere_create', 'mesh.sphere_create', (['"""sphere"""', 'position', 'radius', 'velocity', 'angular', 'sphere_grid'], {}), "('sphere', position, radius, velocity, angular, sphere_grid)\n", (311, 371), False, 'import mesh\n'), ((437, 468), 'FBEM.run', 'FBEM.run', (['sphere', 'output_folder'], {}), '(s... |
from telegram import ReplyKeyboardMarkup, KeyboardButton
def main_keyboard():
# http://unicode.org/emoji/charts/full-emoji-list.html
return ReplyKeyboardMarkup([
[KeyboardButton('/balance (beta)')],
[KeyboardButton('/markets 📈'), KeyboardButton('/volume 💰'), KeyboardButton('/exchange 🚀')],
... | [
"telegram.KeyboardButton"
] | [((181, 214), 'telegram.KeyboardButton', 'KeyboardButton', (['"""/balance (beta)"""'], {}), "('/balance (beta)')\n", (195, 214), False, 'from telegram import ReplyKeyboardMarkup, KeyboardButton\n'), ((226, 254), 'telegram.KeyboardButton', 'KeyboardButton', (['"""/markets 📈"""'], {}), "('/markets 📈')\n", (240, 254), F... |
#!/usr/bin/env python3
#-*- coding: utf-8 -*-
#comment from wenmei:
'''
nal_type:7和nal_type:8代表sps 和pps \
get length 8461, complete 1, type 0,
type 0 表示keyframe
'''
"""
Description: This app is used to parse the main log file and get the information of VoLTE video call
Version-0.3
Author: yi.qiu
E-m... | [
"tkinter.Menu",
"os.path.exists",
"tkinter.messagebox.showinfo",
"tkinter.messagebox.showwarning",
"time.strptime",
"tkinter.messagebox.askokcancel",
"tkinter.messagebox.showerror",
"threading.Lock",
"csv.writer",
"tkinter.filedialog.asksaveasfilename",
"tkinter.Tk",
"threading.Thread",
"tki... | [((10924, 10949), 'os.path.exists', 'os.path.exists', (['file_path'], {}), '(file_path)\n', (10938, 10949), False, 'import os\n'), ((11901, 11926), 'os.path.exists', 'os.path.exists', (['file_path'], {}), '(file_path)\n', (11915, 11926), False, 'import os\n'), ((16499, 16511), 'tkinter.Tk', 'tkinter.Tk', ([], {}), '()\... |
from conans import ConanFile, CMake, tools
import os
class LibmikmodConan(ConanFile):
name = "libmikmod"
description = "Module player and library supporting many formats, including mod, s3m, it, and xm."
topics = ("libmikmod", "audio")
url = "https://github.com/conan-io/conan-center-index"
homepag... | [
"os.rename",
"conans.CMake",
"conans.tools.patch",
"os.path.join",
"conans.tools.collect_libs",
"conans.tools.get",
"conans.tools.is_apple_os"
] | [((1659, 1694), 'conans.tools.is_apple_os', 'tools.is_apple_os', (['self.settings.os'], {}), '(self.settings.os)\n', (1676, 1694), False, 'from conans import ConanFile, CMake, tools\n'), ((2191, 2244), 'conans.tools.get', 'tools.get', ([], {}), "(**self.conan_data['sources'][self.version])\n", (2200, 2244), False, 'fro... |
# 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, software
# d... | [
"stevedore.sphinxext._detailed_list",
"mock.Mock",
"stevedore.extension.Extension",
"stevedore.extension.ExtensionManager.make_test_instance",
"stevedore.sphinxext._simple_list"
] | [((888, 928), 'mock.Mock', 'mock.Mock', ([], {'spec': 'pkg_resources.EntryPoint'}), '(spec=pkg_resources.EntryPoint)\n', (897, 928), False, 'import mock\n'), ((977, 1025), 'mock.Mock', 'mock.Mock', ([], {'return_value': "('ENTRY_POINT(%s)' % name)"}), "(return_value='ENTRY_POINT(%s)' % name)\n", (986, 1025), False, 'im... |
# Copyright (C) 2016, A10 Networks 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 requ... | [
"logging.getLogger",
"neutron_lbaas.services.loadbalancer.plugin.LoadBalancerPluginv2"
] | [((964, 991), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (981, 991), False, 'import logging\n'), ((1293, 1322), 'neutron_lbaas.services.loadbalancer.plugin.LoadBalancerPluginv2', 'plugin.LoadBalancerPluginv2', ([], {}), '()\n', (1320, 1322), False, 'from neutron_lbaas.services.loadbal... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright © 2017, CNRS-LAAS
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
... | [
"sys.path.append",
"ivy_msg_interface.PprzMessage",
"os.getenv"
] | [((1611, 1636), 'os.getenv', 'os.getenv', (['"""PPRZLINK_LIB"""'], {}), "('PPRZLINK_LIB')\n", (1620, 1636), False, 'import os\n'), ((1637, 1687), 'sys.path.append', 'sys.path.append', (["(PPRZLINK_LIB + '/lib/v1.0/python')"], {}), "(PPRZLINK_LIB + '/lib/v1.0/python')\n", (1652, 1687), False, 'import sys\n'), ((3335, 33... |
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from ops import linear, conv1d
class MLP(nn.Module):
def __init__(self, num_classes=1000):
super(MLP, self).__init__()
self.fc1 = nn.Linear(512, 512)
self.fc2 = nn.Linear(512, num_classes)
# when you ... | [
"torch.nn.MaxPool1d",
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.nn.functional.softmax",
"torch.mean",
"math.sqrt",
"torch.nn.BatchNorm1d",
"ops.linear",
"torch.nn.functional.relu",
"torch.nn.Linear",
"ops.conv1d",
"torch.nn.Conv1d"
] | [((233, 252), 'torch.nn.Linear', 'nn.Linear', (['(512)', '(512)'], {}), '(512, 512)\n', (242, 252), True, 'import torch.nn as nn\n'), ((272, 299), 'torch.nn.Linear', 'nn.Linear', (['(512)', 'num_classes'], {}), '(512, num_classes)\n', (281, 299), True, 'import torch.nn as nn\n'), ((805, 951), 'ops.linear', 'linear', ([... |
# Copyright 2020 DataStax, Inc
#
# 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,... | [
"pysper.humanize.pluralize",
"pysper.diag.find_logs",
"pysper.parser.read_output_log",
"collections.defaultdict"
] | [((1053, 1069), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (1064, 1069), False, 'from collections import defaultdict\n'), ((1505, 1532), 'pysper.parser.read_output_log', 'parser.read_output_log', (['log'], {}), '(log)\n', (1527, 1532), False, 'from pysper import parser\n'), ((3253, 3291), 'pysp... |
## -*- coding: utf-8 -*
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
import numpy as np
import math
class Draw(QGraphicsItem):
def __init__(self,width=180, height=180, size=90):
super(Draw,self).__init__()
self.offsetx = 10
self.offsety = 10
se... | [
"numpy.sin",
"numpy.cos",
"numpy.savetxt",
"math.radians"
] | [((7293, 7372), 'numpy.savetxt', 'np.savetxt', (['csv_filename', 'self.angvel_list'], {'delimiter': '""","""', 'header': '""" """', 'fmt': '"""%f"""'}), "(csv_filename, self.angvel_list, delimiter=',', header=' ', fmt='%f')\n", (7303, 7372), True, 'import numpy as np\n'), ((4987, 5032), 'numpy.sin', 'np.sin', (['((90.0... |
# Demo Python Datetime - The strftime() Method
'''
The strftime() Method
The datetime object has a method for formatting date objects into readable strings.
The method is called strftime(), and takes one parameter, format, to specify the format of the returned string.
Directive Description ... | [
"datetime.datetime.now"
] | [((2351, 2374), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (2372, 2374), False, 'import datetime\n')] |
import os
import logging
import discord
from operator import mul
from functools import reduce
from discord.ext import commands
from datetime import datetime as dt
logging.basicConfig(level=logging.INFO)
bot = commands.Bot(
command_prefix=commands.when_mentioned_or('/'),
help_command=None,
intents=discord.I... | [
"logging.basicConfig",
"discord.ext.commands.when_mentioned_or",
"functools.reduce",
"discord.Intents.all",
"datetime.datetime.now"
] | [((164, 203), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (183, 203), False, 'import logging\n'), ((842, 885), 'functools.reduce', 'reduce', (['mul', '(3, 3, 80071, 152837, 4318511)'], {}), '(mul, (3, 3, 80071, 152837, 4318511))\n', (848, 885), False, 'from f... |
#!/usr/bin/python
import os
import json
import string
def path_to_dict(path):
file_name = os.path.basename(path);
title_name = string.replace(os.path.splitext(file_name)[0], '_', ' ').title()
d = {'title': title_name}
if os.path.isdir(path):
d['url'] = file_name
d['menu'] = [path_to_dict(os.path.join(path,x))... | [
"os.listdir",
"json.dumps",
"os.path.join",
"os.path.splitext",
"os.path.isdir",
"os.path.basename"
] | [((93, 115), 'os.path.basename', 'os.path.basename', (['path'], {}), '(path)\n', (109, 115), False, 'import os\n'), ((227, 246), 'os.path.isdir', 'os.path.isdir', (['path'], {}), '(path)\n', (240, 246), False, 'import os\n'), ((801, 817), 'json.dumps', 'json.dumps', (['menu'], {}), '(menu)\n', (811, 817), False, 'impor... |
from setuptools import setup, find_packages
classifiers = [
'Development Status :: 5 - Production/Stable',
'Intended Audience :: Education',
'Operating System :: Microsoft :: Windows :: Windows 10',
'License :: OSI Approved :: MIT License',
'Programming Language :: Python :: 3'
]
setup(
name='mariocard.... | [
"setuptools.find_packages"
] | [((651, 666), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (664, 666), False, 'from setuptools import setup, find_packages\n')] |
import json
import warnings
from typing import Type
from urllib.parse import urlparse
from django.conf import settings
from django.core.signals import setting_changed
from django.db import models
from django.db.models.base import ModelBase
from django.http.request import validate_host
from django.utils.functional impo... | [
"django.core.signals.setting_changed.connect",
"urllib.parse.urlparse",
"requests.get",
"django.utils.module_loading.import_string",
"django.http.request.validate_host",
"warnings.warn"
] | [((2974, 3000), 'django.utils.module_loading.import_string', 'import_string', (['import_path'], {}), '(import_path)\n', (2987, 3000), False, 'from django.utils.module_loading import import_string\n'), ((1448, 1461), 'urllib.parse.urlparse', 'urlparse', (['url'], {}), '(url)\n', (1456, 1461), False, 'from urllib.parse i... |
from collections import OrderedDict
class MyObj(object):
b = 1
a = 2
def __init__(self):
object.__setattr__(self, '_attrs', OrderedDict())
self.c = 1
self.d = 2
def __setattr__(self, key, value):
assert key != '_attrs'
self._attrs[key] = value
def __getat... | [
"collections.OrderedDict"
] | [((147, 160), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (158, 160), False, 'from collections import OrderedDict\n')] |
"""
Copyright (C) 2019 NVIDIA Corporation. All rights reserved.
Licensed under the CC BY-NC-SA 4.0 license
(https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
"""
import torch
from torch.utils.data import Dataset
import numpy as np
import time
import os
import cv2
import sys
import utils
from datasets.sca... | [
"numpy.log",
"utils.resize_mask",
"numpy.array",
"utils.compute_overlaps",
"numpy.arctan2",
"numpy.linalg.norm",
"utils.writePointCloud",
"utils.compose_image_meta",
"numpy.save",
"numpy.arange",
"os.path.exists",
"numpy.where",
"numpy.stack",
"utils.extract_bboxes",
"numpy.random.seed",... | [((20837, 20957), 'utils.resize_image', 'utils.resize_image', (['image'], {'min_dim': 'config.IMAGE_MAX_DIM', 'max_dim': 'config.IMAGE_MAX_DIM', 'padding': 'config.IMAGE_PADDING'}), '(image, min_dim=config.IMAGE_MAX_DIM, max_dim=config.\n IMAGE_MAX_DIM, padding=config.IMAGE_PADDING)\n', (20855, 20957), False, 'impor... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import socket
import struct
import marshal
from ComssServiceDevelopment.connectors.base import BaseConnector
class OutputMulticastConnector(BaseConnector):
TIMEOUT = 0.2
TTL = 2
def __init__(self, service_instance):
self._service_instance = service_i... | [
"socket.socket",
"struct.pack",
"marshal.dumps",
"socket.inet_aton",
"marshal.loads"
] | [((1288, 1306), 'marshal.dumps', 'marshal.dumps', (['msg'], {}), '(msg)\n', (1301, 1306), False, 'import marshal\n'), ((3279, 3298), 'marshal.loads', 'marshal.loads', (['data'], {}), '(data)\n', (3292, 3298), False, 'import marshal\n'), ((840, 888), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGR... |
#!/usr/bin/env python3
#
# Copyright 2021 Graviti. Licensed under MIT License.
#
"""Implementation of gas tag."""
import click
from ..client.gas import DatasetClientType
from .tbrn import TBRN, TBRNType
from .utility import ContextInfo, error, exception_handler, get_dataset_client, get_gas
@exception_handler
def _... | [
"click.echo"
] | [((1059, 1108), 'click.echo', 'click.echo', (['f"""{tag_tbrn} is deleted successfully"""'], {}), "(f'{tag_tbrn} is deleted successfully')\n", (1069, 1108), False, 'import click\n'), ((1550, 1599), 'click.echo', 'click.echo', (['f"""{tag_tbrn} is created successfully"""'], {}), "(f'{tag_tbrn} is created successfully')\n... |
#!/usr/bin/env python3
import os
import configparser
from .app_version import *
# Obligatorily (on every OS):
# - config files go in $HOME/.config/IPyNotes
#
# By default (on every OS):
# - note files go in $HOME/IPyNotes/notes
# - change files go in $HOME/IPyNotes/changes
# TODO: Add a way to save settings, e.g.... | [
"os.path.exists",
"configparser.ConfigParser",
"os.makedirs",
"os.path.join",
"os.path.expanduser"
] | [((498, 521), 'os.path.expanduser', 'os.path.expanduser', (['"""~"""'], {}), "('~')\n", (516, 521), False, 'import os\n'), ((537, 576), 'os.path.join', 'os.path.join', (['home', '""".config"""', 'APP_NAME'], {}), "(home, '.config', APP_NAME)\n", (549, 576), False, 'import os\n'), ((585, 617), 'os.makedirs', 'os.makedir... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import json
import requests
from plasticity.utils import utils
class Endpoint(object):
"""An Endpoint is a specific API action within an API service.
Attributes:
plasticity: a Plasticity ins... | [
"json.loads",
"json.dumps"
] | [((2533, 2563), 'json.loads', 'json.loads', (['self._request.body'], {}), '(self._request.body)\n', (2543, 2563), False, 'import json\n'), ((2335, 2360), 'json.loads', 'json.loads', (['response.text'], {}), '(response.text)\n', (2345, 2360), False, 'import json\n'), ((1464, 1483), 'json.dumps', 'json.dumps', (['payload... |
import os
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import math
import re
from datetime import datetime
data_location = os.path.join(os.path.dirname(__file__), "..", "data")
from os import listdir
from os.path import isfile, join
onlyfiles = [f for f in listdir(data_location) if isfile(jo... | [
"re.split",
"os.listdir",
"datetime.datetime.strptime",
"os.path.join",
"os.path.dirname"
] | [((712, 740), 're.split', 're.split', (['"""-|\\\\."""', 'file_name'], {}), "('-|\\\\.', file_name)\n", (720, 740), False, 'import re\n'), ((859, 894), 'datetime.datetime.strptime', 'datetime.strptime', (['str_date', '"""%Y%m"""'], {}), "(str_date, '%Y%m')\n", (876, 894), False, 'from datetime import datetime\n'), ((16... |
#!/usr/bin/env python3
import csv
import datetime
import requests
# def get_file_lines(url):
def download_file(url):
"""Returns the lines contained in the file at the given URL"""
# Download the file over the internet
response = requests.get(url, stream=True)
lines = []
for line in response.iter... | [
"datetime.datetime",
"datetime.datetime.strptime",
"requests.get",
"datetime.datetime.today",
"datetime.timedelta",
"csv.reader"
] | [((244, 274), 'requests.get', 'requests.get', (['url'], {'stream': '(True)'}), '(url, stream=True)\n', (256, 274), False, 'import requests\n'), ((794, 829), 'datetime.datetime', 'datetime.datetime', (['year', 'month', 'day'], {}), '(year, month, day)\n', (811, 829), False, 'import datetime\n'), ((1227, 1252), 'datetime... |
from __future__ import absolute_import, unicode_literals
import sys
import pytest
from flaky import flaky
from virtualenv.activation import XonshActivator
from virtualenv.info import IS_PYPY, PY3
@pytest.mark.slow
@pytest.mark.skipif(
(sys.platform == "win32" and IS_PYPY and PY3) or sys.version_info[0:2] == (3... | [
"flaky.flaky",
"pytest.mark.skipif"
] | [((220, 404), 'pytest.mark.skipif', 'pytest.mark.skipif', (["(sys.platform == 'win32' and IS_PYPY and PY3 or sys.version_info[0:2] == (3, 9)\n )"], {'reason': '"""xonsh on Windows blocks indefinitely and is not stable yet on 3.9"""'}), "(sys.platform == 'win32' and IS_PYPY and PY3 or sys.\n version_info[0:2] == (... |
import pytest
from plenum.common.exceptions import MissingNodeOp, InvalidNodeOp
from plenum.common.messages.fields import NonNegativeNumberField, AnyValueField, HexField, BooleanField, Base58Field
from plenum.common.messages.message_base import MessageBase
from plenum.common.messages.node_message_factory import Messag... | [
"plenum.common.messages.node_message_factory.NodeMessageFactory",
"pytest.raises",
"plenum.common.messages.fields.NonNegativeNumberField",
"plenum.common.messages.node_message_factory.MessageFactory"
] | [((487, 547), 'plenum.common.messages.node_message_factory.MessageFactory', 'MessageFactory', (['"""plenum.test.input_validation.stub_messages"""'], {}), "('plenum.test.input_validation.stub_messages')\n", (501, 547), False, 'from plenum.common.messages.node_message_factory import MessageFactory, NodeMessageFactory\n')... |
import tensorflow as tf
from tensorflow import keras
# Open with keras first (direct conversion from SavedModel does not work for some reason)
model = keras.models.load_model("model")
model.compile(optimizer="adam",
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=["accuracy"])
... | [
"tensorflow.keras.losses.SparseCategoricalCrossentropy",
"tensorflow.keras.models.load_model",
"tensorflow.lite.TFLiteConverter.from_keras_model"
] | [((156, 188), 'tensorflow.keras.models.load_model', 'keras.models.load_model', (['"""model"""'], {}), "('model')\n", (179, 188), False, 'from tensorflow import keras\n'), ((371, 418), 'tensorflow.lite.TFLiteConverter.from_keras_model', 'tf.lite.TFLiteConverter.from_keras_model', (['model'], {}), '(model)\n', (411, 418)... |
from ...accounts import Account, account_factory
import tempfile
import os
import pickle
from os import listdir
from os.path import isfile, join
class LocalFileSystemAccountAdapter():
def __init__(self, root=None):
if root is None: root = tempfile.gettempdir()
if not os.path.exists(root+"/accounts... | [
"os.path.exists",
"os.listdir",
"pickle.dump",
"os.makedirs",
"pickle.load",
"os.path.join",
"tempfile.gettempdir"
] | [((253, 274), 'tempfile.gettempdir', 'tempfile.gettempdir', ([], {}), '()\n', (272, 274), False, 'import tempfile\n'), ((290, 325), 'os.path.exists', 'os.path.exists', (["(root + '/accounts/')"], {}), "(root + '/accounts/')\n", (304, 325), False, 'import os\n'), ((337, 369), 'os.makedirs', 'os.makedirs', (["(root + '/a... |
import logging
from typing import Callable
from django.conf import settings
from django.http import HttpRequest, HttpResponse
from django.contrib.auth import get_user_model, logout
from django.contrib.messages import info
from .utils import now, seconds_until_idle_time_end, seconds_until_session_end
UserModel = get_u... | [
"logging.getLogger",
"django.contrib.auth.get_user_model",
"django.contrib.messages.info",
"django.contrib.auth.logout"
] | [((315, 331), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (329, 331), False, 'from django.contrib.auth import get_user_model, logout\n'), ((341, 368), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (358, 368), False, 'import logging\n'), ((1303, 1318), 'djang... |
# Custom log levels for Python's logging module.
#
# Author: <NAME> <<EMAIL>>
# Last Change: August 7, 2017
# URL: https://verboselogs.readthedocs.io
"""
Custom log levels for Python's :mod:`logging` module.
The :mod:`verboselogs` module defines the :data:`NOTICE`, :data:`SPAM`,
:data:`SUCCESS` and :data:`VERBOSE` co... | [
"logging.Logger.__init__",
"logging.setLoggerClass",
"logging.getLogger",
"logging.addLevelName"
] | [((2673, 2710), 'logging.setLoggerClass', 'logging.setLoggerClass', (['VerboseLogger'], {}), '(VerboseLogger)\n', (2695, 2710), False, 'import logging\n'), ((2931, 2964), 'logging.addLevelName', 'logging.addLevelName', (['value', 'name'], {}), '(value, name)\n', (2951, 2964), False, 'import logging\n'), ((4367, 4409), ... |
from setuptools import setup, find_packages
from dexy.version import DEXY_VERSION
import platform
is_windows = platform.system() == 'Windows'
if is_windows:
os_specific_requires = []
else:
os_specific_requires = ['pexpect']
setup(
author='<NAME>',
author_email='<EMAIL>',
classifiers=[... | [
"platform.system",
"setuptools.find_packages"
] | [((112, 129), 'platform.system', 'platform.system', ([], {}), '()\n', (127, 129), False, 'import platform\n'), ((2008, 2023), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (2021, 2023), False, 'from setuptools import setup, find_packages\n')] |
""" # NOQA
:mod:`aioopenssl` --- A transport for asyncio using :mod:`OpenSSL`
##################################################################
This package provides a socket-based :class:`asyncio.Transport` which uses
:mod:`OpenSSL` to create a TLS connection. Optionally, the TLS handshake can be
deferred and perfo... | [
"logging.getLogger",
"socket.socket",
"asyncio.Future"
] | [((1456, 1483), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1473, 1483), False, 'import logging\n'), ((33610, 33635), 'asyncio.Future', 'asyncio.Future', ([], {'loop': 'loop'}), '(loop=loop)\n', (33624, 33635), False, 'import asyncio\n'), ((27355, 27371), 'asyncio.Future', 'asyncio.Fu... |
# coding: utf-8
import six
import pytest
from mock import sentinel, patch
from hamcrest.core.base_description import BaseDescription
from hamcrest.core.selfdescribing import SelfDescribing
from hamcrest.core.helpers.ismock import MOCKTYPES
__author__ = "<NAME>"
__copyright__ = "Copyright 2015 hamcrest.org"
__license_... | [
"pytest.mark.parametrize",
"six.u",
"six.b",
"pytest.mark.skipif"
] | [((1518, 1617), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""char, rep"""', '(("\'", "\'"), (\'\\n\', \'\\\\n\'), (\'\\r\', \'\\\\r\'), (\'\\t\', \'\\\\t\'))'], {}), '(\'char, rep\', (("\'", "\'"), (\'\\n\', \'\\\\n\'), (\'\\r\',\n \'\\\\r\'), (\'\\t\', \'\\\\t\')))\n', (1541, 1617), False, 'import py... |
from collections import defaultdict
from typing import Dict, List, Optional
import re
import sys
try:
# TODO: Rewrite this module to use ldap3 which gets installed in rootless installs too.
import ldap
except ModuleNotFoundError:
print("""\
*** ldap module unavailable; this comes from "python-ldap" which i... | [
"logging.getLogger",
"ldap.set_option",
"re.compile",
"ldap.initialize",
"collections.defaultdict",
"asn1.Encoder",
"hashlib.sha1"
] | [((577, 614), 'ldap.set_option', 'ldap.set_option', (['ldap.OPT_TIMEOUT', '(10)'], {}), '(ldap.OPT_TIMEOUT, 10)\n', (592, 614), False, 'import ldap\n'), ((615, 660), 'ldap.set_option', 'ldap.set_option', (['ldap.OPT_NETWORK_TIMEOUT', '(10)'], {}), '(ldap.OPT_NETWORK_TIMEOUT, 10)\n', (630, 660), False, 'import ldap\n'),... |
import json
from django.conf import settings
from django.contrib.auth.models import User
from django.utils.translation import ugettext_lazy as _
from cms.models import Placeholder
from cms.api import create_page, add_plugin, publish_page
placeholder = {}
with open('starting_page.json') as data_file:
content = ... | [
"django.utils.translation.ugettext_lazy",
"django.contrib.auth.models.User.objects.all",
"django.contrib.auth.models.User.objects.count",
"json.load",
"cms.api.add_plugin"
] | [((1158, 1216), 'cms.api.add_plugin', 'add_plugin', (["placeholder['main']", '"""MultiColumnPlugin"""', 'lang'], {}), "(placeholder['main'], 'MultiColumnPlugin', lang)\n", (1168, 1216), False, 'from cms.api import create_page, add_plugin, publish_page\n'), ((320, 340), 'json.load', 'json.load', (['data_file'], {}), '(d... |
# -*- coding: utf-8 -*-
from functools import partial
s_open = partial(open, mode='r')
| [
"functools.partial"
] | [((65, 88), 'functools.partial', 'partial', (['open'], {'mode': '"""r"""'}), "(open, mode='r')\n", (72, 88), False, 'from functools import partial\n')] |
import json
import logging.config
import os
import re
from string import Template
from jans.pycloudlib import get_manager
from jans.pycloudlib.persistence import render_couchbase_properties
from jans.pycloudlib.persistence import render_base_properties
from jans.pycloudlib.persistence import render_hybrid_properties
f... | [
"jans.pycloudlib.persistence.sync_ldap_truststore",
"jans.pycloudlib.get_manager",
"string.Template",
"jans.pycloudlib.persistence.render_hybrid_properties",
"jans.pycloudlib.persistence.render_sql_properties",
"jans.pycloudlib.persistence.sync_couchbase_truststore",
"jans.pycloudlib.persistence.render_... | [((938, 951), 'jans.pycloudlib.get_manager', 'get_manager', ([], {}), '()\n', (949, 951), False, 'from jans.pycloudlib import get_manager\n'), ((1099, 1395), 're.sub', 're.sub', (['"""<New id="DefaultHandler" class="org.eclipse.jetty.server.handler.DefaultHandler"/>"""', '"""<New id="DefaultHandler" class="org.eclipse.... |
import dash
import dash_bootstrap_components as dbc
from flask import Flask
server = Flask(__name__)
app = dash.Dash(__name__, server=server, external_stylesheets=[dbc.themes.BOOTSTRAP], suppress_callback_exceptions=True,
prevent_initial_callbacks=True)
app.server.config["SQLALCHEMY_DATABASE_URI"] = ... | [
"dash.Dash",
"flask.Flask"
] | [((86, 101), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (91, 101), False, 'from flask import Flask\n'), ((108, 263), 'dash.Dash', 'dash.Dash', (['__name__'], {'server': 'server', 'external_stylesheets': '[dbc.themes.BOOTSTRAP]', 'suppress_callback_exceptions': '(True)', 'prevent_initial_callbacks': '(T... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2017-01-18 11:25
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('meas_models', '0005_auto_20170118_1923'),
]
operations = [
migrations.RemoveField(
... | [
"django.db.migrations.RemoveField"
] | [((296, 357), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""formulaindex"""', 'name': '"""idf"""'}), "(model_name='formulaindex', name='idf')\n", (318, 357), False, 'from django.db import migrations\n')] |
import importlib
import sys
import tensorflow as tf
LSTM_SIZE = 2048
def resnet_rnn_model(features, model_params, example_description, training):
# Get hyperparameters
dropout_rate = model_params['resnet_rnn'].get('dropout_rate', 0.5)
# Reshape inputs into proper dimensions
for (name, f), d in zip(... | [
"tensorflow.contrib.framework.init_from_checkpoint",
"tensorflow.layers.flatten",
"importlib.import_module",
"tensorflow.transpose",
"tensorflow.variable_scope",
"tensorflow.reduce_sum",
"tensorflow.layers.max_pooling2d",
"tensorflow.contrib.layers.l2_regularizer",
"tensorflow.nn.rnn_cell.LSTMCell",... | [((749, 799), 'tensorflow.transpose', 'tf.transpose', (['telescope_data'], {'perm': '[1, 0, 2, 3, 4]'}), '(telescope_data, perm=[1, 0, 2, 3, 4])\n', (761, 799), True, 'import tensorflow as tf\n'), ((1539, 1587), 'sys.path.append', 'sys.path.append', (["model_params['model_directory']"], {}), "(model_params['model_direc... |
from molml.Datastructures.molecule import Molecule
import pandas as pd
def mols_from_csv(filename: str, smiles_col: str, label_col: str = None, id_col: str = None,
remove_empty_rows: bool = True):
# Read the data
df = pd.read_csv(filename, low_memory=True, usecols=list(filter(None, [smiles_c... | [
"molml.Datastructures.molecule.Molecule"
] | [((921, 944), 'molml.Datastructures.molecule.Molecule', 'Molecule', (['smiles', 'y', 'id'], {}), '(smiles, y, id)\n', (929, 944), False, 'from molml.Datastructures.molecule import Molecule\n')] |
import os
from functools import partial
from pathlib import Path
from typing import Dict, Optional, Union
from bw_tools.common.bw_api_tool import BWAPITool
from bw_tools.common.bw_node_selection import remove_dot_nodes
from bw_tools.modules.bw_settings.bw_settings import BWModuleSettings
from bw_tools.modules.bw_strai... | [
"bw_tools.common.bw_node_selection.remove_dot_nodes",
"pathlib.Path",
"bw_tools.modules.bw_straighten_connection.straighten_behavior.BWBreakAtSource",
"os.access",
"PySide2.QtWidgets.QMessageBox.question",
"functools.partial",
"bw_tools.modules.bw_straighten_connection.straighten_behavior.BWBreakAtTarge... | [((5573, 5582), 'PySide2.QtWidgets.QAction', 'QAction', ([], {}), '()\n', (5580, 5582), False, 'from PySide2.QtWidgets import QAction, QMessageBox\n'), ((3459, 3498), 'sd.tools.graphlayout.snapSDNodes', 'snapSDNodes', (['api.current_node_selection'], {}), '(api.current_node_selection)\n', (3470, 3498), False, 'from sd.... |
r"""
Cyclic sieving phenomenon
Implementation of the Cyclic Sieving Phenomenon as described in
Reiner, Stanton, White - The cyclic sieving phenomenon, Journal of Combinatorial Theory A 108 (2004)
We define the CyclicSievingPolynomial of a finite set S together with cyclic action cyc_act (of order n) to be the unique
... | [
"sage.rings.all.ZZ",
"sage.rings.arith.lcm"
] | [((3004, 3013), 'sage.rings.arith.lcm', 'lcm', (['keys'], {}), '(keys)\n', (3007, 3013), False, 'from sage.rings.arith import lcm\n'), ((3436, 3449), 'sage.rings.all.ZZ', 'ZZ', (['(order / n)'], {}), '(order / n)\n', (3438, 3449), False, 'from sage.rings.all import ZZ, QQ\n'), ((3380, 3385), 'sage.rings.all.ZZ', 'ZZ', ... |
# Copyright (c) 2016 Mirantis Inc.
#
# 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 writ... | [
"sahara.utils.files.get_file_text",
"sahara.plugins.provisioning.Config"
] | [((2995, 3211), 'sahara.plugins.provisioning.Config', 'p.Config', (['"""Hadoop OpenStack library URL"""', '"""general"""', '"""cluster"""'], {'priority': '(1)', 'default_value': 'DEFAULT_SWIFT_LIB_URL', 'description': '"""Library that adds Swift support to CDH. The file will be downloaded by VMs."""'}), "('Hadoop OpenS... |
import os, sys
import numpy as np
import pybullet as p
class Util:
def __init__(self, pid, np_random):
self.id = pid
self.ik_lower_limits = {}
self.ik_upper_limits = {}
self.ik_joint_ranges = {}
self.ik_rest_poses = {}
self.np_random = np_random
def enable_gpu(... | [
"pkgutil.get_loader",
"numpy.mean",
"numpy.abs",
"numpy.cross",
"GPUtil.getGPUs",
"numpy.any",
"numpy.array",
"numpy.dot",
"GPUtil.showUtilization",
"numpy.cos",
"numpy.concatenate",
"numpy.linalg.norm",
"numpy.sin",
"pybullet.loadPlugin"
] | [((904, 925), 'GPUtil.showUtilization', 'GPU.showUtilization', ([], {}), '()\n', (923, 925), True, 'import GPUtil as GPU\n'), ((988, 1017), 'GPUtil.showUtilization', 'GPU.showUtilization', ([], {'all': '(True)'}), '(all=True)\n', (1007, 1017), True, 'import GPUtil as GPU\n'), ((1219, 1232), 'GPUtil.getGPUs', 'GPU.getGP... |
# Copyright (c) 2010-2014 <NAME>.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distri... | [
"pyrimaa.util.TimeControl"
] | [((1295, 1316), 'pyrimaa.util.TimeControl', 'TimeControl', (['"""30s/1s"""'], {}), "('30s/1s')\n", (1306, 1316), False, 'from pyrimaa.util import TimeControl\n'), ((1368, 1388), 'pyrimaa.util.TimeControl', 'TimeControl', (['"""5m/1s"""'], {}), "('5m/1s')\n", (1379, 1388), False, 'from pyrimaa.util import TimeControl\n'... |
import bpy
import numpy
import mathutils
from enum import Enum
from mathutils import Matrix, Quaternion, Vector
import xml.etree.ElementTree as ET
import os
os.system('cls')
mesh_targets = {}
controller_targets = {}
images = {}
class SourceType(Enum):
Name_array = 0
float_array = 1
class DataType(Enum):
... | [
"mathutils.Matrix.Identity",
"numpy.asarray",
"xml.etree.ElementTree.Element",
"xml.etree.ElementTree.ElementTree",
"mathutils.Quaternion",
"mathutils.Matrix.Translation",
"os.system",
"xml.etree.ElementTree.SubElement"
] | [((158, 174), 'os.system', 'os.system', (['"""cls"""'], {}), "('cls')\n", (167, 174), False, 'import os\n'), ((695, 726), 'xml.etree.ElementTree.SubElement', 'ET.SubElement', (['domNode', '"""input"""'], {}), "(domNode, 'input')\n", (708, 726), True, 'import xml.etree.ElementTree as ET\n'), ((975, 1007), 'xml.etree.Ele... |
"""Time-related utilities."""
from __future__ import absolute_import
from __future__ import division
from __future__ import generator_stop
from __future__ import print_function
import datetime
def datetime_range(start, end, fmt='%Y%m%d'):
"""Change `start` and `end` string to datetime object.
Pa... | [
"datetime.datetime.strptime"
] | [((790, 828), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['start', 'fmt'], {}), '(start, fmt)\n', (816, 828), False, 'import datetime\n'), ((844, 880), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['end', 'fmt'], {}), '(end, fmt)\n', (870, 880), False, 'import datetime\n'), ((943, 981)... |
# Generated by Django 3.2.7 on 2021-10-26 08:55
import ckeditor_uploader.fields
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.... | [
"django.db.models.EmailField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.ImageField",
"django.db.models.BigAutoField",
"django.db.models.DateTimeField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
... | [((279, 336), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (310, 336), False, 'from django.db import migrations, models\n'), ((4009, 4123), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'djang... |
#!/usr/bin/python
import os
import sys
import glob
import argparse
import tempfile
import numpy as np
import matplotlib.pyplot as plt
import pickle
import scipy.stats as stats
from copy import deepcopy
from subprocess import Popen, PIPE
from get_qdec_info import get_qdec_info
from fs_load_stats import fs_load_stats
f... | [
"numpy.array",
"scipy.stats.ttest_ind",
"numpy.mean",
"argparse.ArgumentParser",
"subprocess.Popen",
"os.path.split",
"scipy.stats.spearmanr",
"get_qdec_info.get_qdec_info",
"pickle.load",
"numpy.nonzero",
"numpy.std",
"os.path.abspath",
"fs_load_stats.fs_load_stats",
"pickle.dump",
"os.... | [((770, 884), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Analyze aparc12 surface annotation: Surface area and average thickness"""'}), "(description=\n 'Analyze aparc12 surface annotation: Surface area and average thickness')\n", (793, 884), False, 'import argparse\n'), ((1810, 18... |
# INPUTS: BrainProtonDensitySlice.png
# OUTPUTS: FastMarchingImageFilterOutput5.png
# 81 114 1.0 -0.5 3.0 100 100
#
# INPUTS: BrainProtonDensitySlice.png
# OUTPUTS: FastMarchingImageFilterOutput6.png
# 99 114 1.0 -0.5 3.0 100 100
#
# INPUTS: BrainProtonDensitySlice.png
# OUTPU... | [
"itk.auto_progress",
"sys.exit"
] | [((926, 946), 'itk.auto_progress', 'itk.auto_progress', (['(2)'], {}), '(2)\n', (943, 946), False, 'import itk\n'), ((915, 922), 'sys.exit', 'exit', (['(1)'], {}), '(1)\n', (919, 922), False, 'from sys import argv, stderr, exit\n')] |
import pandas
import os
import math
import numpy
from scipy import stats
pandas.set_option('display.max_rows', 200, 'display.max_columns', 200) # change it to see more or less rows and/or columns
# Ask inputs to read the TSV file
dirPath = input('Enter path to TSV file: ')
inputName = input('Enter TSV name (input fil... | [
"pandas.isnull",
"numpy.mean",
"pandas.merge",
"numpy.log",
"math.sqrt",
"os.path.join",
"os.path.splitext",
"pandas.set_option",
"math.isnan"
] | [((74, 144), 'pandas.set_option', 'pandas.set_option', (['"""display.max_rows"""', '(200)', '"""display.max_columns"""', '(200)'], {}), "('display.max_rows', 200, 'display.max_columns', 200)\n", (91, 144), False, 'import pandas\n'), ((5100, 5199), 'pandas.merge', 'pandas.merge', (['meanAN_DF_gnomAD', 'meanAN_DF_CSVS'],... |
import bitwise as bw
class TestBitwiseNOT4:
def test_BitwiseNOT4(self):
a_bus_1 = bw.wire.Wire()
a_bus_2 = bw.wire.Wire()
a_bus_3 = bw.wire.Wire()
a_bus_4 = bw.wire.Wire()
a_bus = bw.wire.Bus4(a_bus_1, a_bus_2, a_bus_3, a_bus_4)
o_bus_1 = bw.wire.Wire()
o_b... | [
"bitwise.wire.Bus4",
"bitwise.logic.BitwiseNOT4",
"bitwise.wire.Wire"
] | [((96, 110), 'bitwise.wire.Wire', 'bw.wire.Wire', ([], {}), '()\n', (108, 110), True, 'import bitwise as bw\n'), ((129, 143), 'bitwise.wire.Wire', 'bw.wire.Wire', ([], {}), '()\n', (141, 143), True, 'import bitwise as bw\n'), ((162, 176), 'bitwise.wire.Wire', 'bw.wire.Wire', ([], {}), '()\n', (174, 176), True, 'import ... |
import numpy as np
import pandas as pd
import qrcode
import os
import sys
import time
#图像类别：emoji，动图，商品图片，文字图片，二维码，小程序码
#图像分类
from cv2 import cv2
from PIL import Image,ImageDraw
from datetime import datetime
import time
from pytesseract import image_to_string
class Detect():
def __init__(self):
pass
... | [
"PIL.Image.open",
"os.listdir",
"cv2.cv2.imread",
"cv2.cv2.CascadeClassifier",
"datetime.datetime.now",
"numpy.array",
"PIL.ImageDraw.Draw",
"pytesseract.image_to_string",
"cv2.cv2.cvtColor"
] | [((4069, 4083), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (4081, 4083), False, 'from datetime import datetime\n'), ((545, 567), 'cv2.cv2.imread', 'cv2.imread', (['image_name'], {}), '(image_name)\n', (555, 567), False, 'from cv2 import cv2\n'), ((591, 676), 'cv2.cv2.CascadeClassifier', 'cv2.CascadeClas... |
"""
LEGACY DFU HAS NOT BEEN IMPLEMENTED YET!
We will implement it when we will need it.
"""
import math
import pexpect
import time
from array import array
from util import *
from nrf_ble_dfu_controller import NrfBleDfuController
verbose = False
class Procedures:
START_DFU = 1
INITIALIZE_D... | [
"time.time",
"time.sleep"
] | [((5186, 5197), 'time.time', 'time.time', ([], {}), '()\n', (5195, 5197), False, 'import time\n'), ((5223, 5234), 'time.time', 'time.time', ([], {}), '()\n', (5232, 5234), False, 'import time\n'), ((6906, 6919), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (6916, 6919), False, 'import time\n'), ((8414, 8429), 't... |
# Add custom plugins here.
# If you want to make git not to track this file anymore,
# use `git update-index --skip-worktree app/plugin/__init__.py`
import flask
import app.plugin.ddc_docker as ddc_plugin_docker
def init_app(app: flask.Flask):
ddc_plugin_docker.init_app(app)
| [
"app.plugin.ddc_docker.init_app"
] | [((251, 282), 'app.plugin.ddc_docker.init_app', 'ddc_plugin_docker.init_app', (['app'], {}), '(app)\n', (277, 282), True, 'import app.plugin.ddc_docker as ddc_plugin_docker\n')] |
# Copyright 2016 VMware, Inc.
#
# 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 agree... | [
"sqlalchemy.String",
"sqlalchemy.PrimaryKeyConstraint",
"sqlalchemy.DateTime"
] | [((1310, 1344), 'sqlalchemy.PrimaryKeyConstraint', 'sa.PrimaryKeyConstraint', (['"""purpose"""'], {}), "('purpose')\n", (1333, 1344), True, 'import sqlalchemy as sa\n'), ((989, 1009), 'sqlalchemy.String', 'sa.String', ([], {'length': '(32)'}), '(length=32)\n', (998, 1009), True, 'import sqlalchemy as sa\n'), ((1061, 10... |
import os, sys
import numpy as np
from math import sqrt
# testing without install
#sys.path.insert(0, '../build/lib.macosx-10.9-x86_64-3.8')
import poppunk_refine
# Original PopPUNK function (with some improvements)
def withinBoundary(dists, x_max, y_max, slope=2):
boundary_test = np.ones((dists.shape[0]))
fo... | [
"poppunk_refine.assignThreshold",
"numpy.ones",
"math.sqrt",
"poppunk_refine.edgeThreshold",
"poppunk_refine.thresholdIterate2D",
"numpy.array",
"poppunk_refine.thresholdIterate1D",
"numpy.finfo",
"numpy.meshgrid",
"numpy.all",
"numpy.arange"
] | [((1345, 1383), 'numpy.arange', 'np.arange', (['(0)', '(1)', '(0.1)'], {'dtype': 'np.float32'}), '(0, 1, 0.1, dtype=np.float32)\n', (1354, 1383), True, 'import numpy as np\n'), ((1388, 1426), 'numpy.arange', 'np.arange', (['(0)', '(1)', '(0.1)'], {'dtype': 'np.float32'}), '(0, 1, 0.1, dtype=np.float32)\n', (1397, 1426)... |
import cv2
import numpy as np
from keras.datasets import cifar10
from keras import backend as K
from keras.utils import np_utils
nb_train_samples = 50000 # 3000 training samples
nb_valid_samples = 10000 # 100 validation samples
num_classes = 10
def load_cifar10_data(img_rows, img_cols, start=None, end=None, what_da... | [
"cv2.resize",
"keras.utils.np_utils.to_categorical",
"keras.datasets.cifar10.load_data",
"keras.backend.image_dim_ordering"
] | [((424, 443), 'keras.datasets.cifar10.load_data', 'cifar10.load_data', ([], {}), '()\n', (441, 443), False, 'from keras.datasets import cifar10\n'), ((1263, 1327), 'keras.utils.np_utils.to_categorical', 'np_utils.to_categorical', (['Y_train[:nb_train_samples]', 'num_classes'], {}), '(Y_train[:nb_train_samples], num_cla... |
from dagster import (
DependencyDefinition,
InputDefinition,
Int,
Output,
OutputDefinition,
PipelineDefinition,
RunConfig,
lambda_solid,
solid,
)
from dagster.core.execution.api import create_execution_plan, execute_plan
from dagster.core.instance import DagsterInstance
def define_... | [
"dagster.RunConfig",
"dagster.core.instance.DagsterInstance.ephemeral",
"dagster.core.execution.api.create_execution_plan",
"dagster.InputDefinition",
"dagster.Output",
"dagster.PipelineDefinition",
"dagster.OutputDefinition",
"dagster.DependencyDefinition"
] | [((799, 834), 'dagster.core.execution.api.create_execution_plan', 'create_execution_plan', (['pipeline_def'], {}), '(pipeline_def)\n', (820, 834), False, 'from dagster.core.execution.api import create_execution_plan, execute_plan\n'), ((2013, 2092), 'dagster.PipelineDefinition', 'PipelineDefinition', ([], {'name': '"""... |
from Raspi_MotorHAT.Raspi_PWM_Servo_Driver import PWM
class Servos(object):
def __init__(self, addr=0x6f, deflect_90_in_ms = 0.9):
"""addr: The i2c address of the PWM chip.
deflect_90_in_ms: set this to calibrate the servo motors.
it is what a deflection of 90 degrees is
... | [
"Raspi_MotorHAT.Raspi_PWM_Servo_Driver.PWM"
] | [((413, 422), 'Raspi_MotorHAT.Raspi_PWM_Servo_Driver.PWM', 'PWM', (['addr'], {}), '(addr)\n', (416, 422), False, 'from Raspi_MotorHAT.Raspi_PWM_Servo_Driver import PWM\n')] |
import swapper
from rest_framework.generics import ListAPIView, ListCreateAPIView
from rest_framework.response import Response
from rest_framework.views import APIView
from openwisp_users.api.authentication import BearerAuthentication
from openwisp_users.api.mixins import (
FilterByOrganizationManaged,
FilterB... | [
"rest_framework.response.Response",
"swapper.load_model"
] | [((856, 908), 'swapper.load_model', 'swapper.load_model', (['"""openwisp_users"""', '"""Organization"""'], {}), "('openwisp_users', 'Organization')\n", (874, 908), False, 'import swapper\n'), ((1497, 1509), 'rest_framework.response.Response', 'Response', (['{}'], {}), '({})\n', (1505, 1509), False, 'from rest_framework... |
from torch.utils.data import ConcatDataset
from ssd.config.path_catlog import DatasetCatalog
from .voc_dataset import VOCDataset
from .coco_dataset import COCODataset
def build_dataset(dataset_list, transform=None, target_transform=None, is_test=False):
assert len(dataset_list) > 0
datasets = []
for data... | [
"torch.utils.data.ConcatDataset",
"ssd.config.path_catlog.DatasetCatalog.get"
] | [((361, 393), 'ssd.config.path_catlog.DatasetCatalog.get', 'DatasetCatalog.get', (['dataset_name'], {}), '(dataset_name)\n', (379, 393), False, 'from ssd.config.path_catlog import DatasetCatalog\n'), ((753, 776), 'torch.utils.data.ConcatDataset', 'ConcatDataset', (['datasets'], {}), '(datasets)\n', (766, 776), False, '... |
import pandas as pd
def read_clean_csv(path, sep='|'):
"""will read and clean a csv file'"""
df = pd.read_csv(path, sep=sep)
if('Unnamed: 0' in df.columns.values):
df = remove_unnamed(df)
return(df)
def remove_unnamed(df):
df = df.drop('Unnamed: 0', 1)
return df
| [
"pandas.read_csv"
] | [((104, 130), 'pandas.read_csv', 'pd.read_csv', (['path'], {'sep': 'sep'}), '(path, sep=sep)\n', (115, 130), True, 'import pandas as pd\n')] |
"""Read a GO Association File (GAF) and store the data in a Python object.
Annotations available from the Gene Ontology Consortium:
http://geneontology.org/page/download-annotations
GAF format:
http://geneontology.org/page/go-annotation-file-formats
"""
import sys
import re
import collections... | [
"re.split",
"goatools.base.nopen",
"re.compile",
"collections.Counter",
"goatools.evidence_codes.EvidenceCodes"
] | [((8166, 8201), 're.compile', 're.compile', (['"""^!(\\\\w[\\\\w\\\\s-]+:.*)$"""'], {}), "('^!(\\\\w[\\\\w\\\\s-]+:.*)$')\n", (8176, 8201), False, 'import re\n'), ((2562, 2577), 'goatools.evidence_codes.EvidenceCodes', 'EvidenceCodes', ([], {}), '()\n', (2575, 2577), False, 'from goatools.evidence_codes import Evidence... |