code stringlengths 20 1.04M | apis list | extract_api stringlengths 75 9.94M |
|---|---|---|
import numpy as np
from converters import hsllist2rl, hsl2rl
def contrast_between(a, b):
rl_a = hsl2rl(a)
rl_b = hsl2rl(b)
rl_max = max(rl_a, rl_b)
rl_min = min(rl_a, rl_b)
return (rl_max + 0.05) / (rl_min + 0.05)
def contrast_between_all(a, b):
rl_a = hsllist2rl(a)
rl_b = hsl2rl(b)
... | [
"converters.hsl2rl",
"numpy.minimum",
"numpy.maximum",
"numpy.abs",
"converters.hsllist2rl",
"numpy.prod",
"numpy.max",
"numpy.array",
"numpy.ascontiguousarray",
"numpy.delete",
"numpy.vstack"
] | [((103, 112), 'converters.hsl2rl', 'hsl2rl', (['a'], {}), '(a)\n', (109, 112), False, 'from converters import hsllist2rl, hsl2rl\n'), ((124, 133), 'converters.hsl2rl', 'hsl2rl', (['b'], {}), '(b)\n', (130, 133), False, 'from converters import hsllist2rl, hsl2rl\n'), ((281, 294), 'converters.hsllist2rl', 'hsllist2rl', (... |
import numpy as np
import cv2
def get_true_random_number():
np.random.seed(np.random.randint(1000000))
return np.random.randint(10000000)
enc_img = cv2.imread("enc.png")
IMG_W = enc_img.shape[1]
IMG_H = enc_img.shape[0]
dec_img = np.zeros(enc_img.shape, dtype="uint8")
np.random.seed(IMG_W * IMG... | [
"numpy.random.seed",
"cv2.imwrite",
"numpy.zeros",
"cv2.imread",
"numpy.random.randint",
"numpy.arange",
"numpy.random.shuffle"
] | [((165, 186), 'cv2.imread', 'cv2.imread', (['"""enc.png"""'], {}), "('enc.png')\n", (175, 186), False, 'import cv2\n'), ((254, 292), 'numpy.zeros', 'np.zeros', (['enc_img.shape'], {'dtype': '"""uint8"""'}), "(enc_img.shape, dtype='uint8')\n", (262, 292), True, 'import numpy as np\n'), ((294, 329), 'numpy.random.seed', ... |
"""
The architecture of the discriminator and predictor utilized in the adversarial training
"""
import numpy as np
import tensorflow as tf
import warp
# build geometric predictor
def geometric_multires(opt,imageBG,imageFG,p):
def downsample(x):
padH,padW = int(x.shape[1])%2,int(x.shape[2])%2
if padH!=0 or padW!... | [
"tensorflow.nn.relu",
"tensorflow.abs",
"tensorflow.constant_initializer",
"warp.transformImage",
"tensorflow.pad",
"tensorflow.concat",
"tensorflow.variable_scope",
"tensorflow.reshape",
"tensorflow.matmul",
"tensorflow.nn.avg_pool",
"tensorflow.random_normal_initializer",
"tensorflow.nn.conv... | [((379, 433), 'tensorflow.nn.avg_pool', 'tf.nn.avg_pool', (['x', '[1, 2, 2, 1]', '[1, 2, 2, 1]', '"""VALID"""'], {}), "(x, [1, 2, 2, 1], [1, 2, 2, 1], 'VALID')\n", (393, 433), True, 'import tensorflow as tf\n'), ((651, 667), 'tensorflow.nn.relu', 'tf.nn.relu', (['conv'], {}), '(conv)\n', (661, 667), True, 'import tenso... |
import json
import time
import requests
class ExportError(Exception):
""" An error occurred during export """
class DidNotCompleteError(ExportError):
""" Raised if a job did not complete successfully """
class PeopleAIClient:
AUTH_PATH = '/auth/v1/tokens'
EXPORT_ACTIVITIES_PATH = '/pull/v1/export... | [
"requests.post",
"requests.request",
"time.sleep"
] | [((1895, 1980), 'requests.request', 'requests.request', (['method', '(self.api_endpoint + path)'], {'json': 'params', 'headers': 'headers'}), '(method, self.api_endpoint + path, json=params, headers=headers\n )\n', (1911, 1980), False, 'import requests\n'), ((5297, 5314), 'time.sleep', 'time.sleep', (['delay'], {}),... |
#!/usr/bin/env python
# coding: utf-8
# # American Put Option Pricing Model
#
# **<NAME>, PhD**
#
# This demo is based on the original Matlab demo accompanying the <a href="https://mitpress.mit.edu/books/applied-computational-economics-and-finance">Computational Economics and Finance</a> 2001 textbook by <NAME> and... | [
"numpy.empty",
"compecon.BasisSpline",
"numpy.zeros",
"numpy.exp",
"compecon.demo.figure",
"compecon.qnwnorm"
] | [((3208, 3234), 'compecon.qnwnorm', 'qnwnorm', (['m', 'mu', '(sigma ** 2)'], {}), '(m, mu, sigma ** 2)\n', (3215, 3234), False, 'from compecon import BasisSpline, NLP, qnwnorm, demo\n'), ((3440, 3455), 'numpy.empty', 'np.empty', (['(T + 1)'], {}), '(T + 1)\n', (3448, 3455), True, 'import numpy as np\n'), ((4336, 4396),... |
import pandas as pd
from sportsipy.nba.teams import Teams as NbaTeams
from sportsipy.nba.teams import Schedule as NbaSchedule
from sportsipy.nfl.teams import Teams as NflTeams
from sportsipy.nfl.teams import Schedule as NflSchedule
from . import ratingbase
# Todo: check neutral coding
loc_map = {'Home': 'H', 'Away': ... | [
"pandas.DataFrame",
"pandas.concat"
] | [((743, 790), 'pandas.DataFrame', 'pd.DataFrame', (['team_data'], {'columns': "['id', 'name']"}), "(team_data, columns=['id', 'name'])\n", (755, 790), True, 'import pandas as pd\n'), ((932, 972), 'pandas.concat', 'pd.concat', (['team_games'], {'ignore_index': '(True)'}), '(team_games, ignore_index=True)\n', (941, 972),... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('flatpages', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='I18NFlatPage',
fields=[
... | [
"django.db.models.CharField",
"django.db.models.OneToOneField"
] | [((353, 474), 'django.db.models.OneToOneField', 'models.OneToOneField', ([], {'parent_link': '(True)', 'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'to': '"""flatpages.FlatPage"""'}), "(parent_link=True, auto_created=True, primary_key=True,\n serialize=False, to='flatpages.FlatPage')\n"... |
"""
Allocate data from generation_fuel_eia923 table to generator level.
Net electricity generation and fuel consumption are reported in mutiple ways
in the EIA 923. The generation_fuel_eia923 table reports both generation and
fuel consumption, and breaks them down by plant, prime mover, and fuel. In
parallel, the gene... | [
"pandas.merge",
"numpy.isclose",
"numpy.where",
"warnings.warn",
"pandas.concat",
"logging.getLogger"
] | [((5073, 5100), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (5090, 5100), False, 'import logging\n'), ((16180, 16211), 'pandas.concat', 'pd.concat', (['[existing, retiring]'], {}), '([existing, retiring])\n', (16189, 16211), True, 'import pandas as pd\n'), ((19856, 19932), 'pandas.merg... |
#!/usr/bin/python
# Copyright (c) 2013 The Native Client Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""%prog [option...] superinsructions1.txt superinsructions2.txt...
Regex-based verifier for superinstructions list."""
import op... | [
"tempfile.NamedTemporaryFile",
"subprocess.Popen",
"os.remove",
"optparse.OptionParser",
"objdump_parser.ParseLine",
"objdump_parser.SkipHeader",
"objdump_parser.CanonicalizeInstruction",
"validator.Validator"
] | [((5744, 5774), 'optparse.OptionParser', 'optparse.OptionParser', (['__doc__'], {}), '(__doc__)\n', (5765, 5774), False, 'import optparse\n'), ((6677, 6733), 'validator.Validator', 'validator.Validator', ([], {'validator_dll': 'options.validator_dll'}), '(validator_dll=options.validator_dll)\n', (6696, 6733), False, 'i... |
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use ... | [
"libcloud.utils.networking.is_private_subnet",
"libcloud.compute.base.KeyPair",
"json.dumps",
"libcloud.compute.base.Node",
"libcloud.compute.base.NodeImage"
] | [((7292, 7338), 'json.dumps', 'json.dumps', (["{'virtual_machine': server_params}"], {}), "({'virtual_machine': server_params})\n", (7302, 7338), False, 'import json\n'), ((10484, 10517), 'json.dumps', 'json.dumps', (["{'key': key_material}"], {}), "({'key': key_material})\n", (10494, 10517), False, 'import json\n'), (... |
#!/usr/bin/env python3
import json
from random import choice, seed
from bip32utils import BIP32Key
from mnemonic import Mnemonic
def process(data, lst):
code = mnemo.to_mnemonic(bytes.fromhex(data))
seed = Mnemonic.to_seed(code, passphrase="<PASSWORD>")
xprv = BIP32Key.fromEntropy(seed).ExtendedKey()
... | [
"json.dump",
"random.seed.hex",
"mnemonic.Mnemonic.to_seed",
"bip32utils.BIP32Key.fromEntropy",
"mnemonic.Mnemonic",
"random.seed"
] | [((218, 265), 'mnemonic.Mnemonic.to_seed', 'Mnemonic.to_seed', (['code'], {'passphrase': '"""<PASSWORD>"""'}), "(code, passphrase='<PASSWORD>')\n", (234, 265), False, 'from mnemonic import Mnemonic\n'), ((329, 339), 'random.seed.hex', 'seed.hex', ([], {}), '()\n', (337, 339), False, 'from random import choice, seed\n')... |
import pandas as pd
import glob, re, os
import click
def split_lines(text):
text = [' '.join(i.split()) for i in re.split(r'\n{2,}', text)]
text = [i for i in text if i]
return text
def get_num(txt):
return int(re.findall(r'\d+', txt)[0])
def get_ref(txt):
return int(re.findall(r'\d+', txt)[1])
... | [
"pandas.DataFrame",
"re.split",
"click.argument",
"pandas.read_csv",
"re.findall",
"click.group",
"os.path.join"
] | [((1869, 1882), 'click.group', 'click.group', ([], {}), '()\n', (1880, 1882), False, 'import click\n'), ((1920, 1951), 'click.argument', 'click.argument', (['"""forecast_path"""'], {}), "('forecast_path')\n", (1934, 1951), False, 'import click\n'), ((1953, 1994), 'click.argument', 'click.argument', (['"""forecasted_les... |
import pytest
import os
from collections import namedtuple
from ..checksum import ChecksumGenerator
MockDataset = namedtuple('MockDataset', ['files', 'local_files'])
@pytest.fixture
def test_dataset():
fixtures_dir = os.path.join(os.path.dirname(__file__), 'fixtures')
files = ['test_dataset_file_one.txt', '... | [
"os.path.dirname",
"os.path.join",
"collections.namedtuple"
] | [((116, 167), 'collections.namedtuple', 'namedtuple', (['"""MockDataset"""', "['files', 'local_files']"], {}), "('MockDataset', ['files', 'local_files'])\n", (126, 167), False, 'from collections import namedtuple\n'), ((238, 263), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (253, 263), Fal... |
# some_file.py
import sys
# insert at 1, 0 is the script path (or '' in REPL)
sys.path.insert(1, '../')
import argparse
import csv
import json
import os
import time
from copy import deepcopy
from datetime import datetime
import numpy as np
import torch
from sklearn.metrics import confusion_matrix
from torch import nn... | [
"numpy.random.seed",
"argparse.ArgumentParser",
"torch.cat",
"torch.nn.Softmax",
"numpy.arange",
"torch.arange",
"torch.no_grad",
"os.path.join",
"torch.load",
"os.path.exists",
"torch.squeeze",
"helper_utils.EarlyStopping.EarlyStopping",
"datetime.datetime.now",
"json.dump",
"csv.writer... | [((79, 104), 'sys.path.insert', 'sys.path.insert', (['(1)', '"""../"""'], {}), "(1, '../')\n", (94, 104), False, 'import sys\n'), ((742, 789), 'torch.save', 'torch.save', (['[model, dis, lm_opt, dis_opt]', 'path'], {}), '([model, dis, lm_opt, dis_opt], path)\n', (752, 789), False, 'import torch\n'), ((1070, 1095), 'arg... |
import unittest.mock
import pytest
import dwf
@pytest.fixture
def dev():
device = dwf.DwfDevice(0)
return device
@pytest.mark.parametrize('index', [0, -1, 10])
def test_dwf_device_init(index):
dev = dwf.DwfDevice(index)
assert dev.idxDevice == index
@pytest.mark.parametrize('device_id', dwf.DwfDev... | [
"dwf.DwfDevice",
"pytest.mark.parametrize"
] | [((127, 172), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""index"""', '[0, -1, 10]'], {}), "('index', [0, -1, 10])\n", (150, 172), False, 'import pytest\n'), ((273, 330), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""device_id"""', 'dwf.DwfDevice.DEVID'], {}), "('device_id', dwf.DwfDevice.D... |
# -*- coding: iso-8859-1 -*-
from fabric.api import env, task, run
import sys
import os
import subprocess
# ---------- Remote or local definition ----------
env.local_command = False
@task(alias = "lcmd")
def local_command():
env.local_command = True
# ---------- Start clients ----------
# Default values
work... | [
"fabric.api.run",
"fabric.api.task",
"subprocess.Popen",
"os.chdir"
] | [((188, 206), 'fabric.api.task', 'task', ([], {'alias': '"""lcmd"""'}), "(alias='lcmd')\n", (192, 206), False, 'from fabric.api import env, task, run\n'), ((433, 450), 'fabric.api.task', 'task', ([], {'alias': '"""snc"""'}), "(alias='snc')\n", (437, 450), False, 'from fabric.api import env, task, run\n'), ((625, 638), ... |
'''
Copyright 2020 Xilinx 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, softw... | [
"argparse.ArgumentParser",
"numpy.argmax",
"tensorflow.compat.v1.placeholder_with_default",
"customcnn.customcnn",
"tensorflow.compat.v1.Graph",
"tensorflow.compat.v1.losses.softmax_cross_entropy",
"tensorflow.compat.v1.placeholder",
"os.path.dirname",
"tensorflow.compat.v1.Session",
"os.path.base... | [((888, 950), 'tensorflow.compat.v1.logging.set_verbosity', 'tf.compat.v1.logging.set_verbosity', (['tf.compat.v1.logging.ERROR'], {}), '(tf.compat.v1.logging.ERROR)\n', (922, 950), True, 'import tensorflow as tf\n'), ((1635, 1668), 'os.path.dirname', 'os.path.dirname', (['infer_graph_path'], {}), '(infer_graph_path)\n... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.25 on 2020-06-16 12:02
from __future__ import unicode_literals
from django.db import migrations
def add_checksum_algorithms(apps, schema_editor):
"""
Add hash algorithms:
- SHA1
- SHA256
- MD5
"""
ChecksumAlgorithms = apps.get_model("emga... | [
"django.db.migrations.RunPython"
] | [((976, 1067), 'django.db.migrations.RunPython', 'migrations.RunPython', (['add_checksum_algorithms'], {'reverse_code': 'remove_checksum_algorithms'}), '(add_checksum_algorithms, reverse_code=\n remove_checksum_algorithms)\n', (996, 1067), False, 'from django.db import migrations\n')] |
"""
Calcular el cuadrado de un número si este es impar o el cubo
si el número es par.
Por ejemplo, para 4 deberá retornar 64 y para 3 retornar 9.
"""
from unittest import main, TestCase
def solucion(n: int) -> int:
"""Devuelve n^3 si 'n' es par y n^2 si 'n' es impar.
:param n: Número
:type n: int
:r... | [
"unittest.main",
"doctest.testmod"
] | [((798, 815), 'doctest.testmod', 'doctest.testmod', ([], {}), '()\n', (813, 815), False, 'import doctest\n'), ((820, 826), 'unittest.main', 'main', ([], {}), '()\n', (824, 826), False, 'from unittest import main, TestCase\n')] |
from import_export import resources
from import_export.fields import Field
from filmAdvice.movie.models import Movie
from filmAdvice.system.tools import find_imdb_link_for_movie_id
class MovieResource(resources.ModelResource):
movie_id = Field(column_name='movieId', attribute='movie_id')
movie_name = Field(co... | [
"filmAdvice.movie.models.Movie.objects.create",
"filmAdvice.movie.models.Movie.objects.filter",
"import_export.fields.Field",
"filmAdvice.system.tools.find_imdb_link_for_movie_id"
] | [((244, 294), 'import_export.fields.Field', 'Field', ([], {'column_name': '"""movieId"""', 'attribute': '"""movie_id"""'}), "(column_name='movieId', attribute='movie_id')\n", (249, 294), False, 'from import_export.fields import Field\n'), ((312, 362), 'import_export.fields.Field', 'Field', ([], {'column_name': '"""titl... |
"""
Test the RPC service for search1
The RPC module does very little except wrap other methods in a JSONRPCService
object. We test here that things are correctly wrapped, but we don't need to
test search logic here.
"""
import json
import responses
import pytest
from src.utils.config import config
from src.search1_rpc ... | [
"json.loads",
"src.exceptions.AuthError",
"src.exceptions.UnknownType",
"responses.add",
"src.exceptions.UnknownIndex",
"json.dumps",
"unittest.mock.patch",
"pytest.raises",
"responses.add_passthru",
"src.exceptions.ElasticsearchError",
"responses.add_callback",
"src.exceptions.UserProfileErro... | [((1145, 1235), 'responses.add', 'responses.add', (['responses.POST', "config['workspace_url']"], {'json': 'mock_obj_info', 'status': '(200)'}), "(responses.POST, config['workspace_url'], json=mock_obj_info,\n status=200)\n", (1158, 1235), False, 'import responses\n'), ((1286, 1334), 'responses.add_passthru', 'respo... |
from hooman import Hooman # imports local not from
import pygame
window_width, window_height = 500, 500
hapi = Hooman(window_width, window_height)
bg_col = (255, 255, 255)
# the function that gets called when the button is clicked on
def button_clicked(this):
if this.y == 250:
this.y = 300
else:
... | [
"pygame.quit",
"pygame.time.Clock",
"hooman.Hooman"
] | [((114, 149), 'hooman.Hooman', 'Hooman', (['window_width', 'window_height'], {}), '(window_width, window_height)\n', (120, 149), False, 'from hooman import Hooman\n'), ((1444, 1463), 'pygame.time.Clock', 'pygame.time.Clock', ([], {}), '()\n', (1461, 1463), False, 'import pygame\n'), ((1606, 1619), 'pygame.quit', 'pygam... |
# Generated by Django 3.2.8 on 2021-11-15 14:22
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Category',
fields=[
('id', models.BigAutoFi... | [
"django.db.models.URLField",
"django.db.models.TextField",
"django.db.models.ManyToManyField",
"django.db.models.BigAutoField",
"django.db.models.CharField"
] | [((304, 400), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (323, 400), False, 'from django.db import migrations, m... |
# Plutus Bitcoin Brute Forcer
# Made by <NAME>
# https://github.com/Isaacdelly/Plutus
import requests
import os
import binascii
import ecdsa
import hashlib
import time
class pause:
p = 0
def privateKey():
return binascii.hexlify(os.urandom(32)).decode('utf-8')
def publicKey(privatekey):
... | [
"time.sleep",
"binascii.unhexlify",
"hashlib.new",
"ecdsa.SigningKey.from_string",
"os.urandom"
] | [((335, 365), 'binascii.unhexlify', 'binascii.unhexlify', (['privatekey'], {}), '(privatekey)\n', (353, 365), False, 'import binascii\n'), ((375, 438), 'ecdsa.SigningKey.from_string', 'ecdsa.SigningKey.from_string', (['privatekey'], {'curve': 'ecdsa.SECP256k1'}), '(privatekey, curve=ecdsa.SECP256k1)\n', (403, 438), Fal... |
# Objective: match listing hashes with badge creation details.
import random
from market_listing import get_item_nameid_batch
from market_search import load_all_listings, update_all_listings
from parsing_utils import parse_badge_creation_details
from sack_of_gems import get_gem_price
from utils import convert_listing... | [
"sack_of_gems.get_gem_price",
"utils.convert_listing_hash_to_app_name",
"market_search.load_all_listings",
"utils.convert_listing_hash_to_app_id",
"market_search.update_all_listings",
"market_listing.get_item_nameid_batch",
"parsing_utils.parse_badge_creation_details"
] | [((4442, 4656), 'sack_of_gems.get_gem_price', 'get_gem_price', ([], {'enforced_sack_of_gems_price': 'enforced_sack_of_gems_price', 'minimum_allowed_sack_of_gems_price': 'minimum_allowed_sack_of_gems_price', 'retrieve_gem_price_from_scratch': 'retrieve_gem_price_from_scratch'}), '(enforced_sack_of_gems_price=enforced_sa... |
import setuptools
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="small_probs-wlad111",
version="0.2.2",
author="<NAME>",
author_email="<EMAIL>",
description="framework for estimating small probabilities using MCMC based on PyMC3-like probability model",... | [
"setuptools.find_packages"
] | [((468, 494), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (492, 494), False, 'import setuptools\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import re
import sys
import time
import json
import sqlite3
import collections
import jinja2
SQL_GET_PACKAGES = '''
SELECT
name, category, section, pkg_section, version, release, description, dep.dependency
FROM packages
LEFT JOIN (
SELECT
package,... | [
"time.gmtime",
"os.path.dirname",
"time.strftime",
"sqlite3.connect",
"collections.OrderedDict",
"re.compile"
] | [((544, 736), 'collections.OrderedDict', 'collections.OrderedDict', (["(('PKGDEP', 'Depends'), ('BUILDDEP', 'Depends (build)'), ('PKGREP',\n 'Replaces'), ('PKGRECOM', 'Recommends'), ('PKGCONFL', 'Conflicts'), (\n 'PKGBREAK', 'Breaks'))"], {}), "((('PKGDEP', 'Depends'), ('BUILDDEP',\n 'Depends (build)'), ('PKGR... |
from .curve_projective import Point, ProECC, O_POINT_INF
from .ecdsa import ecdsa
import hashlib
import binascii
class TestECDSA():
# all tests here are on the default (Nist P-256) curve
# NIST test vector.
# Msg: message
# d: private key
# Qx, Qy: public key (point)
# k : nonce
# R,S : si... | [
"hashlib.sha256",
"binascii.unhexlify"
] | [((1136, 1157), 'binascii.unhexlify', 'binascii.unhexlify', (['m'], {}), '(m)\n', (1154, 1157), False, 'import binascii\n'), ((2372, 2393), 'binascii.unhexlify', 'binascii.unhexlify', (['m'], {}), '(m)\n', (2390, 2393), False, 'import binascii\n'), ((1175, 1196), 'hashlib.sha256', 'hashlib.sha256', (['m_hex'], {}), '(m... |
import re
from setuptools import setup
version = re.search(
'^__version__\s*=\s*\'(.*)\'',
open('hoist_prop_types/hoist_prop_types.py').read(),
re.M
).group(1)
with open("README.md", "rb") as f:
long_descr = f.read().decode("utf-8")
setup(
name="hoist-prop-types",
packages=["hoist_prop_typ... | [
"setuptools.setup"
] | [((255, 681), 'setuptools.setup', 'setup', ([], {'name': '"""hoist-prop-types"""', 'packages': "['hoist_prop_types']", 'entry_points': "{'console_scripts': [\n 'hoist-prop-types = hoist_prop_types.hoist_prop_types:main']}", 'install_requires': "['codemod']", 'version': 'version', 'description': '"""Hoist your prop t... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
This program is designed to write a pseudo doc from comments
into the files of the musclr package (INRA Grignon)
Usage: python3 list_func_roxygen.py directory
@author <NAME> <<EMAIL>>
"""
##########
# Import #
##########
import os
import sys
impor... | [
"cli_parser.read_args",
"os.system",
"glob.iglob",
"re.search",
"sys.exit",
"re.compile"
] | [((5036, 5083), 're.compile', 're.compile', (["('^.*' + tag_func_name + '\\\\s+(.*)$')"], {}), "('^.*' + tag_func_name + '\\\\s+(.*)$')\n", (5046, 5083), False, 'import re\n'), ((5095, 5142), 're.compile', 're.compile', (["('^.*' + tag_func_desc + '\\\\s+(.*)$')"], {}), "('^.*' + tag_func_desc + '\\\\s+(.*)$')\n", (510... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.2 on 2016-06-05 21:26
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('shop', '0023_order_cancelled'),
]
operations = [
migrations.AlterModelOptions(
name='product',
... | [
"django.db.models.CharField",
"django.db.migrations.AlterModelOptions"
] | [((254, 418), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""product"""', 'options': "{'ordering': ['available_in', 'price'], 'verbose_name': 'Product',\n 'verbose_name_plural': 'Products'}"}), "(name='product', options={'ordering': [\n 'available_in', 'price'], 'verbo... |
import media
import fresh_tomatoes
# Creation of list of movies that are to be in the website.
toystory = media.Movie(
"Toy Story",
"Toy Story is an American computer-animated buddy-comedy adventure film",
"http://upload.wikimedia.org/wikipedia/en/1/13/Toy_Story.jpg",
"https://www.youtube.com/watch?v=4... | [
"fresh_tomatoes.open_movies_page",
"media.Movie"
] | [((107, 327), 'media.Movie', 'media.Movie', (['"""Toy Story"""', '"""Toy Story is an American computer-animated buddy-comedy adventure film"""', '"""http://upload.wikimedia.org/wikipedia/en/1/13/Toy_Story.jpg"""', '"""https://www.youtube.com/watch?v=4KPTXpQehio"""'], {}), "('Toy Story',\n 'Toy Story is an American c... |
#!/usr/bin/env python
from distutils.core import setup
setup(name="mdtools",
version="0.5",
description="Tools for working with LAMMPS",
author="<NAME>",
author_email="<EMAIL>",
url="github.com/anjohan/mdtools",
scripts=["logplotter.py"]
)
| [
"distutils.core.setup"
] | [((57, 250), 'distutils.core.setup', 'setup', ([], {'name': '"""mdtools"""', 'version': '"""0.5"""', 'description': '"""Tools for working with LAMMPS"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""github.com/anjohan/mdtools"""', 'scripts': "['logplotter.py']"}), "(name='mdtools', version='0.... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
class CNN(nn.Module):
def __init__(self, vocab_size, embed_dim, class_num, kernel_num, kernel_sizes,
dropout, static, in_channels, weight):
super().__init__()
self.in_channels = ... | [
"torch.nn.Dropout",
"torch.autograd.Variable",
"torch.nn.Embedding",
"torch.nn.Conv2d",
"torch.cat",
"torch.from_numpy"
] | [((422, 457), 'torch.nn.Embedding', 'nn.Embedding', (['vocab_size', 'embed_dim'], {}), '(vocab_size, embed_dim)\n', (434, 457), True, 'import torch.nn as nn\n'), ((687, 706), 'torch.nn.Dropout', 'nn.Dropout', (['dropout'], {}), '(dropout)\n', (697, 706), True, 'import torch.nn as nn\n'), ((1056, 1071), 'torch.cat', 'to... |
from urllib.parse import urlencode
from allauth.account.adapter import DefaultAccountAdapter
from allauth.exceptions import ImmediateHttpResponse
from django.http import HttpResponseRedirect
from django.urls import reverse
from allauth_2fa.utils import user_has_valid_totp_device
class OTPAdapter(DefaultAccountAdap... | [
"django.urls.reverse",
"django.http.HttpResponseRedirect",
"allauth_2fa.utils.user_has_valid_totp_device",
"urllib.parse.urlencode"
] | [((437, 469), 'allauth_2fa.utils.user_has_valid_totp_device', 'user_has_valid_totp_device', (['user'], {}), '(user)\n', (463, 469), False, 'from allauth_2fa.utils import user_has_valid_totp_device\n'), ((825, 859), 'django.urls.reverse', 'reverse', (['"""two-factor-authenticate"""'], {}), "('two-factor-authenticate')\n... |
#!/usr/bin/env python
import time
import asyncio
import logging
import ujson
import websockets
import hummingbot.connector.exchange.bitmart.bitmart_constants as CONSTANTS
from typing import Optional, List, AsyncIterable, Any, Dict
from hummingbot.core.data_type.user_stream_tracker_data_source import UserStreamTracker... | [
"hummingbot.connector.exchange.bitmart.bitmart_utils.convert_to_exchange_trading_pair",
"asyncio.sleep",
"websockets.connect",
"ujson.loads",
"asyncio.wait_for",
"time.time",
"hummingbot.connector.exchange.bitmart.bitmart_utils.decompress_ws_message",
"hummingbot.connector.exchange.bitmart.bitmart_uti... | [((896, 923), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (913, 923), False, 'import logging\n'), ((2439, 2461), 'ujson.loads', 'ujson.loads', (['auth_resp'], {}), '(auth_resp)\n', (2450, 2461), False, 'import ujson\n'), ((2242, 2274), 'hummingbot.connector.exchange.bitmart.bitmart_uti... |
import collections
from constants import *
def process_sample(json_file):
# between 0-11
key = KEY_TO_NUM[json_file["metadata"]["key"]]
mode_string = json_file["metadata"]["mode"]
# if no mode_string, we can assume that it is major
# between 0-6
mode = int(mode_string) - 1 if mod... | [
"collections.Counter"
] | [((1068, 1096), 'collections.Counter', 'collections.Counter', (['octaves'], {}), '(octaves)\n', (1087, 1096), False, 'import collections\n')] |
from __future__ import unicode_literals
from django.test import TestCase
from wtl.wtparser.parser import parse, guess, load, get_parser_for_filename
from wtl.wtparser.parsers import RequirementsParser, GemfileParser, PodfileParser
from wtl.wtparser.tests.parsers.gemfile import GEMFILE
from wtl.wtparser.tests.parsers.... | [
"wtl.wtparser.parser.load",
"wtl.wtparser.parser.guess",
"wtl.wtparser.parser.get_parser_for_filename"
] | [((873, 887), 'wtl.wtparser.parser.guess', 'guess', (['content'], {}), '(content)\n', (878, 887), False, 'from wtl.wtparser.parser import parse, guess, load, get_parser_for_filename\n'), ((1311, 1326), 'wtl.wtparser.parser.load', 'load', (['"""unknown"""'], {}), "('unknown')\n", (1315, 1326), False, 'from wtl.wtparser.... |
import threading
import time
def thread_worker():
print('my thread has entered the "running" state')
#Not running state
time.sleep(10)
print('My thread is terminating')
myThread = threading.Thread(target=thread_worker)
myThread.start()
myThread.join()
| [
"threading.Thread",
"time.sleep"
] | [((200, 238), 'threading.Thread', 'threading.Thread', ([], {'target': 'thread_worker'}), '(target=thread_worker)\n', (216, 238), False, 'import threading\n'), ((134, 148), 'time.sleep', 'time.sleep', (['(10)'], {}), '(10)\n', (144, 148), False, 'import time\n')] |
import numpy as np
class Dual:
"""
This is a class for mathematical operations on dual numbers.
Attributes:
val (float): function value of dual number.
der (float): derivative part of dual number.
"""
def __init__(self, x, der=1):
"""
The constructor for Dual class... | [
"numpy.log"
] | [((6508, 6521), 'numpy.log', 'np.log', (['other'], {}), '(other)\n', (6514, 6521), True, 'import numpy as np\n'), ((5810, 5826), 'numpy.log', 'np.log', (['self.val'], {}), '(self.val)\n', (5816, 5826), True, 'import numpy as np\n')] |
"""Learning reward models using preference comparisons.
Trains a reward model and optionally a policy based on preferences
between trajectory fragments.
"""
import abc
import random
from typing import List, Optional, Sequence, Tuple
import numpy as np
import torch as th
from imitation.algorithms import base
from i... | [
"imitation.data.rollout.compute_returns",
"imitation.data.types.TrajectoryWithRew",
"torch.utils.data.RandomSampler",
"random.Random",
"imitation.data.rollout.flatten_trajectories",
"numpy.random.default_rng",
"numpy.array",
"numpy.exp",
"numpy.sign",
"torch.as_tensor",
"imitation.util.logger.co... | [((2839, 2858), 'random.Random', 'random.Random', (['seed'], {}), '(seed)\n', (2852, 2858), False, 'import random\n'), ((8056, 8088), 'numpy.random.default_rng', 'np.random.default_rng', ([], {'seed': 'seed'}), '(seed=seed)\n', (8077, 8088), True, 'import numpy as np\n'), ((9753, 9765), 'numpy.array', 'np.array', (['[]... |
from django.contrib.postgres.signals import (
get_citext_oids,
get_hstore_oids,
register_type_handlers,
)
from django.db import NotSupportedError, router
from django.db.migrations import AddConstraint, AddIndex, RemoveIndex
from django.db.migrations.operations.base import Operation
from django.db.models.con... | [
"django.contrib.postgres.signals.get_citext_oids.cache_clear",
"django.contrib.postgres.signals.get_hstore_oids.cache_clear",
"django.db.NotSupportedError",
"django.contrib.postgres.signals.register_type_handlers",
"django.db.router.allow_migrate"
] | [((1045, 1074), 'django.contrib.postgres.signals.get_hstore_oids.cache_clear', 'get_hstore_oids.cache_clear', ([], {}), '()\n', (1072, 1074), False, 'from django.contrib.postgres.signals import get_citext_oids, get_hstore_oids, register_type_handlers\n'), ((1083, 1112), 'django.contrib.postgres.signals.get_citext_oids.... |
import os
import sys
import gzip
import logging
import numpy as np
import click
import reader
import paddle.v2 as paddle
from paddle.v2.layer import parse_network
from network_conf import encoder_decoder_network
logger = logging.getLogger("paddle")
logger.setLevel(logging.WARNING)
def infer_a_batch(inferer, test_ba... | [
"paddle.v2.init",
"gzip.open",
"os.path.exists",
"click.option",
"paddle.v2.inference.Inference",
"click.command",
"numpy.where",
"reader.gen_reader",
"paddle.v2.parameters.Parameters.from_tar",
"logging.getLogger"
] | [((223, 250), 'logging.getLogger', 'logging.getLogger', (['"""paddle"""'], {}), "('paddle')\n", (240, 250), False, 'import logging\n'), ((1184, 1209), 'click.command', 'click.command', (['"""generate"""'], {}), "('generate')\n", (1197, 1209), False, 'import click\n'), ((1211, 1310), 'click.option', 'click.option', (['"... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Python implementation of arrange utility with Numpy backend from the MATLAB Tensor Toolbox [1].
References
========================================
[1] General software, latest release: <NAME>, <NAME> and others, Tensor Toolbox for MATLAB, Version 3.2.1, www.tensortool... | [
"torch.argsort"
] | [((1101, 1123), 'torch.argsort', 'tr.argsort', (['(-M.Weights)'], {}), '(-M.Weights)\n', (1111, 1123), True, 'import torch as tr\n')] |
import os
from setuptools import setup, find_packages
from setuptools.command.test import test as TestCommand
import sys
import uuid
from taskwarrior_subtask_capsule import __version__ as version_string
requirements_path = os.path.join(
os.path.dirname(__file__),
'requirements.txt',
)
try:
from pip.req i... | [
"tox.cmdline",
"os.path.dirname",
"setuptools.command.test.test.finalize_options",
"uuid.uuid1",
"sys.exit",
"setuptools.find_packages"
] | [((244, 269), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (259, 269), False, 'import os\n'), ((809, 843), 'setuptools.command.test.test.finalize_options', 'TestCommand.finalize_options', (['self'], {}), '(self)\n', (837, 843), True, 'from setuptools.command.test import test as TestCommand\... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
class BTree:
class Node:
def __init__(self):
self.sons = []
self.keys = []
def __repr__(self):
return 'Node' + str(self.keys) + str(self.sons)
def _lower_bound(self, key):
... | [
"collections.defaultdict",
"random.random",
"random.seed",
"random.randint"
] | [((11980, 12003), 'random.randint', 'random.randint', (['(0)', '(1000)'], {}), '(0, 1000)\n', (11994, 12003), False, 'import random\n'), ((12060, 12077), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (12071, 12077), False, 'import random\n'), ((12255, 12283), 'collections.defaultdict', 'collections.defaultd... |
# coding=utf-8
import logging
import os
from common import Common
logger = logging.getLogger(__name__)
class LocalCodeContainer(Common):
def __init__(self, file_path=None):
self.FilePath = file_path
def get_local_code_container(self):
container = self.client.factory.create('LocalCodeContai... | [
"logging.getLogger",
"os.path.basename"
] | [((77, 104), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (94, 104), False, 'import logging\n'), ((691, 722), 'os.path.basename', 'os.path.basename', (['self.FilePath'], {}), '(self.FilePath)\n', (707, 722), False, 'import os\n')] |
from relay_sdk import Interface, WebhookServer
from quart import Quart, request
import logging
import json
relay = Interface()
app = Quart('json')
logging.getLogger().setLevel(logging.INFO)
@app.route('/', methods=['POST'])
async def handler():
r = await request.get_json(force=True)
logging.info("Received th... | [
"relay_sdk.Interface",
"json.dumps",
"quart.Quart",
"quart.request.get_json",
"relay_sdk.WebhookServer",
"logging.getLogger"
] | [((116, 127), 'relay_sdk.Interface', 'Interface', ([], {}), '()\n', (125, 127), False, 'from relay_sdk import Interface, WebhookServer\n'), ((134, 147), 'quart.Quart', 'Quart', (['"""json"""'], {}), "('json')\n", (139, 147), False, 'from quart import Quart, request\n'), ((149, 168), 'logging.getLogger', 'logging.getLog... |
# Copyright 2021 Wirepas Ltd. All Rights Reserved.
#
# See file LICENSE.txt for full license details.
#
import argparse
from wirepas_mqtt_library import WirepasNetworkInterface
from time import sleep, strftime
import os
import logging
if __name__ == "__main__":
parser = argparse.ArgumentParser(fromfile_prefix_cha... | [
"argparse.ArgumentParser",
"logging.basicConfig",
"time.strftime",
"time.sleep",
"wirepas_mqtt_library.WirepasNetworkInterface"
] | [((277, 327), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'fromfile_prefix_chars': '"""@"""'}), "(fromfile_prefix_chars='@')\n", (300, 327), False, 'import argparse\n'), ((1501, 1593), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s %(asctime)s %(message)s"""', 'level': '... |
# Copyright 2018 DeepMind Technologies Limited. 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 ... | [
"acme.tf.utils.batch_to_sequence",
"sonnet.static_unroll",
"tensorflow.convert_to_tensor",
"sonnet.optimizers.Adam",
"tensorflow.reduce_mean",
"trfl.policy_gradient",
"time.time",
"acme.utils.counting.Counter",
"acme.utils.loggers.TerminalLogger",
"tensorflow.cast",
"acme.tf.utils.to_numpy",
"... | [((1758, 1806), 'sonnet.optimizers.Adam', 'snt.optimizers.Adam', ([], {'learning_rate': 'learning_rate'}), '(learning_rate=learning_rate)\n', (1777, 1806), True, 'import sonnet as snt\n'), ((2372, 2408), 'tensorflow.convert_to_tensor', 'tf.convert_to_tensor', (['max_abs_reward'], {}), '(max_abs_reward)\n', (2392, 2408)... |
# Copyright (C) 2011, the scikit-image team
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of cond... | [
"numpy.maximum",
"numpy.multiply",
"numpy.ceil",
"numpy.empty",
"numpy.asarray",
"numpy.dtype",
"numpy.floor",
"numpy.iinfo",
"numpy.clip",
"numpy.floor_divide",
"numpy.any",
"numpy.min",
"numpy.max",
"numpy.array",
"numpy.rint",
"numpy.add",
"numpy.issubdtype"
] | [((3533, 3550), 'numpy.any', 'np.any', (['(image < 0)'], {}), '(image < 0)\n', (3539, 3550), True, 'import numpy as np\n'), ((7032, 7049), 'numpy.asarray', 'np.asarray', (['image'], {}), '(image)\n', (7042, 7049), True, 'import numpy as np\n'), ((7099, 7114), 'numpy.dtype', 'np.dtype', (['dtype'], {}), '(dtype)\n', (71... |
import unittest
from rotational_cipher import (
rotate,
)
# Tests adapted from `problem-specifications//canonical-data.json`
class RotationalCipherTest(unittest.TestCase):
def test_rotate_a_by_0_same_output_as_input(self):
self.assertEqual(rotate("a", 0), "a")
def test_rotate_a_by_1(self):
... | [
"unittest.main",
"rotational_cipher.rotate"
] | [((1328, 1343), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1341, 1343), False, 'import unittest\n'), ((261, 275), 'rotational_cipher.rotate', 'rotate', (['"""a"""', '(0)'], {}), "('a', 0)\n", (267, 275), False, 'from rotational_cipher import rotate\n'), ((342, 356), 'rotational_cipher.rotate', 'rotate', (['""... |
import os
import re
def load_labels(labels_file):
if not os.path.isfile(labels_file):
print('Label file is required!')
return -1
print('Loading labels')
image_label_pairs = {}
label_text_dict = {}
images = []
i = 0
with open(labels_file) as f:
for line in f:... | [
"os.path.isfile"
] | [((62, 89), 'os.path.isfile', 'os.path.isfile', (['labels_file'], {}), '(labels_file)\n', (76, 89), False, 'import os\n')] |
#!/usr/bin/python
#
# updated testing system for classes and BT leaves
#
# BH May 2017
# Copyright 2017 University of Washington
# Developed by <NAME> and <NAME>
# BioRobotics Lab, University of Washington
# Redistribution and use in source and binary forms, with or without modification, are permitted provided that... | [
"sys.path.append",
"sympy.symbols",
"io.StringIO",
"unittest.TextTestRunner",
"unittest.TestLoader",
"os.chdir",
"tests.HTMLTestRunner.HTMLTestRunner"
] | [((1859, 1881), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (1874, 1881), False, 'import sys\n'), ((1882, 1917), 'sys.path.append', 'sys.path.append', (['"""../ikbtfunctions"""'], {}), "('../ikbtfunctions')\n", (1897, 1917), False, 'import sys\n'), ((2598, 2613), 'os.chdir', 'os.chdir', (['"... |
import itertools
import random
import zope.event
import gym_pool.envs.config as config
import gym_pool.envs.event as event
import gym_pool.envs.physics as physics
def resolve_all_collisions(balls, holes, table_sides):
# destroys any circles that are in a hole
for ball_hole_combination in itertools.product(b... | [
"gym_pool.envs.physics.ball_collision_check",
"random.shuffle",
"itertools.combinations",
"gym_pool.envs.physics.collide_line_ball",
"itertools.product",
"gym_pool.envs.physics.line_ball_collision_check",
"gym_pool.envs.physics.collide_balls",
"gym_pool.envs.physics.distance_less_equal",
"gym_pool.e... | [((301, 332), 'itertools.product', 'itertools.product', (['balls', 'holes'], {}), '(balls, holes)\n', (318, 332), False, 'import itertools\n'), ((631, 668), 'itertools.product', 'itertools.product', (['table_sides', 'balls'], {}), '(table_sides, balls)\n', (648, 668), False, 'import itertools\n'), ((979, 1004), 'random... |
# Problem: large array of numbers.
# input = [3,5,8,12]
# output = [product of all but input[0], product of all but input[1], 3 * 5 * 12]
# output = [5 * 8 * 12, 3 * 8 * 12, ...]
from functools import reduce
input = [3,5,8,12]
# Baseline
product = reduce((lambda x,y: x*y), input)
print(product)
from functools impo... | [
"functools.reduce"
] | [((251, 284), 'functools.reduce', 'reduce', (['(lambda x, y: x * y)', 'input'], {}), '(lambda x, y: x * y, input)\n', (257, 284), False, 'from functools import reduce\n'), ((1386, 1419), 'functools.reduce', 'reduce', (['(lambda x, y: x * y)', 'input'], {}), '(lambda x, y: x * y, input)\n', (1392, 1419), False, 'from fu... |
#!/usr/bin/env python
"""
@package mi/dataset/parser
@file mi/dataset/parser/glider.py
@author <NAME> & <NAME>
@brief Module containing parser scripts for glider data set agents
"""
__author__ = '<NAME>, <NAME>, <NAME>'
__license__ = 'Apache 2.0'
import re
import ntplib
from math import copysign, isnan
from mi.core.lo... | [
"mi.core.exceptions.DatasetParserException",
"mi.core.log.get_logger",
"mi.core.exceptions.ConfigurationException",
"mi.core.exceptions.SampleException",
"mi.core.exceptions.SampleEncodingException",
"re.compile"
] | [((732, 744), 'mi.core.log.get_logger', 'get_logger', ([], {}), '()\n', (742, 744), False, 'from mi.core.log import get_logger\n'), ((5569, 5586), 're.compile', 're.compile', (['regex'], {}), '(regex)\n', (5579, 5586), False, 'import re\n'), ((36206, 36232), 're.compile', 're.compile', (['header_pattern'], {}), '(heade... |
from pytorch_tabular.augmentations import get_random_index, mixup, cutmix
import numpy as np
import torch
def test_get_random_index():
torch.manual_seed(0)
x = torch.Tensor([1, 2, 3])
expected = np.array([2, 0, 1])
actual = get_random_index(x).numpy()
np.testing.assert_array_equal(actual, expected... | [
"numpy.random.seed",
"pytorch_tabular.augmentations.mixup",
"pytorch_tabular.augmentations.get_random_index",
"numpy.testing.assert_array_equal",
"torch.manual_seed",
"pytorch_tabular.augmentations.cutmix",
"torch.Tensor",
"numpy.array"
] | [((141, 161), 'torch.manual_seed', 'torch.manual_seed', (['(0)'], {}), '(0)\n', (158, 161), False, 'import torch\n'), ((170, 193), 'torch.Tensor', 'torch.Tensor', (['[1, 2, 3]'], {}), '([1, 2, 3])\n', (182, 193), False, 'import torch\n'), ((209, 228), 'numpy.array', 'np.array', (['[2, 0, 1]'], {}), '([2, 0, 1])\n', (21... |
#!/usr/bin/env python
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import os
import random
from distributions import Bernoulli, Categorical, DiagGaussian
from utils import init
# Convert weights from tensorflow to pytorch
def copy_mlp_weights(baselines_model):
model_param... | [
"torch.nn.Dropout",
"distributions.Categorical",
"torch.cat",
"torch.nn.init.constant_",
"torch.nn.init.calculate_gain",
"os.path.join",
"stable_baselines.TRPO.load",
"numpy.transpose",
"torch.nn.Linear",
"stable_baselines.PPO2.load",
"torch.nn.init.orthogonal_",
"torch.nn.GRU",
"torch.nn.Ta... | [((1304, 1329), 'torch.tensor', 'torch.tensor', (['params[key]'], {}), '(params[key])\n', (1316, 1329), False, 'import torch\n'), ((1522, 1553), 'numpy.transpose', 'np.transpose', (['obs', '(3, 2, 0, 1)'], {}), '(obs, (3, 2, 0, 1))\n', (1534, 1553), True, 'import numpy as np\n'), ((2499, 2524), 'torch.tensor', 'torch.t... |
import origen
from origen.interface import BaseInterface, dut, tester
from contextlib import contextmanager, ContextDecorator
#import pdb; pdb.set_trace()
class Interface(BaseInterface):
#def func(self, name):
# with tester().specific("v93k_smt7") as v93k:
# t = v93k.test_suites.add(name)
# ... | [
"origen.interface.dut",
"origen.interface.tester"
] | [((1300, 1308), 'origen.interface.tester', 'tester', ([], {}), '()\n', (1306, 1308), False, 'from origen.interface import BaseInterface, dut, tester\n'), ((3292, 3300), 'origen.interface.tester', 'tester', ([], {}), '()\n', (3298, 3300), False, 'from origen.interface import BaseInterface, dut, tester\n'), ((5389, 5397)... |
"""Tests for parsing."""
import unittest
from typing import Iterable
import citation_url
from citation_url import IRRECONCILABLE, PREFIXES, PROTOCOLS, Result, Status
class TestParse(unittest.TestCase):
"""Tests for parsing."""
def test_protocols(self):
"""Test all protocols are formed properly."""
... | [
"citation_url.Result",
"citation_url.parse"
] | [((1206, 1275), 'citation_url.Result', 'Result', ([], {'status': 'Status.success', 'prefix': '"""pubmed"""', 'identifier': '"""34739845"""'}), "(status=Status.success, prefix='pubmed', identifier='34739845')\n", (1212, 1275), False, 'from citation_url import IRRECONCILABLE, PREFIXES, PROTOCOLS, Result, Status\n'), ((40... |
import unittest
from AerospikeClientMock import AerospikeClientMock
class TestAerospikeClientMock(unittest.TestCase):
def setUp(self):
pass
def test_blank_init(self):
asm = AerospikeClientMock()
self.assertEqual({}, asm.dump())
def test_connected(self):
asm = AerospikeCli... | [
"unittest.main",
"AerospikeClientMock.AerospikeClientMock"
] | [((8863, 8878), 'unittest.main', 'unittest.main', ([], {}), '()\n', (8876, 8878), False, 'import unittest\n'), ((200, 221), 'AerospikeClientMock.AerospikeClientMock', 'AerospikeClientMock', ([], {}), '()\n', (219, 221), False, 'from AerospikeClientMock import AerospikeClientMock\n'), ((308, 329), 'AerospikeClientMock.A... |
##### https://www.pyimagesearch.com/2017/12/11/image-classification-with-keras-and-deep-learning/
# USAGE
# python train_network.py --dataset images --model santa_not_santa.model
# set the matplotlib backend so figures can be saved in the background
import matplotlib
matplotlib.use("Agg")
## we set the matplotlib bac... | [
"keras.preprocessing.image.ImageDataGenerator",
"imutils.paths.list_images",
"pyimagesearch.lenet.LeNet.plot_model",
"argparse.ArgumentParser",
"random.shuffle",
"sklearn.model_selection.train_test_split",
"keras.optimizers.Adam",
"cv2.imread",
"keras.preprocessing.image.img_to_array",
"matplotlib... | [((269, 290), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (283, 290), False, 'import matplotlib\n'), ((1013, 1038), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1036, 1038), False, 'import argparse\n'), ((2820, 2835), 'random.seed', 'random.seed', (['(42)'], {}), '(... |
import sys
from collections import namedtuple
from enum import Enum
from typing import Callable
from typing import Mapping
from typing import Optional
from typing import Set
from typing import Tuple
from maps_generator.checks import check
from maps_generator.checks.check_addresses import get_addresses_check_set
from m... | [
"maps_generator.checks.check_log_levels.get_log_levels_check_set",
"maps_generator.checks.check.norm",
"maps_generator.checks.check_addresses.get_addresses_check_set",
"maps_generator.checks.check_sections.get_sections_existence_check_set",
"maps_generator.checks.check.get_rel",
"maps_generator.checks.che... | [((930, 969), 'collections.namedtuple', 'namedtuple', (['"""Threshold"""', "['abs', 'rel']"], {}), "('Threshold', ['abs', 'rel'])\n", (940, 969), False, 'from collections import namedtuple\n'), ((2779, 2831), 'maps_generator.checks.check_sections.get_sections_existence_check_set', 'get_sections_existence_check_set', ([... |
# load module (Requires that the module supports it by exposing its functions)
import module
hello = module.Hello("Hello")
hello.say_hello()
# Import class from module
from module import module_class
hey = module_class.Hello("Hey!")
hey.say_hello()
# Import class from file
from classes import Hello
hi = Hello("Hi")
... | [
"module.Hello",
"module.module_class.Hello",
"classes.Hello"
] | [((102, 123), 'module.Hello', 'module.Hello', (['"""Hello"""'], {}), "('Hello')\n", (114, 123), False, 'import module\n'), ((208, 234), 'module.module_class.Hello', 'module_class.Hello', (['"""Hey!"""'], {}), "('Hey!')\n", (226, 234), False, 'from module import module_class\n'), ((308, 319), 'classes.Hello', 'Hello', (... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
from config.template_middleware import TemplateResponse
from tekton import router
from gaecookie.decorator import no_csrf
from gaepermission.decorator import login_not_required
from routes.alunos import admin, rest
@login_not_required
@n... | [
"tekton.router.to_path",
"config.template_middleware.TemplateResponse"
] | [((573, 598), 'config.template_middleware.TemplateResponse', 'TemplateResponse', (['context'], {}), '(context)\n', (589, 598), False, 'from config.template_middleware import TemplateResponse\n'), ((379, 404), 'tekton.router.to_path', 'router.to_path', (['rest.save'], {}), '(rest.save)\n', (393, 404), False, 'from tekto... |
import jinja2
jinja_env = jinja2.Environment(extensions=['jinja2.ext.do']) | [
"jinja2.Environment"
] | [((27, 75), 'jinja2.Environment', 'jinja2.Environment', ([], {'extensions': "['jinja2.ext.do']"}), "(extensions=['jinja2.ext.do'])\n", (45, 75), False, 'import jinja2\n')] |
#!/usr/bin/env python3
# coding: utf-8
# MIT License
#
# Copyright (c) 2017 <NAME>
# Copyright (c) 2020 <NAME> / <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 restrictio... | [
"pandas.DataFrame",
"pulp.LpVariable.dicts",
"argparse.ArgumentParser",
"pandas.read_csv",
"random.shuffle",
"time.process_time",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.bar",
"time.time",
"matplotlib.pyplot.figure",
"pulp.LpProblem",
"matplotlib.pyplot.savefig"
] | [((1629, 1652), 'pandas.DataFrame', 'pd.DataFrame', (['distances'], {}), '(distances)\n', (1641, 1652), True, 'import pandas as pd\n'), ((4076, 4095), 'random.shuffle', 'random.shuffle', (['ids'], {}), '(ids)\n', (4090, 4095), False, 'import random\n'), ((6696, 6717), 'random.shuffle', 'random.shuffle', (['idata'], {})... |
# -*- encoding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
import six
from addonpayments.mixins import HashMixin
class SdkResponse(HashMixin):
"""
Class representing the SDK response. This class is valid for HPP and API
You can consult the specific documentation of all HPP and ... | [
"six.iteritems"
] | [((931, 959), 'six.iteritems', 'six.iteritems', (['self.__dict__'], {}), '(self.__dict__)\n', (944, 959), False, 'import six\n')] |
import os
PROJECT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
MODELS_DIR = os.path.join(PROJECT_DIR, "trained_models")
STATS_LOGGER_NAME = "stats_logger"
PARAM_LOGGER_NAME = "param_logger"
| [
"os.path.dirname",
"os.path.join"
] | [((106, 149), 'os.path.join', 'os.path.join', (['PROJECT_DIR', '"""trained_models"""'], {}), "(PROJECT_DIR, 'trained_models')\n", (118, 149), False, 'import os\n'), ((54, 79), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (69, 79), False, 'import os\n')] |
# Generated by Django 3.0.3 on 2020-02-21 10:58
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("StudentVillage", "0001_initial")]
operations = [
migrations.AlterModelOptions(
name="studentvillage",
options={"verbose_name": "Studenby"... | [
"django.db.migrations.AlterModelOptions"
] | [((208, 339), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""studentvillage"""', 'options': "{'verbose_name': 'Studenby', 'verbose_name_plural': 'Studentbyer'}"}), "(name='studentvillage', options={'verbose_name':\n 'Studenby', 'verbose_name_plural': 'Studentbyer'})\n", (... |
#! /usr/bin/env python
import base64
import hashlib
import hmac
import json
import os
import requests
import sys
import time
from collections import defaultdict
try:
from configparser import ConfigParser
except ImportError: # python 2
from ConfigParser import ConfigParser
try:
from urllib.parse import q... | [
"urllib.quote",
"os.getcwd",
"pygments.lexers.JsonLexer",
"os.path.exists",
"json.dumps",
"time.sleep",
"collections.defaultdict",
"pygments.formatters.TerminalFormatter",
"base64.b64encode",
"requests.get",
"ConfigParser.ConfigParser",
"os.path.expanduser"
] | [((1069, 1094), 'urllib.quote', 'quote', (['value'], {'safe': '""".-*_"""'}), "(value, safe='.-*_')\n", (1074, 1094), False, 'from urllib import quote\n'), ((4779, 4793), 'ConfigParser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (4791, 4793), False, 'from ConfigParser import ConfigParser\n'), ((5227, 5243), 'colle... |
a = [1,2,3,4]
while a:
print(a.pop())
# 4 3 2 1
if []:
print("True")
else:
print("False")
# False
if [1,2]:
print("True")
else:
print("False")
# True
# all type of value for example integer, it is also object.
print(type(3)) # <class 'int'>
a = 3
b = 3
print(a is b) # True. Com... | [
"sys.getrefcount",
"copy.copy"
] | [((1081, 1088), 'copy.copy', 'copy', (['a'], {}), '(a)\n', (1085, 1088), False, 'from copy import copy\n'), ((402, 420), 'sys.getrefcount', 'sys.getrefcount', (['(3)'], {}), '(3)\n', (417, 420), False, 'import sys\n'), ((435, 453), 'sys.getrefcount', 'sys.getrefcount', (['a'], {}), '(a)\n', (450, 453), False, 'import s... |
# -*- coding: utf-8 -*-
# *****************************************************************************
# NICOS, the Networked Instrument Control System of the MLZ
# Copyright (c) 2009-2022 by the NICOS contributors (see AUTHORS)
#
# This program is free software; you can redistribute it and/or modify it under
# the t... | [
"nicos.core.Attach",
"nicos.core.errors.ProgrammingError",
"nicos.utils.createThread",
"nicos.core.DataSinkHandler.begin",
"nicos.core.DataSinkHandler.end",
"nicos.utils.readFileCounter",
"nicos.core.Param",
"socket.socket",
"nicos.nexus.nexussink.NexusSink.createHandlers",
"nicos.core.Override",
... | [((3765, 3830), 'nicos.session.experiment._setROParam', 'session.experiment._setROParam', (['"""lastpoint"""', 'self.dataset.counter'], {}), "('lastpoint', self.dataset.counter)\n", (3795, 3830), False, 'from nicos import session\n'), ((4632, 4672), 'nicos_ess.devices.datasinks.nexussink.NexusFileWriterSinkHandler.prep... |
import pytest
from fib import fib_fail, fib_success
from fib import fib_memo, fib_memo_improved
from fib import fib_non_recursive
def test_infinite_loop():
with pytest.raises(RecursionError):
fib_fail(4)
def test_zero():
assert fib_success(0) == 0
def test_one():
assert fib_success(1) == 1
... | [
"fib.fib_memo",
"fib.fib_non_recursive",
"fib.fib_memo_improved",
"pytest.raises",
"fib.fib_fail",
"fib.fib_success"
] | [((168, 197), 'pytest.raises', 'pytest.raises', (['RecursionError'], {}), '(RecursionError)\n', (181, 197), False, 'import pytest\n'), ((207, 218), 'fib.fib_fail', 'fib_fail', (['(4)'], {}), '(4)\n', (215, 218), False, 'from fib import fib_fail, fib_success\n'), ((249, 263), 'fib.fib_success', 'fib_success', (['(0)'], ... |
# Copyright 2020 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... | [
"unittest.mock.MagicMock",
"smspark.history_server_utils.config_history_server",
"unittest.mock.patch",
"smspark.history_server_utils.start_history_server",
"pytest.raises",
"unittest.mock.call"
] | [((1037, 1103), 'unittest.mock.patch', 'patch', (['"""smspark.history_server_utils.open"""'], {'new_callable': 'mock_open'}), "('smspark.history_server_utils.open', new_callable=mock_open)\n", (1042, 1103), False, 'from unittest.mock import MagicMock, call, mock_open, patch\n'), ((1634, 1693), 'unittest.mock.patch', 'p... |
from modules.bricks import places , events
class Action(object) :
pass
# places = {
# "island_gate" : places.Island_gate(),
# "gold_room_gate" : places.Gold_room_gate(),
# "gold_room" : places.Gold_room(),
# "prison" : places.Prison(),
# "diamond_roo... | [
"modules.bricks.events.Bear"
] | [((954, 978), 'modules.bricks.events.Bear', 'events.Bear', (['self.player'], {}), '(self.player)\n', (965, 978), False, 'from modules.bricks import places, events\n')] |
""" Module RxNSEM.py
Receivers for the NSEM problem
"""
from ...utils.code_utils import deprecate_class
import numpy as np
from scipy.constants import mu_0
import properties
from ...utils import sdiag, mkvc
from ...survey import BaseRx
class BaseRxNSEM_Point(BaseRx):
"""
Natural source receiver base class... | [
"properties.StringChoice"
] | [((625, 801), 'properties.StringChoice', 'properties.StringChoice', (['"""component of the field (real or imag)"""', "{'real': ['re', 'in-phase', 'in phase'], 'imag': ['imaginary', 'im',\n 'out-of-phase', 'out of phase']}"], {}), "('component of the field (real or imag)', {'real': [\n 're', 'in-phase', 'in phase'... |
"""
Configuration for QAgent
"""
import csv
from gym_idsgame.agents.training_agents.q_learning.dqn.dqn_config import DQNConfig
class QAgentConfig:
"""
DTO with configuration for QAgent
"""
def __init__(self, gamma :float = 0.8, alpha:float = 0.1, epsilon :float =0.9, render :bool =False,
... | [
"csv.writer"
] | [((5892, 5905), 'csv.writer', 'csv.writer', (['f'], {}), '(f)\n', (5902, 5905), False, 'import csv\n')] |
# Generated by Django 3.1.5 on 2021-03-04 09:47
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('smis', '0002_auto_20210224_1623'),
]
operations = [
migrations.RenameField(
model_name='form4',
old_name='चांगल्या_कोषांचे_व... | [
"django.db.migrations.RemoveField",
"django.db.migrations.RenameField"
] | [((224, 340), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""form4"""', 'old_name': '"""चांगल्या_कोषांचे_वजन_कि_ग्रॅ"""', 'new_name': '"""good_kosh_count"""'}), "(model_name='form4', old_name=\n 'चांगल्या_कोषांचे_वजन_कि_ग्रॅ', new_name='good_kosh_count')\n", (246, 340), False, ... |
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.cart_home, name='cart'),
url(r'^update/$', views.cart_update, name='update'),
url(r'^add/$', views.cart_add, name='add'),
url(r'^cart/$', views.cart_remove, name='delate'),
url(r'^wishlist/$', views.wishlist, nam... | [
"django.conf.urls.url"
] | [((75, 114), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.cart_home'], {'name': '"""cart"""'}), "('^$', views.cart_home, name='cart')\n", (78, 114), False, 'from django.conf.urls import url\n'), ((121, 171), 'django.conf.urls.url', 'url', (['"""^update/$"""', 'views.cart_update'], {'name': '"""update"""'}), "('^... |
# Copyright 2020 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"timesketch.lib.sigma_util.get_sigma_rule",
"os.remove",
"os.stat",
"timesketch.lib.sigma_util.get_sigma_config_file",
"timesketch.lib.sigma_util.get_sigma_blocklist",
"timesketch.lib.sigma_util._sanitize_query",
"timesketch.lib.sigma_util.get_sigma_rule_by_text"
] | [((7724, 7779), 'timesketch.lib.sigma_util._sanitize_query', 'sigma_util._sanitize_query', (['"""(* lorem * OR * lorema *)"""'], {}), "('(* lorem * OR * lorema *)')\n", (7750, 7779), False, 'from timesketch.lib import sigma_util\n'), ((8442, 8489), 'timesketch.lib.sigma_util._sanitize_query', 'sigma_util._sanitize_quer... |
import os
from kubeflow.kubeflow.crud_backend import helpers, status
from ..common import utils as common_utils
KIND = "PVCViewer"
GROUP = "kubeflow.org"
VERSION = "v1alpha1"
PLURAL = "pvcviewers"
PVCVIEWER = [GROUP, VERSION, PLURAL]
PVCVIEWER_YAML = os.path.join(
os.path.abspath(os.path.dirname(__file__)), "pv... | [
"os.path.dirname",
"kubeflow.kubeflow.crud_backend.helpers.load_param_yaml"
] | [((578, 627), 'kubeflow.kubeflow.crud_backend.helpers.load_param_yaml', 'helpers.load_param_yaml', (['PVCVIEWER_YAML'], {}), '(PVCVIEWER_YAML, **kwargs)\n', (601, 627), False, 'from kubeflow.kubeflow.crud_backend import helpers, status\n'), ((289, 314), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file... |
import os
from yacs.config import CfgNode as CN
_C = CN()
_C.CFG_NAME = ''
_C.OUTPUT_DIR = ''
_C.LOG_DIR = ''
_C.DATA_DIR = ''
_C.GPUS = '0'
_C.WORKERS = 4
_C.PRINT_FREQ = 20
_C.AUTO_RESUME = False
_C.PIN_MEMORY = True
_C.RANK = 0
_C.VERBOSE = True
_C.DIST_BACKEND = 'nccl'
_C.DDP = True
# Cudnn related params
_C.CU... | [
"yacs.config.CfgNode"
] | [((55, 59), 'yacs.config.CfgNode', 'CN', ([], {}), '()\n', (57, 59), True, 'from yacs.config import CfgNode as CN\n'), ((326, 330), 'yacs.config.CfgNode', 'CN', ([], {}), '()\n', (328, 330), True, 'from yacs.config import CfgNode as CN\n'), ((452, 456), 'yacs.config.CfgNode', 'CN', ([], {}), '()\n', (454, 456), True, '... |
import unittest
import os
import sys
import io
import contextlib
import yaml
from badjware.v1.placeholdertransformer import plugin
class TestPlaceholderTransformer(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.old_wd = os.getcwd()
# change workdir
os.chdir('tests/plugins/k... | [
"io.StringIO",
"os.getcwd",
"sys.argv.append",
"badjware.v1.placeholdertransformer.plugin.run_plugin",
"contextlib.redirect_stdout",
"yaml.safe_load",
"os.chdir"
] | [((250, 261), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (259, 261), False, 'import os\n'), ((295, 353), 'os.chdir', 'os.chdir', (['"""tests/plugins/kustomize/placeholdertransformer"""'], {}), "('tests/plugins/kustomize/placeholdertransformer')\n", (303, 353), False, 'import os\n'), ((434, 454), 'os.chdir', 'os.chdir'... |
from PySide6.QtWidgets import QApplication, QFileDialog, QMainWindow, QLineEdit, QVBoxLayout
from PySide6.QtWidgets import QWidget, QGridLayout, QPushButton, QStatusBar, QDialogButtonBox, QLabel, QDialog
from PySide6.QtGui import Qt, QAction
import sys
import os
directorio = os.path.dirname(__file__)
# Clase QDialog ... | [
"PySide6.QtGui.QAction",
"os.path.dirname",
"PySide6.QtWidgets.QVBoxLayout",
"PySide6.QtWidgets.QWidget",
"PySide6.QtWidgets.QLabel",
"PySide6.QtWidgets.QDialogButtonBox",
"PySide6.QtWidgets.QLineEdit",
"PySide6.QtWidgets.QPushButton",
"PySide6.QtWidgets.QApplication",
"PySide6.QtWidgets.QStatusBa... | [((277, 302), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (292, 302), False, 'import os\n'), ((11909, 11931), 'PySide6.QtWidgets.QApplication', 'QApplication', (['sys.argv'], {}), '(sys.argv)\n', (11921, 11931), False, 'from PySide6.QtWidgets import QApplication, QFileDialog, QMainWindow, ... |
import re
from PIL import Image
import pytesseract
f = open('doc1.bmp', 'rb')
img = Image.open(f)
text = pytesseract.image_to_string(img)
without_spaces = re.sub('\s+', '', text)
print(len(without_spaces))
f.close()
| [
"re.sub",
"pytesseract.image_to_string",
"PIL.Image.open"
] | [((86, 99), 'PIL.Image.open', 'Image.open', (['f'], {}), '(f)\n', (96, 99), False, 'from PIL import Image\n'), ((108, 140), 'pytesseract.image_to_string', 'pytesseract.image_to_string', (['img'], {}), '(img)\n', (135, 140), False, 'import pytesseract\n'), ((158, 182), 're.sub', 're.sub', (['"""\\\\s+"""', '""""""', 'te... |
# -*- coding: utf-8 -*-
# vim:fileencoding=UTF-8:ts=4:sw=4:sta:et:sts=4:ai
from __future__ import unicode_literals, division, absolute_import, print_function
import sys
import os
import re
from compatibility_utils import PY2
_plat = sys.platform.lower()
iswindows = 'win32' in _plat or 'win64' in _plat
ismacos = iso... | [
"sys.platform.startswith",
"ctypes.byref",
"ctypes.c_wchar_p",
"sys.platform.lower",
"ctypes.create_unicode_buffer",
"re.search",
"re.compile"
] | [((237, 257), 'sys.platform.lower', 'sys.platform.lower', ([], {}), '()\n', (255, 257), False, 'import sys\n'), ((437, 467), 'sys.platform.startswith', 'sys.platform.startswith', (['"""win"""'], {}), "('win')\n", (460, 467), False, 'import sys\n'), ((3672, 3721), 're.compile', 're.compile', (['"""<meta name="ASIN" cont... |
import re
from linguistic_style_transfer_model.config import global_config
from linguistic_style_transfer_model.utils import log_initializer
logger = log_initializer.setup_custom_logger(global_config.logger_name, "INFO")
dev_pos_reviews_file_path = "data/yelp/sentiment.dev.1"
dev_neg_reviews_file_path = "data/yelp/s... | [
"linguistic_style_transfer_model.utils.log_initializer.setup_custom_logger",
"re.sub"
] | [((152, 222), 'linguistic_style_transfer_model.utils.log_initializer.setup_custom_logger', 'log_initializer.setup_custom_logger', (['global_config.logger_name', '"""INFO"""'], {}), "(global_config.logger_name, 'INFO')\n", (187, 222), False, 'from linguistic_style_transfer_model.utils import log_initializer\n'), ((930, ... |
import numpy as np
from random import shuffle
from past.builtins import xrange
def softmax_loss_naive(W, X, y, reg):
"""
Softmax loss function, naive implementation (with loops)
Inputs have dimension D, there are C classes, and we operate on minibatches
of N examples.
Inputs:
- W: A numpy array of shape ... | [
"numpy.matrix",
"numpy.zeros_like",
"numpy.sum",
"numpy.max",
"numpy.arange",
"numpy.exp"
] | [((768, 784), 'numpy.zeros_like', 'np.zeros_like', (['W'], {}), '(W)\n', (781, 784), True, 'import numpy as np\n'), ((1277, 1298), 'numpy.arange', 'np.arange', (['X.shape[0]'], {}), '(X.shape[0])\n', (1286, 1298), True, 'import numpy as np\n'), ((2112, 2128), 'numpy.zeros_like', 'np.zeros_like', (['W'], {}), '(W)\n', (... |
import logging
from remme.tp.pub_key import PUB_KEY_STORE_PRICE, PUB_KEY_ORGANIZATION, PUB_KEY_MAX_VALIDITY
from remme.clients.account import AccountClient
from remme.tp.account import AccountHandler
from remme.shared.exceptions import KeyNotFound
from remme.clients.pub_key import PubKeyClient
from cryptography.haz... | [
"cryptography.x509.Name",
"remme.clients.pub_key.PubKeyClient",
"cryptography.hazmat.primitives.hashes.SHA256",
"remme.clients.account.AccountClient",
"cryptography.x509.NameAttribute",
"datetime.datetime.utcnow",
"remme.tp.account.AccountHandler.make_address_from_data",
"cryptography.x509.Certificate... | [((649, 676), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (666, 676), False, 'import logging\n'), ((6018, 6037), 'cryptography.x509.Name', 'x509.Name', (['name_oid'], {}), '(name_oid)\n', (6027, 6037), False, 'from cryptography import x509\n'), ((7735, 7763), 'cryptography.hazmat.primi... |
from django.contrib import admin
from .models import *
from parler.admin import TranslatableAdmin
from mptt.admin import MPTTModelAdmin
@admin.register(Category)
class CategoryAdmin(TranslatableAdmin, MPTTModelAdmin):
list_display = ['name', 'slug', 'parent']
search_fields = ['name']
def get_populated_fi... | [
"django.contrib.admin.register"
] | [((139, 163), 'django.contrib.admin.register', 'admin.register', (['Category'], {}), '(Category)\n', (153, 163), False, 'from django.contrib import admin\n'), ((389, 412), 'django.contrib.admin.register', 'admin.register', (['Product'], {}), '(Product)\n', (403, 412), False, 'from django.contrib import admin\n')] |
from urllib import urlopen
from django.core.files.storage import default_storage
from django.core.files.base import ContentFile
from social_auth.backends.facebook import FacebookBackend
from social_auth.backends.twitter import TwitterBackend
from social_auth.backends import google
def update_user_details(backend, det... | [
"urllib.urlopen",
"django.core.files.base.ContentFile"
] | [((1256, 1275), 'django.core.files.base.ContentFile', 'ContentFile', (['avatar'], {}), '(avatar)\n', (1267, 1275), False, 'from django.core.files.base import ContentFile\n'), ((1148, 1160), 'urllib.urlopen', 'urlopen', (['url'], {}), '(url)\n', (1155, 1160), False, 'from urllib import urlopen\n')] |
# Copyright 2018 <NAME> <<EMAIL>>
#
# This file is part of Ansible
#
# Ansible 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 version.
#
# Ansi... | [
"ansible.inventory.host.Host",
"ansible.inventory.group.Group"
] | [((1019, 1029), 'ansible.inventory.group.Group', 'Group', (['"""A"""'], {}), "('A')\n", (1024, 1029), False, 'from ansible.inventory.group import Group\n'), ((1042, 1052), 'ansible.inventory.group.Group', 'Group', (['"""B"""'], {}), "('B')\n", (1047, 1052), False, 'from ansible.inventory.group import Group\n'), ((1065,... |
#Wifi hacking using Aircrack-ng
import os
print("[#]Developed by Yatharth[#]")
print("Wi-Fi hacking Automation Program")
print(" ")
print("follow on instagram @im.yatharth")
print("Visit Github:- https://github.com/yatharthgeek/")
print("Subscribe YouTube Channel :- https://www.youtube.com/channel/UC6AXassf_ZGu-icFW8... | [
"os.system"
] | [((829, 845), 'os.system', 'os.system', (['code1'], {}), '(code1)\n', (838, 845), False, 'import os\n'), ((1203, 1219), 'os.system', 'os.system', (['code1'], {}), '(code1)\n', (1212, 1219), False, 'import os\n'), ((1404, 1420), 'os.system', 'os.system', (['code1'], {}), '(code1)\n', (1413, 1420), False, 'import os\n'),... |
from mountaintools import client as mt
import multiprocessing
# key=dict(test='key')
# for ii in range(20):
# val0='{}'.format(ii)
# mt.setValue(key=key,value=val0)
# val1=mt.getValue(key=key)
# print(val0,val1)
# assert val0==val1
# for ii in range(20):
# subkey='{}'.format(ii)
# val0='{}... | [
"mountaintools.client.setValue",
"mountaintools.client.getValue",
"multiprocessing.Pool"
] | [((644, 669), 'multiprocessing.Pool', 'multiprocessing.Pool', (['(100)'], {}), '(100)\n', (664, 669), False, 'import multiprocessing\n'), ((555, 587), 'mountaintools.client.setValue', 'mt.setValue', ([], {'key': 'key', 'value': 'val0'}), '(key=key, value=val0)\n', (566, 587), True, 'from mountaintools import client as ... |
import argparse
import datetime
import glob
import os
import time
import numpy as np
from agent import Agent
from agent_stub import AgentStub
from algo.alphatest import AlphaTest
from algo.random_search import RandomSearch
from env_utils import (instantiate_env_variables, instantiate_eval_callback,
... | [
"agent_stub.AgentStub",
"algo.random_search.RandomSearch",
"env_utils.instantiate_eval_callback",
"argparse.ArgumentParser",
"algo.alphatest.AlphaTest",
"env_utils.instantiate_env_variables",
"numpy.asarray",
"env_utils.standardize_env_name",
"time.time",
"log.Log",
"agent.Agent",
"os.path.joi... | [((563, 581), 'log.Log', 'Log', (['"""experiments"""'], {}), "('experiments')\n", (566, 581), False, 'from log import Log\n'), ((595, 620), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (618, 620), False, 'import argparse\n'), ((2623, 2667), 'env_utils.standardize_env_name', 'standardize_env_n... |
from django.core.files.storage import default_storage
from django.utils.functional import lazy
from drf_spectacular.types import OpenApiTypes
from drf_spectacular.utils import extend_schema_field
from rest_framework import serializers, fields
from baserow.contrib.database.export.handler import ExportHandler
from baser... | [
"drf_spectacular.utils.extend_schema_field",
"rest_framework.fields.IntegerField",
"rest_framework.fields.BooleanField",
"rest_framework.serializers.SerializerMethodField",
"django.core.files.storage.default_storage.url",
"baserow.contrib.database.export.handler.ExportHandler",
"django.utils.functional.... | [((2305, 2340), 'rest_framework.serializers.SerializerMethodField', 'serializers.SerializerMethodField', ([], {}), '()\n', (2338, 2340), False, 'from rest_framework import serializers, fields\n'), ((2436, 2473), 'drf_spectacular.utils.extend_schema_field', 'extend_schema_field', (['OpenApiTypes.URI'], {}), '(OpenApiTyp... |
#!/usr/bin/env python
# Copyright (c) 2011-2019, wradlib developers.
# Distributed under the MIT License. See LICENSE.txt for more info.
"""
Digital Elevation Model I/O
^^^^^^^^^^^^^^^^^^^^^^^^^^^
Provide surface/terrain elevation information from SRTM data
.. autosummary::
:nosignatures:
:toctree: generated/... | [
"os.makedirs",
"osgeo.gdal.Warp",
"numpy.floor",
"os.path.exists",
"requests.get",
"wradlib.util.get_wradlib_data_path",
"osgeo.gdal.Open",
"os.path.join"
] | [((1539, 1569), 'os.path.join', 'os.path.join', (['source', 'filename'], {}), '(source, filename)\n', (1551, 1569), False, 'import os\n'), ((3691, 3719), 'wradlib.util.get_wradlib_data_path', 'util.get_wradlib_data_path', ([], {}), '()\n', (3717, 3719), False, 'from wradlib import util\n'), ((3736, 3770), 'os.path.join... |
##############################################################################
# Copyright (c) 2015 Orange
# <EMAIL> / <EMAIL>
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is availabl... | [
"ast.literal_eval",
"copy.deepcopy",
"opnfv_testapi.tornado_swagger.swagger.model"
] | [((2815, 2830), 'opnfv_testapi.tornado_swagger.swagger.model', 'swagger.model', ([], {}), '()\n', (2828, 2830), False, 'from opnfv_testapi.tornado_swagger import swagger\n'), ((2925, 2940), 'opnfv_testapi.tornado_swagger.swagger.model', 'swagger.model', ([], {}), '()\n', (2938, 2940), False, 'from opnfv_testapi.tornado... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.