code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from Interaction import Interaction
from Adversary import Adversary
from EventNode import EventNode
import random
# create a set of interactions
# create set of rewards
# create interaction name
def assignJobs(people,titles):
# Find out how many of each profession you're going to have.
arr = []
for i in ra... | [
"EventNode.EventNode",
"random.sample",
"random.choice",
"Adversary.Adversary",
"random.randint",
"Interaction.Interaction"
] | [((4644, 4671), 'random.sample', 'random.sample', (['allTitles', '(3)'], {}), '(allTitles, 3)\n', (4657, 4671), False, 'import random\n'), ((4684, 4711), 'random.sample', 'random.sample', (['allPeople', '(3)'], {}), '(allPeople, 3)\n', (4697, 4711), False, 'import random\n'), ((5001, 5027), 'random.sample', 'random.sam... |
from Root import b
import unittest
class test1(unittest.TestCase):
def test_shuffle(self):
self.assertEqual(b.add(1,2),3)
def test_add(self):
self.assertEqual(b.add(4,2),6)
def test_addFail(self):
self.assertEqual(b.add(1,2),4)
if __name__ == '__main__':
unittest.main()
| [
"unittest.main",
"Root.b.add"
] | [((265, 280), 'unittest.main', 'unittest.main', ([], {}), '()\n', (278, 280), False, 'import unittest\n'), ((111, 122), 'Root.b.add', 'b.add', (['(1)', '(2)'], {}), '(1, 2)\n', (116, 122), False, 'from Root import b\n'), ((165, 176), 'Root.b.add', 'b.add', (['(4)', '(2)'], {}), '(4, 2)\n', (170, 176), False, 'from Root... |
"""
Copyright (C) 2009
<NAME> <<EMAIL>>
<NAME> <<EMAIL>>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later ve... | [
"ply.lex.lex"
] | [((4048, 4057), 'ply.lex.lex', 'lex.lex', ([], {}), '()\n', (4055, 4057), True, 'import ply.lex as lex\n')] |
from setuptools import setup, find_packages
setup(name='wield_services',
version='0.1',
description='A reactive debuggable CICD & orchestration management project'
'running a kubernetes micro-service cluster',
url='https://github.com/hamshif/wild-services.git',
author='gbar',
... | [
"setuptools.find_packages"
] | [((386, 401), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (399, 401), False, 'from setuptools import setup, find_packages\n')] |
from __future__ import unicode_literals, print_function
import base64
import os
from django.conf import settings
from django.core.management.base import BaseCommand
from credocommon.models import Detection, Ping
def gen(data):
for d in data:
if d.get("frame_content"):
d["frame_content"] = b... | [
"simplejson.JSONEncoder",
"boto3.resource",
"base64.b64encode",
"os.remove"
] | [((1762, 1921), 'boto3.resource', 'boto3.resource', (['"""s3"""'], {'aws_access_key_id': 'settings.S3_ACCESS_KEY_ID', 'aws_secret_access_key': 'settings.S3_SECRET_KEY', 'endpoint_url': 'settings.S3_ENDPOINT_URL'}), "('s3', aws_access_key_id=settings.S3_ACCESS_KEY_ID,\n aws_secret_access_key=settings.S3_SECRET_KEY, e... |
from django.db import models
from django.contrib.auth.models import User
class Company(models.Model):
company_name = models.CharField(max_length=50, blank=False)
class Meta:
verbose_name_plural = "companies"
def __str__(self):
return self.company_name
# Extra user information in a... | [
"django.db.models.OneToOneField",
"django.db.models.EmailField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((125, 169), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)', 'blank': '(False)'}), '(max_length=50, blank=False)\n', (141, 169), False, 'from django.db import models\n'), ((410, 436), 'django.db.models.ForeignKey', 'models.ForeignKey', (['Company'], {}), '(Company)\n', (427, 436), False, ... |
import os.path
import time
import typing
import numpy # type: ignore
from d3m import container, exceptions, utils
from d3m.metadata import base as metadata_base, hyperparams
from d3m.primitive_interfaces import base, transformer
from . import __author__, __version__, null
__all__ = ('PrimitiveSumPrimitive',)
Inpu... | [
"d3m.exceptions.InvalidArgumentValueError",
"time.perf_counter"
] | [((5309, 5328), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (5326, 5328), False, 'import time\n'), ((6071, 6159), 'd3m.exceptions.InvalidArgumentValueError', 'exceptions.InvalidArgumentValueError', (['"""No primitives provided as hyper-parameters."""'], {}), "(\n 'No primitives provided as hyper-para... |
# predictor_api.py
import json
from ibm_watson import NaturalLanguageUnderstandingV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator
from ibm_watson.natural_language_understanding_v1 import Features, EmotionOptions, SentimentOptions, KeywordsOptions
from .. import credentials_path
def get_ibm_nlu():
... | [
"ibm_watson.natural_language_understanding_v1.SentimentOptions",
"ibm_watson.NaturalLanguageUnderstandingV1",
"ibm_cloud_sdk_core.authenticators.IAMAuthenticator",
"ibm_watson.natural_language_understanding_v1.EmotionOptions",
"ibm_watson.natural_language_understanding_v1.KeywordsOptions"
] | [((595, 633), 'ibm_cloud_sdk_core.authenticators.IAMAuthenticator', 'IAMAuthenticator', (["ibm_creds['api_key']"], {}), "(ibm_creds['api_key'])\n", (611, 633), False, 'from ibm_cloud_sdk_core.authenticators import IAMAuthenticator\n'), ((644, 730), 'ibm_watson.NaturalLanguageUnderstandingV1', 'NaturalLanguageUnderstand... |
from django.urls import path
from todo_app import views
urlpatterns = [
path('',views.home,name='home'),
path('home',views.home,name='home'),
path('add',views.add_task,name='addtask'),
path('home/<id>',views.home,name='home')
] | [
"django.urls.path"
] | [((77, 110), 'django.urls.path', 'path', (['""""""', 'views.home'], {'name': '"""home"""'}), "('', views.home, name='home')\n", (81, 110), False, 'from django.urls import path\n'), ((114, 151), 'django.urls.path', 'path', (['"""home"""', 'views.home'], {'name': '"""home"""'}), "('home', views.home, name='home')\n", (11... |
"""
Scipy utils.
<NAME>
10 June 2021
"""
import numpy as np
import scipy.optimize as sci
import warnings
all = ['fsolve']
def fsolve(f, x0=1.0, args=None):
"scipy.optimize.fsolve shell"
[x] = sci.fsolve(f, x0=x0, args=args)
return x
# --------------------------------------------------------... | [
"scipy.optimize.fsolve"
] | [((213, 244), 'scipy.optimize.fsolve', 'sci.fsolve', (['f'], {'x0': 'x0', 'args': 'args'}), '(f, x0=x0, args=args)\n', (223, 244), True, 'import scipy.optimize as sci\n')] |
#!/usr/bin/env python3
"""
git_odoo
usage:
git_odoo checkout (<version>... | --dbname <dbname>)
git_odoo pull [--version <version> | --all]
git_odoo fetch
git_odoo list
options:
--dbname=<dbname> name of the database to use to select the right version to checkout
--version=<version> ... | [
"psycopg2.connect",
"docopt.docopt",
"git.Repo"
] | [((9589, 9604), 'docopt.docopt', 'docopt', (['__doc__'], {}), '(__doc__)\n', (9595, 9604), False, 'from docopt import docopt\n'), ((6497, 6535), 'psycopg2.connect', 'psycopg2.connect', (['f"""dbname=\'{dbname}\'"""'], {}), '(f"dbname=\'{dbname}\'")\n', (6513, 6535), False, 'import psycopg2\n'), ((1289, 1301), 'git.Repo... |
"""
utilities routines associated with Kubernetes python client
"""
import os
import copy
import base64
import yaml
from kubernetes import client, config
from kubernetes.client.rest import ApiException
from pandaharvester.harvesterconfig import harvester_config
from pandaharvester.harvestermisc.info_utils import Pan... | [
"kubernetes.client.BatchV1Api",
"kubernetes.client.V1DeleteOptions",
"kubernetes.client.V1Secret",
"kubernetes.client.CoreV1Api",
"base64.b64encode",
"kubernetes.config.load_kube_config",
"yaml.load",
"os.path.basename",
"pandaharvester.harvestermisc.info_utils.PandaQueuesDict",
"copy.deepcopy"
] | [((423, 471), 'kubernetes.config.load_kube_config', 'config.load_kube_config', ([], {'config_file': 'config_file'}), '(config_file=config_file)\n', (446, 471), False, 'from kubernetes import client, config\n'), ((557, 575), 'kubernetes.client.CoreV1Api', 'client.CoreV1Api', ([], {}), '()\n', (573, 575), False, 'from ku... |
#! /bin/sh
# -*- coding: utf-8 -*-
""":"
exec python3 $0 ${1+"$@"}
"""
# * ********************************************************************* *
# * Copyright (C) 2018 by xmz *
# * ********************************************************************* *
'''
BIN to ASCII con... | [
"logging.basicConfig",
"signal.signal",
"argparse.FileType",
"argparse.ArgumentParser",
"bintexttools.BinTextCommon.str2Bool",
"bintexttools.BinTextCommon.getTimestempFileName",
"os.access",
"argparse.ArgumentTypeError",
"os.unlink",
"sys.exit",
"re.sub",
"logging.info",
"bintexttools.BinTex... | [((2129, 2187), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'applicationNameString'}), '(description=applicationNameString)\n', (2152, 2187), False, 'import argparse\n'), ((3965, 4107), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""[%(asctime)s][%(levelname)-8s] [%(mod... |
# coding: utf-8
"""
Octopus Server API
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501
OpenAPI spec version: 2019.6.7+Branch.tags-2019.6.7.Sha.aa18dc6809953218c66f57eff7d26481d9b23d6a
Generated by: https://github.com/swagger-api... | [
"unittest.main"
] | [((3285, 3300), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3298, 3300), False, 'import unittest\n')] |
from django.test import TestCase
from curious.graph import traverse
from curious_tests.models import Blog, Entry, Author
from curious_tests import assertQueryResultsEqual
class TestFunc(TestCase):
def setUp(self):
blog = Blog(name='Databases')
blog.save()
self.blogs = [blog]
authors = ('<NAME>', '<... | [
"curious_tests.models.Blog",
"curious_tests.models.Author",
"curious_tests.models.Entry",
"curious_tests.models.Blog.authors",
"curious.graph.traverse"
] | [((229, 251), 'curious_tests.models.Blog', 'Blog', ([], {'name': '"""Databases"""'}), "(name='Databases')\n", (233, 251), False, 'from curious_tests.models import Blog, Entry, Author\n'), ((965, 999), 'curious.graph.traverse', 'traverse', (['self.blogs', 'Blog.authors'], {}), '(self.blogs, Blog.authors)\n', (973, 999),... |
"""
Provides functionality for persistence of data
"""
import csv
import os
from abc import ABC, abstractmethod
from collections import OrderedDict
from dataclasses import dataclass
@dataclass
class EmissionsData:
"""
Output object containg experiment data
"""
timestamp: str
experiment_id: str
... | [
"os.path.isfile"
] | [((1256, 1291), 'os.path.isfile', 'os.path.isfile', (['self.save_file_path'], {}), '(self.save_file_path)\n', (1270, 1291), False, 'import os\n')] |
from httpie.plugins import TransportPlugin
from lambda_requests import DEFAULT_SCHEME, LambdaAdapter
class LambdaTransportPlugin(TransportPlugin):
name = "AWS Lambda invoke transport"
prefix = DEFAULT_SCHEME
def get_adapter(self):
return LambdaAdapter()
| [
"lambda_requests.LambdaAdapter"
] | [((262, 277), 'lambda_requests.LambdaAdapter', 'LambdaAdapter', ([], {}), '()\n', (275, 277), False, 'from lambda_requests import DEFAULT_SCHEME, LambdaAdapter\n')] |
import setuptools
with open("README.md", "r", encoding="utf-8") as fh:
long_description = fh.read()
setuptools.setup(
name="speednet", # Replace with your own username
version="0.0.0",
author="<NAME>",
author_email="<EMAIL>",
description="This is a package that aims to make various neural netw... | [
"setuptools.find_packages"
] | [((540, 566), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (564, 566), False, 'import setuptools\n')] |
from olymptester.olymptester import main
main() | [
"olymptester.olymptester.main"
] | [((42, 48), 'olymptester.olymptester.main', 'main', ([], {}), '()\n', (46, 48), False, 'from olymptester.olymptester import main\n')] |
from util.reply import get_reply
import discord
async def ask_players(ctx, players):
# getting responses from the two players for rock paper or scissors
choices = []
for num, player in enumerate(players):
# 3 times to enter either rock paper or scissors
if num == 0:
await playe... | [
"util.reply.get_reply"
] | [((657, 688), 'util.reply.get_reply', 'get_reply', (['ctx', '(30)'], {'user': 'player'}), '(ctx, 30, user=player)\n', (666, 688), False, 'from util.reply import get_reply\n'), ((2341, 2378), 'util.reply.get_reply', 'get_reply', (['ctx', '(30)'], {'channel_user': 'user'}), '(ctx, 30, channel_user=user)\n', (2350, 2378),... |
import random
from turtle import Turtle, Screen
screen = Screen()
height = 600
width = 600
screen.setup(width=width, height=height)
# creating an instances of the Turtle class
tim = Turtle()
tom = Turtle()
zak = Turtle()
ala = Turtle()
wafel = Turtle()
mariusz = Turtle()
drawer = Turtle()
players = [tom, tim, mariusz... | [
"turtle.Screen",
"random.randint",
"turtle.Turtle"
] | [((58, 66), 'turtle.Screen', 'Screen', ([], {}), '()\n', (64, 66), False, 'from turtle import Turtle, Screen\n'), ((184, 192), 'turtle.Turtle', 'Turtle', ([], {}), '()\n', (190, 192), False, 'from turtle import Turtle, Screen\n'), ((199, 207), 'turtle.Turtle', 'Turtle', ([], {}), '()\n', (205, 207), False, 'from turtle... |
# builtins
import os
import unittest
from unittest.mock import patch, mock_open, Mock
# ours
from .decorators import provider
from src.config_lib import get_config, ConfigError
import src.config_lib
class ConfigLibTests(unittest.TestCase):
def setUp(self):
self.open_patcher = patch.object(src.config_lib,... | [
"os.environ.keys",
"unittest.mock.mock_open",
"os.environ.get",
"src.config_lib.get_config",
"unittest.mock.patch"
] | [((395, 423), 'unittest.mock.patch', 'patch', (['"""src.config_lib.yaml"""'], {}), "('src.config_lib.yaml')\n", (400, 423), False, 'from unittest.mock import patch, mock_open, Mock\n'), ((980, 1017), 'os.environ.get', 'os.environ.get', (['"""CRUSCA_OWNERS_REPOS"""'], {}), "('CRUSCA_OWNERS_REPOS')\n", (994, 1017), False... |
r"""
Utility functions for snakemake files
"""
# pylint: disable=missing-function-docstring, redefined-outer-name
from functools import reduce
from operator import add
from pathlib import Path
def conf_expand_pattern(conf, placeholder="null"):
expand_pattern = "-".join(f"{key}:{{{key}}}" for key in conf)
re... | [
"snakemake.io.expand",
"pathlib.Path"
] | [((801, 829), 'snakemake.io.expand', 'expand', (['pattern'], {}), '(pattern, **wildcards)\n', (807, 829), False, 'from snakemake.io import expand\n'), ((2541, 2785), 'snakemake.io.expand', 'expand', (['"""results/raw/{dataset}/{subsample_conf}/{prior_conf}/{method}/{hyperparam_conf}/seed:{seed}"""'], {'dataset': 'datas... |
import unittest
from bobocep.receiver.bobo_receiver import BoboReceiver
from bobocep.receiver.formatters.primitive_event_formatter import \
PrimitiveEventFormatter
from bobocep.receiver.receiver_subscriber import IReceiverSubscriber
from bobocep.receiver.validators.str_dict_validator import StrDictValidator
from b... | [
"bobocep.receiver.formatters.primitive_event_formatter.PrimitiveEventFormatter",
"bobocep.receiver.validators.str_dict_validator.StrDictValidator"
] | [((938, 956), 'bobocep.receiver.validators.str_dict_validator.StrDictValidator', 'StrDictValidator', ([], {}), '()\n', (954, 956), False, 'from bobocep.receiver.validators.str_dict_validator import StrDictValidator\n'), ((958, 983), 'bobocep.receiver.formatters.primitive_event_formatter.PrimitiveEventFormatter', 'Primi... |
import argparse
import functools
import time
import wave
import paddle.fluid as fluid
import pyaudio
from data_utils.data import DataGenerator
from model_utils.model import DeepSpeech2Model
from utils.utility import add_arguments, print_arguments
parser = argparse.ArgumentParser(description=__doc__)
add_arg = functoo... | [
"wave.open",
"data_utils.data.DataGenerator",
"argparse.ArgumentParser",
"paddle.fluid.CPUPlace",
"utils.utility.print_arguments",
"functools.partial",
"model_utils.model.DeepSpeech2Model",
"paddle.fluid.CUDAPlace",
"pyaudio.PyAudio",
"time.time"
] | [((258, 302), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (281, 302), False, 'import argparse\n'), ((313, 363), 'functools.partial', 'functools.partial', (['add_arguments'], {'argparser': 'parser'}), '(add_arguments, argparser=parser)\n', (330, 363)... |
from matplotlib import pyplot as plt
from optimism.JaxConfig import *
from optimism import EquationSolver as EqSolver
from optimism import Mesh
from optimism import Mechanics
from optimism import FunctionSpace
from optimism.Mesh import EssentialBC
from optimism.Mesh import DofManager
from optimism import Objective
fr... | [
"optimism.ConstrainedObjective.ConstrainedQuasiObjective",
"optimism.AlSolver.get_settings",
"optimism.Objective.Params",
"optimism.QuadratureRule.eval_at_iso_points",
"optimism.Surface.get_field_index",
"optimism.VTKWriter.VTKWriter",
"optimism.Surface.eval_field",
"optimism.EquationSolver.get_settin... | [((849, 937), 'optimism.EquationSolver.get_settings', 'EqSolver.get_settings', ([], {'use_incremental_objective': '(False)', 'min_tr_size': '(1e-15)', 'tol': '(1e-07)'}), '(use_incremental_objective=False, min_tr_size=1e-15,\n tol=1e-07)\n', (870, 937), True, 'from optimism import EquationSolver as EqSolver\n'), ((1... |
# -*- coding: utf-8 -*-
# Copyright (C) 2013 Mag. <NAME> All rights reserved
# Glasauergasse 32, A--1130 Wien, Austria. <EMAIL>
# #*** <License> ************************************************************#
# This module is part of the package GTW.OMP.PAP.
#
# This module is licensed under the terms of the BSD 3-Claus... | [
"_GTW.GTW.OMP.PAP._Export"
] | [((1441, 1465), '_GTW.GTW.OMP.PAP._Export', 'GTW.OMP.PAP._Export', (['"""*"""'], {}), "('*')\n", (1460, 1465), False, 'from _GTW import GTW\n')] |
from humancellatlas.data.metadata.api import (
Bundle,
CellSuspension,
LibraryPreparationProtocol,
)
from humancellatlas.data.metadata.helpers.dss import (
download_bundle_metadata,
dss_client,
)
from pipeline_tools.shared.exceptions import (
UnsupportedOrganismException,
UnsupportedLibraryP... | [
"humancellatlas.data.metadata.helpers.dss.dss_client",
"humancellatlas.data.metadata.helpers.dss.download_bundle_metadata",
"pipeline_tools.shared.exceptions.UnsupportedOrganismException",
"humancellatlas.data.metadata.api.Bundle",
"pipeline_tools.shared.exceptions.UnsupportedLibraryPrepException"
] | [((1094, 1204), 'humancellatlas.data.metadata.helpers.dss.download_bundle_metadata', 'download_bundle_metadata', ([], {'client': 'client', 'replica': '"""gcp"""', 'uuid': 'uuid', 'version': 'version', 'directurls': 'directurls'}), "(client=client, replica='gcp', uuid=uuid, version=\n version, directurls=directurls)\... |
# -*- coding: utf-8 -*-
# © 2016 <NAME>
# © 2016 Niboo SPRL (<https://www.niboo.be/>)
# License AGPL-3.0 or later (https://www.gnu.org/licenses/agpl.html).
from odoo import api, exceptions, fields, models
class ProjectProject(models.Model):
_inherit = 'project.project'
scrum_team_id = fields.Many2one('proje... | [
"odoo.api.constrains",
"odoo.fields.Date",
"odoo.fields.Many2one",
"odoo.fields.Integer",
"odoo.exceptions.ValidationError",
"odoo.fields.One2many",
"odoo.api.depends",
"odoo.fields.Char",
"odoo.fields.Boolean"
] | [((298, 349), 'odoo.fields.Many2one', 'fields.Many2one', (['"""project.scrum.team"""', '"""Scrum Team"""'], {}), "('project.scrum.team', 'Scrum Team')\n", (313, 349), False, 'from odoo import api, exceptions, fields, models\n'), ((435, 476), 'odoo.fields.Char', 'fields.Char', ([], {'string': '"""Name"""', 'required': '... |
import numpy as np
import math
import pickle
from tensorflow.python.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import (Dropout, Embedding, Dense, GRU, Bidirectional)
from tensorfl... | [
"pickle.dump",
"tensorflow.keras.preprocessing.sequence.pad_sequences",
"tensorflow.python.keras.preprocessing.text.Tokenizer",
"tensorflow.keras.layers.Embedding",
"tensorflow.keras.callbacks.EarlyStopping",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.callbacks.ModelCheckpoint",
"tensorflow.ke... | [((510, 521), 'tensorflow.python.keras.preprocessing.text.Tokenizer', 'Tokenizer', ([], {}), '()\n', (519, 521), False, 'from tensorflow.python.keras.preprocessing.text import Tokenizer\n'), ((1051, 1115), 'tensorflow.keras.preprocessing.sequence.pad_sequences', 'pad_sequences', (['X_train_tokens'], {'maxlen': 'seq_len... |
from rest_framework import serializers
from ..models import Condition
class ConditionExportSerializer(serializers.ModelSerializer):
source = serializers.CharField(source='source.uri', default=None, read_only=True)
target_option = serializers.CharField(source='target_option.uri', default=None, read_only=True... | [
"rest_framework.serializers.CharField"
] | [((149, 221), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'source': '"""source.uri"""', 'default': 'None', 'read_only': '(True)'}), "(source='source.uri', default=None, read_only=True)\n", (170, 221), False, 'from rest_framework import serializers\n'), ((242, 321), 'rest_framework.serializers... |
# Generated by Django 3.0.4 on 2020-03-14 04:03
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
initial = True
dependencies = [
('user', '0002_auto_20200314_0331'),
]
operations = [
migrat... | [
"django.db.models.Index",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((1520, 1594), 'django.db.models.Index', 'models.Index', ([], {'fields': "['session_id']", 'name': '"""ttp_documen_session_27171c_idx"""'}), "(fields=['session_id'], name='ttp_documen_session_27171c_idx')\n", (1532, 1594), False, 'from django.db import migrations, models\n'), ((411, 462), 'django.db.models.AutoField',... |
from django.core.validators import RegexValidator
from django.core.exceptions import ValidationError
from django.db import models
invalid_format = "Invalid Format for Grad Year (YY-YY)"
grad_year_validator_format = RegexValidator("^[0-9]{2}-[0-9]{2}$",
invalid_format,
... | [
"django.core.validators.RegexValidator",
"django.core.exceptions.ValidationError",
"django.db.models.CharField"
] | [((216, 286), 'django.core.validators.RegexValidator', 'RegexValidator', (['"""^[0-9]{2}-[0-9]{2}$"""', 'invalid_format'], {'code': '"""gradYear"""'}), "('^[0-9]{2}-[0-9]{2}$', invalid_format, code='gradYear')\n", (230, 286), False, 'from django.core.validators import RegexValidator\n'), ((747, 852), 'django.db.models.... |
# Copyright (C) 2012-2016 - <NAME> <<EMAIL>>
# This program is Free Software see LICENSE file for details
import jedi
from commands.find_usages import FindUsages
from handlers.jedi_handler import JediHandler
_code = 'from _usages_helper import usages_helper'
class TestFindUsages(object):
"""FindUsages tests s... | [
"handlers.jedi_handler.JediHandler",
"jedi.Script"
] | [((576, 634), 'handlers.jedi_handler.JediHandler', 'JediHandler', (['"""usages"""', 'data', '(0)', '(0)', 'self._check_find_usages'], {}), "('usages', data, 0, 0, self._check_find_usages)\n", (587, 634), False, 'from handlers.jedi_handler import JediHandler\n'), ((421, 439), 'jedi.Script', 'jedi.Script', (['_code'], {}... |
from marshmallow import class_registry, fields
from marshmallow.base import SchemaABC
class RelatedResourceLinkField(fields.Field):
def __init__(
self,
schema=None,
many=False,
microservice_aware=False,
**kwargs
):
self._schema_arg = schema
... | [
"marshmallow.class_registry.get_class"
] | [((1048, 1090), 'marshmallow.class_registry.get_class', 'class_registry.get_class', (['self._schema_arg'], {}), '(self._schema_arg)\n', (1072, 1090), False, 'from marshmallow import class_registry, fields\n'), ((3062, 3104), 'marshmallow.class_registry.get_class', 'class_registry.get_class', (['self._schema_arg'], {}),... |
import torch
import torch.nn as nn
_input_size = 4
_seq_len = 2
_batch = 3
_hidden_size = 3
# model
class net_RNN(nn.Module):
def __init__(self):
super().__init__()
self.op = nn.RNN(_input_size, _hidden_size, 1)
def forward(self, input):
return self.op(input)
_model_ = net_RNN()
#... | [
"torch.nn.RNN",
"torch.randn"
] | [((363, 405), 'torch.randn', 'torch.randn', (['_seq_len', '_batch', '_input_size'], {}), '(_seq_len, _batch, _input_size)\n', (374, 405), False, 'import torch\n'), ((198, 234), 'torch.nn.RNN', 'nn.RNN', (['_input_size', '_hidden_size', '(1)'], {}), '(_input_size, _hidden_size, 1)\n', (204, 234), True, 'import torch.nn ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Service functions
Configure console and file logging;
Create and handle config file for database connection;
SPDX-License-Identifier: AGPL-3.0-or-later
"""
__copyright__ = "© <NAME>"
__license__ = "GNU Affero General Public License Version 3 (AGPL-3.0)"
__url__ = "h... | [
"logging.getLogger",
"logging.StreamHandler",
"pandas.read_csv",
"logging.Formatter",
"os.path.dirname",
"logging.FileHandler"
] | [((489, 516), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (506, 516), False, 'import logging\n'), ((771, 790), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (788, 790), False, 'import logging\n'), ((880, 972), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s %(... |
import time
from collections import Counter
from pprint import pprint
from tabulate import tabulate
from tinydb import Query, TinyDB
db = TinyDB("db.json")
def started(task):
return task["start"] is not None
def pending(task):
return not completed(task)
def completed(task):
return task["addr_payload... | [
"tabulate.tabulate",
"tinydb.Query",
"tinydb.TinyDB"
] | [((140, 157), 'tinydb.TinyDB', 'TinyDB', (['"""db.json"""'], {}), "('db.json')\n", (146, 157), False, 'from tinydb import Query, TinyDB\n'), ((1835, 1842), 'tinydb.Query', 'Query', ([], {}), '()\n', (1840, 1842), False, 'from tinydb import Query, TinyDB\n'), ((2581, 2604), 'tabulate.tabulate', 'tabulate', (['rows', 'he... |
from jinja2 import Environment, FileSystemLoader, Template
from abc import ABC, abstractmethod
import shutil
import os
class AbstractGenerator(ABC):
def __init__(self, base, dest):
self.base = base
self.dest = dest
@abstractmethod
def generate(self, config, base, dest):
pass
... | [
"os.path.exists",
"shutil.ignore_patterns",
"shutil.copytree",
"shutil.rmtree",
"jinja2.FileSystemLoader"
] | [((347, 372), 'os.path.exists', 'os.path.exists', (['self.dest'], {}), '(self.dest)\n', (361, 372), False, 'import os\n'), ((429, 524), 'shutil.ignore_patterns', 'shutil.ignore_patterns', (['"""template"""', '"""template/*"""', '"""Generator.py"""', '"""__pycache__"""', '"""meta.yml"""'], {}), "('template', 'template/*... |
from discord.ext import commands
from carberretta import Config
class CustomCheckFailure(commands.CheckAnyFailure):
def __init__(self, message):
self.msg = message
class CanNotVerifyQt(CustomCheckFailure):
def __init__(self):
super().__init__("You can not verify QTs.")
def can_verify_qts(... | [
"discord.ext.commands.check"
] | [((470, 495), 'discord.ext.commands.check', 'commands.check', (['predicate'], {}), '(predicate)\n', (484, 495), False, 'from discord.ext import commands\n')] |
""" fiona.tool
Converts Shapefiles (etc) to GeoJSON.
"""
import json
import logging
import pprint
import sys
from six.moves import map
import fiona
def open_output(arg):
"""Returns an opened output stream."""
if arg == sys.stdout:
return arg
else:
return open(arg, 'w')
def make_ld_con... | [
"logging.basicConfig",
"logging.getLogger",
"argparse.ArgumentParser",
"json.dumps",
"fiona.open",
"six.moves.map",
"fiona.drivers",
"json.dump"
] | [((7775, 7833), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stderr', 'level': 'logging.INFO'}), '(stream=sys.stderr, level=logging.INFO)\n', (7794, 7833), False, 'import logging\n'), ((7847, 7878), 'logging.getLogger', 'logging.getLogger', (['"""fiona.tool"""'], {}), "('fiona.tool')\n", (7864, 78... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
" Location Head."
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.init import kaiming_uniform, normal
from alphastarmini.lib.hyper_parameters import Arch_Hyper_Parameters as AHP
from alphastarmini.lib.hype... | [
"torch.nn.BatchNorm2d",
"torch.multinomial",
"torch.nn.Softmax",
"torch.nn.ModuleList",
"alphastarmini.lib.utils.get_location_mask",
"torch.nn.Conv2d",
"torch.randint",
"numpy.array",
"torch.tensor",
"torch.nn.functional.relu",
"torch.nn.Linear",
"torch.zeros",
"alphastarmini.lib.utils.actio... | [((14470, 14528), 'torch.randn', 'torch.randn', (['batch_size', 'AHP.autoregressive_embedding_size'], {}), '(batch_size, AHP.autoregressive_embedding_size)\n', (14481, 14528), False, 'import torch\n'), ((14658, 14728), 'torch.randint', 'torch.randint', ([], {'low': '(0)', 'high': 'SFS.available_actions', 'size': '(batc... |
import argparse
from gym.spaces import Box, Discrete
import os
from ray.rllib.examples.env.action_mask_env import ActionMaskEnv
from ray.rllib.examples.models.action_mask_model import \
ActionMaskModel, TorchActionMaskModel
parser = argparse.ArgumentParser()
parser.add_argument(
"--run",
type=str,
def... | [
"ray.shutdown",
"argparse.ArgumentParser",
"os.environ.get",
"gym.spaces.Discrete",
"gym.spaces.Box",
"ray.init",
"ray.tune.run"
] | [((239, 264), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (262, 264), False, 'import argparse\n'), ((1226, 1294), 'ray.init', 'ray.init', ([], {'num_cpus': '(args.num_cpus or None)', 'local_mode': 'args.local_mode'}), '(num_cpus=args.num_cpus or None, local_mode=args.local_mode)\n', (1234, 1... |
import time
import pyautogui
# 주 모니터 사이즈 얻기
screen_width, screen_height = pyautogui.size()
"""마우스"""
current_mouse_x, current_mouse_y = pyautogui.position() # 마우스 X, Y 좌표 얻기
pyautogui.moveTo(100, 150, duration=0.25) # 마우스 이동 0.25초 동안 이동
pyautogui.click() # 마우스 클릭
pyautogui.click(100, 200, duration=1) # 마우스 좌표 1초 ... | [
"pyautogui.drag",
"pyautogui.hotkey",
"pyautogui.write",
"pyautogui.press",
"pyautogui.move",
"pyautogui.moveTo",
"pyautogui.keyDown",
"pyautogui.scroll",
"pyautogui.size",
"pyautogui.click",
"pyautogui.keyUp",
"pyautogui.alert",
"pyautogui.position"
] | [((75, 91), 'pyautogui.size', 'pyautogui.size', ([], {}), '()\n', (89, 91), False, 'import pyautogui\n'), ((138, 158), 'pyautogui.position', 'pyautogui.position', ([], {}), '()\n', (156, 158), False, 'import pyautogui\n'), ((177, 218), 'pyautogui.moveTo', 'pyautogui.moveTo', (['(100)', '(150)'], {'duration': '(0.25)'})... |
# MySQL Connector/Python - MySQL driver written in Python.
# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
# MySQL Connector/Python is licensed under the terms of the GPLv2
# <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most
# MySQL Connectors. There are special exceptions to ... | [
"json.loads",
"json.dumps",
"uuid.uuid4"
] | [((2142, 2167), 'json.dumps', 'json.dumps', (['self.__dict__'], {}), '(self.__dict__)\n', (2152, 2167), False, 'import json\n'), ((1711, 1728), 'json.loads', 'json.loads', (['value'], {}), '(value)\n', (1721, 1728), False, 'import json\n'), ((2050, 2062), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (2060, 2062), Fals... |
import unittest
import numpy as np
import tensorflow as tf
import twodlearn as tdl
class ConstrainedTest(unittest.TestCase):
def test_positive_variable(self):
with tf.Session().as_default():
test = tdl.constrained.PositiveVariableExp(
initial_value=lambda:
tf.ex... | [
"unittest.main",
"numpy.testing.assert_almost_equal",
"tensorflow.Session",
"tensorflow.truncated_normal_initializer"
] | [((661, 676), 'unittest.main', 'unittest.main', ([], {}), '()\n', (674, 676), False, 'import unittest\n'), ((589, 627), 'numpy.testing.assert_almost_equal', 'np.testing.assert_almost_equal', (['x1', 'x2'], {}), '(x1, x2)\n', (619, 627), True, 'import numpy as np\n'), ((178, 190), 'tensorflow.Session', 'tf.Session', ([]... |
__author__ = 'tom'
from setuptools import setup
# Makes use of the sphinx and sphinx-pypi-upload packages. To build for local development
# use 'python setup.py develop'. To upload a version to pypi use 'python setup.py clean sdist upload'.
# To build docs use 'python setup.py build_sphinx' and to upload docs to pytho... | [
"setuptools.setup"
] | [((503, 1017), 'setuptools.setup', 'setup', ([], {'name': '"""approxeng.picamera"""', 'version': '"""0.1"""', 'description': '"""PiCamera based image processing for PiWars robots using OpenCV"""', 'classifiers': "['Programming Language :: Python :: 2.7']", 'url': '"""https://github.com/ApproxEng/approxeng.picamera/"""'... |
# Copyright 2021 The Kubeflow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicabl... | [
"os.path.exists",
"os.getenv",
"kfp.dsl.pipeline",
"json.load",
"google_cloud_pipeline_components.v1.bigquery.BigqueryQueryJobOp",
"kfp.v2.compiler.Compiler",
"os.remove"
] | [((1465, 1499), 'os.path.exists', 'os.path.exists', (['self._package_path'], {}), '(self._package_path)\n', (1479, 1499), False, 'import os\n'), ((1592, 1630), 'kfp.dsl.pipeline', 'kfp.dsl.pipeline', ([], {'name': '"""bigquery-test"""'}), "(name='bigquery-test')\n", (1608, 1630), False, 'import kfp\n'), ((1326, 1366), ... |
from logging import getLogger
import datetime
from uuid import uuid4
from django.contrib.postgres.fields import JSONField
from django.db import models
from django.utils.timezone import utc
logger = getLogger('django')
class Message(models.Model):
first_name = models.CharField(max_length=300, null=True, blank=Tr... | [
"logging.getLogger",
"datetime.datetime.now",
"django.db.models.CharField",
"django.db.models.DateTimeField"
] | [((201, 220), 'logging.getLogger', 'getLogger', (['"""django"""'], {}), "('django')\n", (210, 220), False, 'from logging import getLogger\n'), ((268, 323), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(300)', 'null': '(True)', 'blank': '(True)'}), '(max_length=300, null=True, blank=True)\n', (... |
from bs4 import BeautifulSoup
from ..webhook_message import WebhookMessage
from ..config import Config
import json
class YoutubeNotification(WebhookMessage):
id: str
channel_name: str
channel_url: str
title: str
video_url: str
def __init__(self, config: Config, channel_name, channel_url, titl... | [
"bs4.BeautifulSoup",
"json.load"
] | [((793, 820), 'bs4.BeautifulSoup', 'BeautifulSoup', (['_xml', '"""lxml"""'], {}), "(_xml, 'lxml')\n", (806, 820), False, 'from bs4 import BeautifulSoup\n'), ((1246, 1258), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1255, 1258), False, 'import json\n')] |
import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)
# %matplotlib inline
import torch
from torch.utils.data import Dataset
# https://www.kaggle.com/pinocookie/pytorch-dataset-and-dataloader
class GamesDataset(Dataset):
def __init__(self, file_path, transf... | [
"pandas.read_csv"
] | [((351, 391), 'pandas.read_csv', 'pd.read_csv', (['file_path'], {'low_memory': '(False)'}), '(file_path, low_memory=False)\n', (362, 391), True, 'import pandas as pd\n')] |
#!/usr/bin/python3.6
"""
.. module:: diskTools
:platform: Windows, linux
:synopsis: module with functions that provide drive and volume information
.. moduleauthor:: <NAME> <<EMAIL>>
"""
import os
import re
import subprocess
def genDrivesInfo():
"""Generator for drives information."""
fields = dic... | [
"subprocess.check_output",
"subprocess.Popen",
"os.path.isdir",
"re.search"
] | [((3454, 3556), 'subprocess.Popen', 'subprocess.Popen', (["['udevadm', 'info', '--query=all', '--name=%s' % device]"], {'stdout': 'subprocess.PIPE'}), "(['udevadm', 'info', '--query=all', '--name=%s' % device],\n stdout=subprocess.PIPE)\n", (3470, 3556), False, 'import subprocess\n'), ((2735, 2763), 'os.path.isdir',... |
#import setuptools
from setuptools import setup, Extension
from distutils.util import convert_path
main_ns = {}
ver_path = convert_path('tormentor/version.py')
with open(ver_path) as ver_file:
exec(ver_file.read(), main_ns)
setup(
name='tormentor',
version=main_ns['__version__'],
packages=['tormentor'... | [
"distutils.util.convert_path"
] | [((124, 160), 'distutils.util.convert_path', 'convert_path', (['"""tormentor/version.py"""'], {}), "('tormentor/version.py')\n", (136, 160), False, 'from distutils.util import convert_path\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Nov 30 23:03:39 2019
@author: xingjiawen
"""
# 爬取人民建议征集网站
# Part I 爬取前一千条的标题、超链接、时间
# Part II 爬取现在到2019/1/1的、标题含垃圾二字的标题、超链接、时间
import requests
from bs4 import BeautifulSoup
import pandas as pd
import time
u21 = 'http://wsxf.sh.gov.cn/xf_rmyjzj/list.a... | [
"bs4.BeautifulSoup",
"requests.get"
] | [((698, 715), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (710, 715), False, 'import requests\n'), ((2085, 2102), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (2097, 2102), False, 'import requests\n'), ((2928, 2943), 'requests.get', 'requests.get', (['u'], {}), '(u)\n', (2940, 2943), False, '... |
from setuptools import setup, find_packages
setup(
name = "wadnr_utilities",
version = "1.0.0",
author = "<NAME>",
author_email = "<EMAIL>",
url = "https://github.com/rjhildre/wadnr_utilities",
description = "Common functions used at Washington DNR",
packages = find_packages(),
classifi... | [
"setuptools.find_packages"
] | [((291, 306), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (304, 306), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/env python3
# Copyright 2018 Johns Hopkins University (author: <NAME>)
# Apache 2.0
""" This module will be used for loading ICDAR 2015 data as a class.
Further functions may be added as and when required.
"""
import os
import numpy as np
from PIL import Image,ImageDraw
from glob import glob
from waldo... | [
"os.path.exists",
"os.listdir",
"PIL.Image.open",
"os.path.isdir",
"glob.glob"
] | [((2444, 2471), 'os.listdir', 'os.listdir', (['self.tr_img_dir'], {}), '(self.tr_img_dir)\n', (2454, 2471), False, 'import os\n'), ((2491, 2518), 'os.listdir', 'os.listdir', (['self.te_img_dir'], {}), '(self.te_img_dir)\n', (2501, 2518), False, 'import os\n'), ((3187, 3211), 'os.path.exists', 'os.path.exists', (['data_... |
# Generated by Django 2.1.3 on 2018-12-15 16:56
import django.core.validators
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
initial = True
dependencies = [
('MCS', '0001_initial'),
]
operations ... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.PositiveIntegerField",
"django.db.models.DateTimeField"
] | [((432, 504), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""訂單編號"""'}), "(primary_key=True, serialize=False, verbose_name='訂單編號')\n", (448, 504), False, 'from django.db import migrations, models\n'), ((539, 587), 'django.db.models.PositiveIn... |
import numpy as np
import wave
import struct
def note( pitch, beat ):
fs = 44000
amplitude = 30000
frequency = np.array( [ 261.6, 293.7, 329.6, 349.2, 392.0, 440.0, 493.9 ] )
num_samples = beat * fs
t = np.linspace( 0, beat, num_samples, endpoint = False )
a = np.linspace( 0, 1, num_samples, endpoint = False )
... | [
"wave.open",
"numpy.size",
"numpy.append",
"numpy.array",
"numpy.linspace",
"numpy.cos"
] | [((115, 174), 'numpy.array', 'np.array', (['[261.6, 293.7, 329.6, 349.2, 392.0, 440.0, 493.9]'], {}), '([261.6, 293.7, 329.6, 349.2, 392.0, 440.0, 493.9])\n', (123, 174), True, 'import numpy as np\n'), ((209, 258), 'numpy.linspace', 'np.linspace', (['(0)', 'beat', 'num_samples'], {'endpoint': '(False)'}), '(0, beat, nu... |
import versup.changelog as changelog
import pytest
try:
from unittest.mock import patch, Mock
except ImportError:
from mock import patch, Mock
import io
import sys
def mocked_get_commit_messages():
return [
{
"hash": "0820a11b306a78c184b183ac0820a11b30f80500",
"author_nam... | [
"mock.patch",
"versup.changelog.show_file",
"mock.Mock",
"os.environ.pop",
"versup.changelog.write",
"pytest.fixture",
"io.StringIO"
] | [((928, 959), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (942, 959), False, 'import pytest\n'), ((2606, 2624), 'mock.patch', 'patch', (['"""os.system"""'], {}), "('os.system')\n", (2611, 2624), False, 'from mock import patch, Mock\n'), ((2843, 2861), 'mock.patch', 'patc... |
'''
A mini Knightmare text adventure game.
--------------------------------------
Knightmare was a popular TV programme in the early to mid 1990s
shown on ITV in UK. This game is a text adventure version
of a mini Knightmare quest. As a text adventure the mechanics
are different from the TV show and it is intended a... | [
"text_adventure.actions.RoomSpecificInventoryItemAction",
"text_adventure.commands.NullCommand",
"text_adventure.actions.BasicInventoryItemAction",
"text_adventure.commands.ChangeLocationDescription",
"text_adventure.actions.ChoiceInventoryItemAction",
"text_adventure.commands.AppendToRoomDescription",
... | [((2497, 2521), 'text_adventure.world.Room', 'Room', ([], {'name': '"""Throne room"""'}), "(name='Throne room')\n", (2501, 2521), False, 'from text_adventure.world import TextWorld, Room, InventoryItem\n'), ((2850, 2870), 'text_adventure.world.Room', 'Room', ([], {'name': '"""puzzle1"""'}), "(name='puzzle1')\n", (2854,... |
import pygame
from core import animation
from utils import vector
from utils.settings import *
class Actor(pygame.sprite.Sprite):
"""The Generic Actor Class"""
def __init__(self):
pygame.sprite.Sprite.__init__(self)
self.actor_type = ACTOR_NONE
self.can_collide = False
self.... | [
"core.animation.Animation",
"pygame.sprite.Sprite.__init__",
"pygame.Rect",
"utils.vector.Vector2d"
] | [((200, 235), 'pygame.sprite.Sprite.__init__', 'pygame.sprite.Sprite.__init__', (['self'], {}), '(self)\n', (229, 235), False, 'import pygame\n'), ((358, 381), 'pygame.Rect', 'pygame.Rect', (['(0)', '(0)', '(0)', '(0)'], {}), '(0, 0, 0, 0)\n', (369, 381), False, 'import pygame\n'), ((553, 574), 'core.animation.Animatio... |
import sys
import queue
import random
import time
import copy
import numpy as np
from multiprocessing import Process,Queue
file_path=sys.argv[1]
termin_time=sys.argv[3]
random_seed=sys.argv[5]
start=time.time()
random.seed(random_seed)
f=open(file_path,encoding='utf-8')
sentimentlist = []
for line in f:
s = line... | [
"numpy.random.rand",
"multiprocessing.Process",
"queue.get",
"random.seed",
"random.random",
"copy.deepcopy",
"queue.PriorityQueue",
"multiprocessing.Queue",
"time.time",
"random.randint",
"numpy.random.shuffle"
] | [((200, 211), 'time.time', 'time.time', ([], {}), '()\n', (209, 211), False, 'import time\n'), ((212, 236), 'random.seed', 'random.seed', (['random_seed'], {}), '(random_seed)\n', (223, 236), False, 'import random\n'), ((58481, 58488), 'multiprocessing.Queue', 'Queue', ([], {}), '()\n', (58486, 58488), False, 'from mul... |
from flask import current_app, g
from gatekeeper.app import app
import json
class DeedApi(object):
"""Encapsulating class for Deed API access."""
def __init__(self):
super(DeedApi, self).__init__()
self.deed_api_url = current_app.config["DEED_API_URL"]
def health(self):
app.logger... | [
"json.dumps",
"gatekeeper.app.app.logger.info"
] | [((310, 347), 'gatekeeper.app.app.logger.info', 'app.logger.info', (['"""Calling get health"""'], {}), "('Calling get health')\n", (325, 347), False, 'from gatekeeper.app import app\n'), ((485, 520), 'gatekeeper.app.app.logger.info', 'app.logger.info', (['"""Calling get deed"""'], {}), "('Calling get deed')\n", (500, 5... |
import pytest
import os
@pytest.mark.skipif(
"TRAVIS" in os.environ and os.environ["TRAVIS"] == "true",
reason="doesn't work with Travis",
)
def test_album_infos(network):
url_album = (
"https://rateyourmusic.com/release/comp/malicorne/legende___deuxieme_epoque/"
)
album_timeline = networ... | [
"pytest.mark.skipif"
] | [((27, 143), 'pytest.mark.skipif', 'pytest.mark.skipif', (["('TRAVIS' in os.environ and os.environ['TRAVIS'] == 'true')"], {'reason': '"""doesn\'t work with Travis"""'}), '(\'TRAVIS\' in os.environ and os.environ[\'TRAVIS\'] ==\n \'true\', reason="doesn\'t work with Travis")\n', (45, 143), False, 'import pytest\n')] |
import numpy as SP
import subprocess, sys, os.path
from itertools import *
from fastlmm.pyplink.snpset import *
import math
class Consecutive(object): # implements ISnpSetList
"""
The sets should be every consecutive set of SNPs within a 2cM window of each user
(distance in cM is in the 3rd column of the... | [
"pandas.read_csv",
"math.floor"
] | [((1171, 1295), 'pandas.read_csv', 'pd.read_csv', (['self.spec.BimFileName'], {'delimiter': '"""\\\\s"""', 'usecols': '(0, 1, 2, 3)', 'header': 'None', 'index_col': '(False)', 'engine': '"""python"""'}), "(self.spec.BimFileName, delimiter='\\\\s', usecols=(0, 1, 2, 3),\n header=None, index_col=False, engine='python'... |
import pandas as pd
import os
from PIL import Image
import numpy as np
from keras.callbacks import ModelCheckpoint, LearningRateScheduler, EarlyStopping, ReduceLROnPlateau, TensorBoard
from keras import optimizers, losses, activations, models
from keras.layers import Convolution2D, Dense, Input, Flatten, Dropout, MaxPo... | [
"pandas.read_csv",
"keras.preprocessing.image.ImageDataGenerator",
"numpy.array",
"keras.layers.Dense",
"numpy.mean",
"numpy.max",
"keras.models.Model",
"keras.callbacks.EarlyStopping",
"keras.backend.clear_session",
"keras.layers.GlobalMaxPooling2D",
"sklearn.model_selection.train_test_split",
... | [((1031, 1156), 'keras.preprocessing.image.ImageDataGenerator', 'ImageDataGenerator', ([], {'rotation_range': '(6)', 'width_shift_range': '(0.1)', 'height_shift_range': '(0.1)', 'horizontal_flip': '(True)', 'zoom_range': '(0.1)'}), '(rotation_range=6, width_shift_range=0.1,\n height_shift_range=0.1, horizontal_flip=... |
from asyncio import Event, get_event_loop
class TaskGroup:
def __init__(self, loop=None):
self._loop = loop or get_event_loop()
self._tasks = set()
self.done = Event()
def add(self, coro):
task = self._loop.create_task(coro)
self._tasks.add(task)
self.done.cle... | [
"asyncio.get_event_loop",
"asyncio.Event"
] | [((191, 198), 'asyncio.Event', 'Event', ([], {}), '()\n', (196, 198), False, 'from asyncio import Event, get_event_loop\n'), ((126, 142), 'asyncio.get_event_loop', 'get_event_loop', ([], {}), '()\n', (140, 142), False, 'from asyncio import Event, get_event_loop\n')] |
# PyPoll HW - <NAME>
# Import required packages
import csv
import os
# Files to load and output
file_to_load = os.path.join(r"PyPoll\Resources\election_data.csv")
file_to_output = os.path.join(r"PyPoll\Analysis\election_data.txt")
# Placeholders for Variables
total_votes = 0
interim = 0
Khan = 0
Correy = 0
Li= 0
OTo... | [
"os.path.join",
"csv.reader"
] | [((113, 165), 'os.path.join', 'os.path.join', (['"""PyPoll\\\\Resources\\\\election_data.csv"""'], {}), "('PyPoll\\\\Resources\\\\election_data.csv')\n", (125, 165), False, 'import os\n'), ((182, 233), 'os.path.join', 'os.path.join', (['"""PyPoll\\\\Analysis\\\\election_data.txt"""'], {}), "('PyPoll\\\\Analysis\\\\elec... |
import zipfile
import tkinter
from tkinter import filedialog
import tkinter.messagebox
from pathlib import Path
def un_zip(file_name):
i = 0
try:
path_use = file_choose_1.get()
with zipfile.ZipFile(path_use, "r") as f:
for fn in f.namelist():
i += 1
... | [
"tkinter.messagebox.showwarning",
"tkinter.Entry",
"zipfile.ZipFile",
"tkinter.Button",
"tkinter.StringVar",
"tkinter.Tk",
"tkinter.filedialog.askopenfilename"
] | [((836, 898), 'tkinter.filedialog.askopenfilename', 'filedialog.askopenfilename', ([], {'filetypes': "[('zip files', '*.zip')]"}), "(filetypes=[('zip files', '*.zip')])\n", (862, 898), False, 'from tkinter import filedialog\n'), ((978, 990), 'tkinter.Tk', 'tkinter.Tk', ([], {}), '()\n', (988, 990), False, 'import tkint... |
#!/usr/bin/env python
#
# Copyright 2013 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# ... | [
"gnuradio.gr.top_block",
"gnuradio.blocks.vector_sink_f",
"gnuradio.blocks.threshold_ff",
"gnuradio.gr_unittest.run",
"gnuradio.blocks.vector_source_f"
] | [((1483, 1536), 'gnuradio.gr_unittest.run', 'gr_unittest.run', (['test_threshold', '"""test_threshold.xml"""'], {}), "(test_threshold, 'test_threshold.xml')\n", (1498, 1536), False, 'from gnuradio import gr, gr_unittest, blocks\n'), ((935, 949), 'gnuradio.gr.top_block', 'gr.top_block', ([], {}), '()\n', (947, 949), Fal... |
import math
from algorithms.maths import (
find_order,
euler_totient
)
"""
For positive integer n and given integer a that satisfies gcd(a, n) = 1,
a is the primitive root of n, if a's order k for n satisfies k = ϕ(n).
Primitive roots of certain number may or may not be exist.
If so, return empty list.
"""
def... | [
"math.gcd",
"algorithms.maths.find_order",
"algorithms.maths.euler_totient"
] | [((492, 508), 'algorithms.maths.euler_totient', 'euler_totient', (['n'], {}), '(n)\n', (505, 508), False, 'from algorithms.maths import find_order, euler_totient\n'), ((640, 654), 'math.gcd', 'math.gcd', (['i', 'n'], {}), '(i, n)\n', (648, 654), False, 'import math\n'), ((840, 856), 'algorithms.maths.find_order', 'find... |
from commands import CommandManager
class Terminal(object):
def __init__(self):
self.cmd_manager = CommandManager()
def welcome(self):
print('welcome to pysc! soundcloud in your terminal ~ powered by soundcloud')
print('type \'genres\' to discover, or just \'help\' to see available commands')
def loop(self)... | [
"commands.CommandManager"
] | [((103, 119), 'commands.CommandManager', 'CommandManager', ([], {}), '()\n', (117, 119), False, 'from commands import CommandManager\n')] |
from exams.models import Exam
from exams.serializers import ExamSerializer
from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from courses.models import Course
class ExamView(APIView):
def get(self, request, *args, **kwargs):
exams = Ex... | [
"rest_framework.response.Response",
"exams.models.Exam.objects.all",
"exams.serializers.ExamSerializer"
] | [((318, 336), 'exams.models.Exam.objects.all', 'Exam.objects.all', ([], {}), '()\n', (334, 336), False, 'from exams.models import Exam\n'), ((358, 390), 'exams.serializers.ExamSerializer', 'ExamSerializer', (['exams'], {'many': '(True)'}), '(exams, many=True)\n', (372, 390), False, 'from exams.serializers import ExamSe... |
import random
import pandas as pd
shots = 90
ot_shots = 10
##########
# Team 1 #
##########
team1 = {
'2pt rate': .80,
'3pt rate': .20,
'2pt%': .50,
'3pt%': .33333,
'orbd': .225,
'foul3': .015,
'foul2': .057,
'ft%': .77
}
##########
# Team 2 #
##########
team2 = {
'2pt rate': .50... | [
"pandas.DataFrame",
"random.random"
] | [((2148, 2169), 'pandas.DataFrame', 'pd.DataFrame', (['results'], {}), '(results)\n', (2160, 2169), True, 'import pandas as pd\n'), ((708, 723), 'random.random', 'random.random', ([], {}), '()\n', (721, 723), False, 'import random\n'), ((740, 755), 'random.random', 'random.random', ([], {}), '()\n', (753, 755), False, ... |
"""
What is denoising?
Noise is modeled as samples from a certain distribution, it can be referred
with the name of distribution it follows, for example, a Gaussian noise.
Mode (noise_type and noise_params):
- "gaussian", [standard deviation of the distribution]: Gaussian noise
- "poisson", [peak value]: Poisson nois... | [
"nnimgproc.util.parameters.Parameters",
"numpy.copy",
"numpy.random.poisson",
"numpy.random.normal"
] | [((784, 796), 'nnimgproc.util.parameters.Parameters', 'Parameters', ([], {}), '()\n', (794, 796), False, 'from nnimgproc.util.parameters import Parameters\n'), ((1087, 1099), 'numpy.copy', 'np.copy', (['img'], {}), '(img)\n', (1094, 1099), True, 'import numpy as np\n'), ((1348, 1377), 'numpy.random.poisson', 'np.random... |
from requests import get
from bs4 import BeautifulSoup
import webbrowser as browser
import paho.mqtt.client as mqtt
import platform
from gtts import gTTS # Biblioteca principal de transformação de textos em audios
from subprocess import call # biblioteca para executar o audio no MAC e LINUX
from playsound import play... | [
"paho.mqtt.client.Client",
"playsound.playsound",
"webbrowser.open",
"requests.get",
"bs4.BeautifulSoup",
"platform.system",
"gtts.gTTS",
"subprocess.call"
] | [((532, 572), 'gtts.gTTS', 'gTTS', (['mensagem'], {'lang': '"""pt-br"""', 'slow': '(False)'}), "(mensagem, lang='pt-br', slow=False)\n", (536, 572), False, 'from gtts import gTTS\n'), ((995, 1059), 'requests.get', 'get', (['"""https://news.google.com/rss?hl=pt-BR&gl=BR&ceid=BR:pt-419"""'], {}), "('https://news.google.c... |
from nltk.tag import pos_tag
import numpy as np
import pandas as pd
from transformers import TFGPT2LMHeadModel, GPT2Tokenizer
from string import punctuation
from os import path, listdir
import pickle
import copy
from helper_functions import get_embeddings
from nltk import word_tokenize
#Model
MODEL_ID_GPT2... | [
"transformers.GPT2Tokenizer.from_pretrained",
"os.listdir",
"pickle.dump",
"helper_functions.get_embeddings",
"pandas.read_csv",
"nltk.word_tokenize",
"os.path.join",
"pickle.load",
"numpy.squeeze",
"numpy.array",
"copy.deepcopy",
"transformers.TFGPT2LMHeadModel.from_pretrained"
] | [((344, 448), 'transformers.TFGPT2LMHeadModel.from_pretrained', 'TFGPT2LMHeadModel.from_pretrained', (['MODEL_ID_GPT2'], {'output_hidden_states': '(True)', 'output_attentions': '(False)'}), '(MODEL_ID_GPT2, output_hidden_states=True,\n output_attentions=False)\n', (377, 448), False, 'from transformers import TFGPT2L... |
# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"). You
# may not use this file except in compliance with the License. A copy of
# the License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file acc... | [
"logging.getLogger",
"argparse.ArgumentParser",
"numpy.arange",
"sklearn.model_selection.train_test_split",
"tensorflow.contrib.saved_model.save_keras_model",
"tensorflow.logging.set_verbosity",
"os.environ.get",
"tensorflow.keras.optimizers.Adam",
"numpy.zeros",
"tensorflow.keras.callbacks.ModelC... | [((873, 915), 'tensorflow.logging.set_verbosity', 'tf.logging.set_verbosity', (['tf.logging.ERROR'], {}), '(tf.logging.ERROR)\n', (897, 915), True, 'import tensorflow as tf\n'), ((1006, 1043), 'os.system', 'os.system', (['"""mkdir /opt/ml/model/code"""'], {}), "('mkdir /opt/ml/model/code')\n", (1015, 1043), False, 'imp... |
"""Test honeywell setup process."""
from unittest.mock import create_autospec, patch
import somecomfort
from homeassistant.config_entries import ConfigEntryState
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry
@patch("homeassistant.components.honeywell.UPDATE_LOOP_SLEEP_TIME"... | [
"unittest.mock.patch",
"unittest.mock.create_autospec"
] | [((255, 324), 'unittest.mock.patch', 'patch', (['"""homeassistant.components.honeywell.UPDATE_LOOP_SLEEP_TIME"""', '(0)'], {}), "('homeassistant.components.honeywell.UPDATE_LOOP_SLEEP_TIME', 0)\n", (260, 324), False, 'from unittest.mock import create_autospec, patch\n'), ((696, 765), 'unittest.mock.patch', 'patch', (['... |
import os
import gzip
import logging
import tempfile
from pathlib import Path
import h5py
import numpy
import sunpy.map
from astropy import units as u
from astropy.io import fits
from astropy.time import Time
from sunpy.util.exceptions import warn_user
from sunkit_instruments.suvi._variables import (
COMPOSITE_M... | [
"astropy.io.fits.getheader",
"logging.debug",
"sunpy.util.exceptions.warn_user",
"pathlib.Path",
"gzip.open",
"numpy.longlong",
"numpy.float64",
"h5py.File",
"astropy.time.Time",
"tempfile.gettempdir",
"os.path.basename",
"astropy.io.fits.open",
"astropy.io.fits.Header.fromstring",
"sunkit... | [((7669, 7714), 'astropy.io.fits.Header.fromstring', 'fits.Header.fromstring', (['hdr_str_new'], {'sep': '"""\n"""'}), "(hdr_str_new, sep='\\n')\n", (7691, 7714), False, 'from astropy.io import fits\n'), ((1689, 1713), 'astropy.io.fits.getheader', 'fits.getheader', (['filename'], {}), '(filename)\n', (1703, 1713), Fals... |
from aide_design.shared.units import unit_registry as u
from datetime import datetime, timedelta
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import os
from pathlib import Path
def ftime(data_file_path, start, end=-1):
"""This function extracts the column of times from a ProCoDA data fil... | [
"numpy.insert",
"pandas.read_csv",
"numpy.average",
"datetime.datetime.strptime",
"numpy.size",
"matplotlib.pyplot.plot",
"os.path.join",
"os.path.split",
"numpy.append",
"numpy.array",
"matplotlib.pyplot.figure",
"pandas.to_numeric",
"numpy.vstack",
"aide_design.shared.units.unit_registry... | [((1033, 1076), 'pandas.read_csv', 'pd.read_csv', (['data_file_path'], {'delimiter': '"""\t"""'}), "(data_file_path, delimiter='\\t')\n", (1044, 1076), True, 'import pandas as pd\n'), ((1149, 1185), 'pandas.to_numeric', 'pd.to_numeric', (['df.iloc[start:end, 0]'], {}), '(df.iloc[start:end, 0])\n', (1162, 1185), True, '... |
# -*- coding: utf-8 -*-
# python 2 support via python-future
from __future__ import absolute_import, division, print_function, unicode_literals
from builtins import bytes, dict, int, str
import atexit
import collections
import distutils.spawn
import importlib
import logging
import re
import shlex
import subprocess
im... | [
"logging.getLogger",
"collections.OrderedDict",
"importlib.import_module",
"re.compile",
"subprocess.check_call",
"atexit.register",
"shlex.split",
"builtins.int",
"builtins.str",
"uuid.uuid4",
"builtins.dict",
"subprocess.call",
"luigi.contrib.s3.S3Target",
"luigi.LocalTarget",
"sys.pat... | [((445, 481), 'logging.getLogger', 'logging.getLogger', (['"""luigi-interface"""'], {}), "('luigi-interface')\n", (462, 481), False, 'import logging\n'), ((1545, 1553), 'builtins.str', 'str', (['obj'], {}), '(obj)\n', (1548, 1553), False, 'from builtins import bytes, dict, int, str\n'), ((1682, 1699), 'luigi.Parameter'... |
import os
import json
import re
from nltk import word_tokenize
from nltk.translate.bleu_score import corpus_bleu
from tqdm import tqdm
from rouge import Rouge
from sumy.parsers.plaintext import PlaintextParser
from sumy.nlp.tokenizers import Tokenizer
from sumy.summarizers.text_rank import TextRankSummarizer
from sumy.... | [
"nltk.translate.bleu_score.corpus_bleu",
"os.listdir",
"sumy.nlp.tokenizers.Tokenizer",
"nltk.word_tokenize",
"re.compile",
"rouge.Rouge",
"tqdm.tqdm",
"os.path.join",
"sumy.nlp.stemmers.Stemmer",
"json.load",
"sumy.utils.get_stop_words",
"sumy.summarizers.text_rank.TextRankSummarizer",
"os.... | [((610, 628), 're.compile', 're.compile', (['url_re'], {}), '(url_re)\n', (620, 628), False, 'import re\n'), ((643, 670), 're.sub', 're.sub', (['regex', '""" """', 'content'], {}), "(regex, ' ', content)\n", (649, 670), False, 'import re\n'), ((683, 701), 're.compile', 're.compile', (['www_re'], {}), '(www_re)\n', (693... |
from flask import render_template, url_for, flash, redirect
from package import app,db
from package.forms import RegistrationForm, LoginForm
from package.models import User
from flask_login import login_user
import pymongo
from pymongo import MongoClient
# Mongo Initialisation
cluster = MongoClient("mongodb+srv://adm... | [
"flask.render_template",
"package.forms.RegistrationForm",
"flask.flash",
"flask_login.login_user",
"flask.url_for",
"pymongo.MongoClient",
"package.forms.LoginForm",
"package.app.route",
"package.models.User.query.filter_by"
] | [((290, 400), 'pymongo.MongoClient', 'MongoClient', (['"""mongodb+srv://admin:admin@cluster1-p71lz.mongodb.net/test?retryWrites=true&w=majority"""'], {}), "(\n 'mongodb+srv://admin:admin@cluster1-p71lz.mongodb.net/test?retryWrites=true&w=majority'\n )\n", (301, 400), False, 'from pymongo import MongoClient\n'), (... |
from __future__ import annotations
from typing import List, Tuple, Union
import numpy as np
# now just for the 2x2 mat or 1x2 vec
class Matrix():
def __init__(self,
arr: Union[List[float], np.ndarray],
data_type: str = 'mat',
row: int = 2,
col: ... | [
"numpy.isclose",
"numpy.linalg.det",
"numpy.square",
"numpy.array",
"numpy.dot",
"numpy.linalg.inv",
"numpy.arctan2",
"numpy.cos",
"numpy.sin"
] | [((5993, 6017), 'numpy.linalg.det', 'np.linalg.det', (['self._val'], {}), '(self._val)\n', (6006, 6017), True, 'import numpy as np\n'), ((6200, 6224), 'numpy.linalg.inv', 'np.linalg.inv', (['self._val'], {}), '(self._val)\n', (6213, 6224), True, 'import numpy as np\n'), ((6809, 6853), 'numpy.arctan2', 'np.arctan2', (['... |
import urllib.request
import json
import random
from Levenshtein import distance
categoriesPerPage = 20
def areSimilar(s1, s2):
dist = distance(str(s1).lower(), str(s2).lower())
return dist < (len(s1) * 0.4) # Can be 40% wrong
# Gets a random question
def getQuestion(difficulty=0, category=0):
urlPat... | [
"random.choice"
] | [((521, 540), 'random.choice', 'random.choice', (['data'], {}), '(data)\n', (534, 540), False, 'import random\n')] |
# -*- coding: utf-8 -*-
'''
Used to scan the given directories for loadable files
'''
# Import python libs
import os
import imp
import collections
PY_END = ('.py', '.pyc', '.pyo')
PYEXT_END = tuple([suffix[0] for suffix in imp.get_suffixes() if suffix[-1] == imp.C_EXTENSION])
CYTHON_END = ('.pyx',)
SKIP_DIRNAMES = ('_... | [
"collections.OrderedDict",
"os.listdir",
"imp.get_suffixes",
"os.path.join",
"os.path.basename"
] | [((416, 441), 'collections.OrderedDict', 'collections.OrderedDict', ([], {}), '()\n', (439, 441), False, 'import collections\n'), ((462, 487), 'collections.OrderedDict', 'collections.OrderedDict', ([], {}), '()\n', (485, 487), False, 'import collections\n'), ((508, 533), 'collections.OrderedDict', 'collections.OrderedD... |
""" Copyright (c) 2021 Cisco and/or its affiliates.
This software is licensed to you under the terms of the Cisco Sample
Code License, Version 1.1 (the "License"). You may obtain a copy of the
License at
https://developer.cisco.com/docs/licenses
All use of the material herein must be in accordance with the t... | [
"logging.basicConfig",
"datetime.datetime.fromtimestamp",
"paho.mqtt.client.Client",
"subprocess.Popen",
"time.sleep",
"time.time",
"logging.info"
] | [((907, 1073), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG', 'format': '"""%(asctime)s.%(msecs)03d %(levelname)s %(module)s - %(funcName)s: %(message)s"""', 'datefmt': '"""%Y-%m-%d %H:%M:%S"""'}), "(level=logging.DEBUG, format=\n '%(asctime)s.%(msecs)03d %(levelname)s %(module)s - %(f... |
#!/usr/bin/env python
import rospy
from std_msgs.msg import String
from std_msgs.msg import Twist
def talker() :
pub = rospy.Pulisher('/upstream_data', Twist, queue_size=10)
rospy.init_node('upstream_pub', anonymous=True)
rate = rospy.Rate(10)
while not rospy.is_shutdown() :
mes = {
... | [
"rospy.is_shutdown",
"rospy.init_node",
"rospy.Pulisher",
"rospy.Rate",
"rospy.loginfo"
] | [((124, 178), 'rospy.Pulisher', 'rospy.Pulisher', (['"""/upstream_data"""', 'Twist'], {'queue_size': '(10)'}), "('/upstream_data', Twist, queue_size=10)\n", (138, 178), False, 'import rospy\n'), ((183, 230), 'rospy.init_node', 'rospy.init_node', (['"""upstream_pub"""'], {'anonymous': '(True)'}), "('upstream_pub', anony... |
import os
from dragoneye.cloud_scanner.base_cloud_scanner import CloudScanSettings, CloudProvider
class GcpCloudScanSettings(CloudScanSettings):
def __init__(self,
commands_path: str,
account_name: str,
project_id: str,
output_path: str = os.get... | [
"os.getcwd"
] | [((314, 325), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (323, 325), False, 'import os\n')] |
#!/usr/bin/env python3
# encoding: utf-8
import numpy as np
import tensorflow as tf
import tensorflow_probability as tfp
from rls.nn.noise import ClippedNormalNoisedAction
from rls.algos.base.off_policy import Off_Policy
from rls.utils.tf2_utils import update_target_net_weights
from rls.utils.build_networks... | [
"tensorflow.one_hot",
"tensorflow.device",
"tensorflow.maximum",
"rls.nn.noise.ClippedNormalNoisedAction",
"tensorflow.nn.log_softmax",
"tensorflow.GradientTape",
"tensorflow.argmax",
"tensorflow.stop_gradient",
"rls.utils.tf2_utils.update_target_net_weights",
"tensorflow.nn.softmax",
"tensorflo... | [((3124, 3198), 'rls.utils.tf2_utils.update_target_net_weights', 'update_target_net_weights', (['self.ac_target_net.weights', 'self.ac_net.weights'], {}), '(self.ac_target_net.weights, self.ac_net.weights)\n', (3149, 3198), False, 'from rls.utils.tf2_utils import update_target_net_weights\n'), ((4651, 4742), 'rls.utils... |
# -*- coding: utf-8 -*-
# OPTIMIZE: using caching improves speed significantly at the cost of memory. I
# need to see which is preferable in higher-level tests.
from functools import cached_property
import numpy
from numba import njit as numba_speedup
class Lattice:
"""
This class is for 3D crystal lattices... | [
"numpy.arccos",
"numba.njit",
"numpy.array",
"numpy.dot",
"numpy.sum",
"numpy.degrees"
] | [((1774, 1799), 'numba.njit', 'numba_speedup', ([], {'cache': '(True)'}), '(cache=True)\n', (1787, 1799), True, 'from numba import njit as numba_speedup\n'), ((3248, 3273), 'numba.njit', 'numba_speedup', ([], {'cache': '(True)'}), '(cache=True)\n', (3261, 3273), True, 'from numba import njit as numba_speedup\n'), ((112... |
import sqlite3
from tqdm import tqdm
import numpy as np
import array
import sys
import math
import os
import multiprocessing
import shutil
import pandas as pd
from scipy.signal import savgol_filter
class Reload:
def __init__(self, path_pri, path_tra, fold):
self.path_pri = path_pri
self.path_tra =... | [
"os.path.exists",
"os.listdir",
"sys.exit",
"sqlite3.connect",
"pandas.read_csv",
"numpy.where",
"tqdm.tqdm",
"math.sqrt",
"scipy.signal.savgol_filter",
"shutil.rmtree",
"numpy.argsort",
"numpy.array",
"os.chdir",
"multiprocessing.Pool",
"numpy.concatenate",
"os.mkdir",
"pandas.DataF... | [((10978, 11006), 'math.sqrt', 'math.sqrt', (['(energy / duration)'], {}), '(energy / duration)\n', (10987, 11006), False, 'import math\n'), ((11953, 12030), 'pandas.DataFrame', 'pd.DataFrame', (["{'time_pop1': Time[cls_KKM[0]], 'energy_pop1': Eny[cls_KKM[0]]}"], {}), "({'time_pop1': Time[cls_KKM[0]], 'energy_pop1': En... |
# Copyright (c) 2021. <NAME>
# Copyright (c) 2021. University of Edinburgh
# 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
... | [
"DataObjects.ClassMultiDict.MultiDict",
"Parser.ProtoCCLexer.tokenNamesMap.values",
"collections.OrderedDict",
"Algorithms.General.AuxStateHandler.AuxStateHandler.cond_rename_operation"
] | [((2468, 2481), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (2479, 2481), False, 'from collections import OrderedDict\n'), ((7138, 7149), 'DataObjects.ClassMultiDict.MultiDict', 'MultiDict', ([], {}), '()\n', (7147, 7149), False, 'from DataObjects.ClassMultiDict import MultiDict\n'), ((3881, 3985), 'Alg... |
#!/usr/bin/python3
# Computes all primes up to a max value. Uses division.
# FROM https://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# NOTE: NOT WORKING! Getting the following error..
#
# ValueError: attempt to ... | [
"datetime.datetime.now",
"os.path.basename",
"sys.exit"
] | [((1008, 1022), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1020, 1022), False, 'from datetime import datetime\n'), ((1488, 1502), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (1500, 1502), False, 'from datetime import datetime\n'), ((1677, 1691), 'datetime.datetime.now', 'datetime.now', (... |
from code.models import Mark
from django.utils.html import strip_tags
from django import template
from django.utils.translation import ugettext as _
class Syntaxhighlighter():
def __init__(self, code):
self.code = code
#noescape_brushs = ['js','jscript','javascript','php','xml','xhtml','xslt',... | [
"django.utils.translation.ugettext",
"code.models.Mark.objects.filter",
"django.template.defaultfilters.force_escape",
"django.utils.html.strip_tags"
] | [((434, 486), 'django.template.defaultfilters.force_escape', 'template.defaultfilters.force_escape', (['self.code.code'], {}), '(self.code.code)\n', (470, 486), False, 'from django import template\n'), ((2756, 2773), 'django.utils.translation.ugettext', '_', (['"""Code details"""'], {}), "('Code details')\n", (2757, 27... |
#!/usr/bin/env python3
# coding: utf-8
#libraries
import keras
import tensorflow as tf
from keras import backend as K
import cv2
import os
import numpy as np
from keras.optimizers import Adam
from keras.models import model_from_json, load_model
from keras.layers import Input, Dense
from keras.models import Model,Seque... | [
"keras.backend.shape",
"keras.backend.sum",
"keras.callbacks.TerminateOnNaN",
"keras.backend.flatten",
"keras.layers.Activation",
"keras.layers.Dense",
"numpy.reshape",
"keras.backend.square",
"numpy.random.seed",
"keras.models.Model",
"keras.callbacks.EarlyStopping",
"keras.backend.exp",
"g... | [((818, 850), 'keras.callbacks.TerminateOnNaN', 'keras.callbacks.TerminateOnNaN', ([], {}), '()\n', (848, 850), False, 'import keras\n'), ((860, 880), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (874, 880), True, 'import numpy as np\n'), ((1916, 1985), 'keras.callbacks.CSVLogger', 'CSVLogger', ([... |
import sys
from direct.showbase.ShowBase import ShowBase
from direct.directnotify import DirectNotifyGlobal
from panda3d.core import UniqueIdAllocator
from src.util.LogManager import LogManager
from src.dclass.DCManager import DCManager
from src.core.ConnectionManager import ConnectionManager
from src.message.MessageM... | [
"src.interest.InterestManager.InterestManager",
"src.distributed.DistributedObjectManager.DistributedObjectManager",
"src.dclass.DCManager.DCManager",
"src.core.ConnectionManager.ConnectionManager",
"panda3d.core.UniqueIdAllocator",
"src.message.MessageManager.MessageManager",
"src.util.LogManager.LogMa... | [((527, 584), 'direct.directnotify.DirectNotifyGlobal.directNotify.newCategory', 'DirectNotifyGlobal.directNotify.newCategory', (['"""ServerBase"""'], {}), "('ServerBase')\n", (570, 584), False, 'from direct.directnotify import DirectNotifyGlobal\n'), ((654, 677), 'direct.showbase.ShowBase.ShowBase.__init__', 'ShowBase... |
import os
from torch.utils.tensorboard import SummaryWriter
def get_summary_writer(cfg):
if not cfg['output']['use_tensorboard']:
return None
else:
log_dir = os.path.join(cfg['output']['log_dir'], cfg['experiment_id'])
return SummaryWriter(log_dir=log_dir)
| [
"torch.utils.tensorboard.SummaryWriter",
"os.path.join"
] | [((184, 244), 'os.path.join', 'os.path.join', (["cfg['output']['log_dir']", "cfg['experiment_id']"], {}), "(cfg['output']['log_dir'], cfg['experiment_id'])\n", (196, 244), False, 'import os\n'), ((260, 290), 'torch.utils.tensorboard.SummaryWriter', 'SummaryWriter', ([], {'log_dir': 'log_dir'}), '(log_dir=log_dir)\n', (... |
#! /usr/bin/env python
from __future__ import absolute_import
from pybedtools import BedTool
import argparse
import numpy as np
parser = argparse.ArgumentParser(
description="""
Given two or mote bed files, ``multiBedSumary.py`` computes the sum of overlapping intervals in every genomic region. The default outpu... | [
"pybedtools.BedTool",
"numpy.array",
"argparse.ArgumentParser"
] | [((139, 531), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""\n\nGiven two or mote bed files, ``multiBedSumary.py`` computes the sum of overlapping intervals in every genomic region. The default output of ``multiBedSumary.py`` (a compressed numpy array, .npz) can be used from various too... |