code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from __future__ import print_function
import os
from sklearn import preprocessing
from sklearn import ensemble
from sklearn.metrics import accuracy_score,roc_auc_score
import pandas as pd
import joblib
import numpy as np
#import dispatcher
folds={
0:[1,2,3,4],
1:[0,2,3,4],
2:[1,0,3,4],
3:[1,2,0,4],
... | [
"sklearn.preprocessing.LabelEncoder",
"sklearn.ensemble.ExtraTreesClassifier",
"pandas.read_csv",
"sklearn.preprocessing.OneHotEncoder",
"sklearn.ensemble.RandomForestClassifier",
"sklearn.metrics.roc_auc_score",
"joblib.dump",
"sklearn.metrics.accuracy_score"
] | [((1924, 1995), 'joblib.dump', 'joblib.dump', (['label_encoders', 'f"""models/{MODEL}_{FOLD}_label_encoder.pkl"""'], {}), "(label_encoders, f'models/{MODEL}_{FOLD}_label_encoder.pkl')\n", (1935, 1995), False, 'import joblib\n'), ((1995, 2043), 'joblib.dump', 'joblib.dump', (['model', 'f"""models/{MODEL}_{FOLD}.pkl"""']... |
import pytest
import struct
from unittest.mock import MagicMock
import aiomodbus
import asyncio
import aiomodbus.exceptions
import aiomodbus.serial
import aiomodbus.tcp
def async_return(result):
f = asyncio.Future()
f.set_result(result)
return f
def respond(protocol, arr):
def _tmp(data):
p... | [
"unittest.mock.MagicMock",
"aiomodbus.crc.calc_crc",
"pytest.mark.parametrize",
"pytest.raises",
"aiomodbus.serial.ModbusSerialClient",
"aiomodbus.serial.ModbusSerialProtocol",
"asyncio.Future"
] | [((5552, 6137), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""exceptioncls,exception_code"""', '[(aiomodbus.exceptions.IllegalFunction, 1), (aiomodbus.exceptions.\n IllegalDataAddress, 2), (aiomodbus.exceptions.IllegalDataValue, 3), (\n aiomodbus.exceptions.SlaveDeviceFailure, 4), (aiomodbus.excepti... |
import subprocess
from subprocess import PIPE
import helper
def gits_push(args):
"""
This function is used to push local changes to remote branch.
Usage: gits push
"""
try:
untracked_file_check_status = ["git", "status", "--porcelain"]
process0 = subprocess.Popen(untracked_file_che... | [
"subprocess.Popen",
"helper.get_current_branch"
] | [((285, 356), 'subprocess.Popen', 'subprocess.Popen', (['untracked_file_check_status'], {'stdout': 'PIPE', 'stderr': 'PIPE'}), '(untracked_file_check_status, stdout=PIPE, stderr=PIPE)\n', (301, 356), False, 'import subprocess\n'), ((646, 673), 'helper.get_current_branch', 'helper.get_current_branch', ([], {}), '()\n', ... |
#!/usr/bin/env python3
import argparse
import codecs
import operator
import re
import sys
from datetime import datetime, timedelta
timestamp_format = '%b %d %H:%M:%S'
line_pattern = re.compile(r"""
(?P<timestamp>\w+\s+\d+\s+\d+:\d+:\d+)\s+ # timestamp: Oct 8 07:02:22
(?P<hostname>\w+)\s+ ... | [
"argparse.ArgumentParser",
"re.compile",
"datetime.datetime.strptime",
"datetime.timedelta",
"datetime.datetime.today",
"codecs.open"
] | [((185, 616), 're.compile', 're.compile', (['"""\n (?P<timestamp>\\\\w+\\\\s+\\\\d+\\\\s+\\\\d+:\\\\d+:\\\\d+)\\\\s+ # timestamp: Oct 8 07:02:22\n (?P<hostname>\\\\w+)\\\\s+ # hostname: mx1\n (?P<service>\\\\w+[/-]?)+ # service: amavis\n (?P<ser... |
#!/usr/bin/env python3
import gizeh
import moviepy.editor as mpy
import numpy as np
import midi
RGB = lambda hx: tuple(map(lambda c: int(c, 16) / 256, [hx[1:3], hx[3:5], hx[5:7]]))
is_ebony = lambda note: (note % 12) in [1, 3, 6, 8, 10]
is_ivory = lambda note: not is_ebony(note)
position = dict()
position.update({iv... | [
"gizeh.rectangle",
"gizeh.Surface",
"numpy.concatenate",
"midi.second2tick",
"numpy.arange"
] | [((850, 870), 'gizeh.Surface', 'gizeh.Surface', (['*size'], {}), '(*size)\n', (863, 870), False, 'import gizeh\n'), ((1776, 1796), 'gizeh.Surface', 'gizeh.Surface', (['*size'], {}), '(*size)\n', (1789, 1796), False, 'import gizeh\n'), ((1811, 1833), 'midi.second2tick', 'midi.second2tick', (['time'], {}), '(time)\n', (1... |
#! /usr/bin/env python3
import numpy as np
from sklearn.metrics import adjusted_rand_score as ari
from sklearn.preprocessing import LabelEncoder as labeler
import lsbm
## Import labels
lab = np.loadtxt('../data/drosophila_labels.csv', dtype=str)
lab = labeler().fit(lab).transform(lab)
## Import embeddings
X = np.loadt... | [
"sklearn.preprocessing.LabelEncoder",
"sklearn.cluster.AgglomerativeClustering",
"sklearn.mixture.GaussianMixture",
"lsbm.theta_transform",
"sknetwork.clustering.Louvain",
"sklearn.metrics.adjusted_rand_score",
"lsbm.row_normalise",
"sknetwork.hierarchy.LouvainHierarchy",
"numpy.random.seed",
"skn... | [((192, 246), 'numpy.loadtxt', 'np.loadtxt', (['"""../data/drosophila_labels.csv"""'], {'dtype': 'str'}), "('../data/drosophila_labels.csv', dtype=str)\n", (202, 246), True, 'import numpy as np\n'), ((312, 368), 'numpy.loadtxt', 'np.loadtxt', (['"""../data/drosophila_dase.csv"""'], {'delimiter': '""","""'}), "('../data... |
from flask import Blueprint, render_template
from requests import get
from plotly.utils import PlotlyJSONEncoder
import plotly.express as px
import pandas as pd
import numpy as np
import json
# Define Blueprint for U.S. specific data
usa_bp = Blueprint(
'usa',
__name__,
template_folder="templ... | [
"flask.render_template",
"json.dumps",
"requests.get",
"plotly.express.line",
"pandas.DataFrame",
"flask.Blueprint",
"pandas.concat"
] | [((255, 334), 'flask.Blueprint', 'Blueprint', (['"""usa"""', '__name__'], {'template_folder': '"""templates"""', 'static_folder': '"""static"""'}), "('usa', __name__, template_folder='templates', static_folder='static')\n", (264, 334), False, 'from flask import Blueprint, render_template\n'), ((672, 700), 'pandas.DataF... |
from django_partisan.settings.settings_models import QueueSettings
from django_partisan.settings import get_queue_settings
from django.test import TestCase
class TestQueueSettings(TestCase):
valid_settings = dict(
MIN_QUEUE_SIZE=10,
MAX_QUEUE_SIZE=20,
CHECKS_BEFORE_CLEANUP=50,
WORK... | [
"django_partisan.settings.settings_models.QueueSettings",
"django_partisan.settings.get_queue_settings"
] | [((551, 587), 'django_partisan.settings.settings_models.QueueSettings', 'QueueSettings', ([], {}), '(**self.valid_settings)\n', (564, 587), False, 'from django_partisan.settings.settings_models import QueueSettings\n'), ((791, 824), 'django_partisan.settings.settings_models.QueueSettings', 'QueueSettings', ([], {}), '(... |
import random
import time
from agora.retry.backoff import Backoff
class Strategy:
"""Determines whether or not an action should be retried. Strategies are allowed to delay or cause other side
effects.
"""
def should_retry(self, attempts: int, e: Exception) -> bool:
"""Returns whether or not... | [
"random.random",
"time.sleep"
] | [((2798, 2815), 'time.sleep', 'time.sleep', (['delay'], {}), '(delay)\n', (2808, 2815), False, 'import time\n'), ((3811, 3826), 'random.random', 'random.random', ([], {}), '()\n', (3824, 3826), False, 'import random\n')] |
import torch
import torch.nn as nn
import os
from .models import Darknet
from .utils.utils import non_max_suppression, rescale_boxes
class YoLov3HumanDetector(nn.Module):
def __init__(self, weights_path="weights/yolov3.weights",
conf_thres=0.8, nms_thres=0.4, img_size=416, device=torch.device("c... | [
"torch.load",
"os.path.join",
"os.path.dirname",
"torch.no_grad",
"torch.device"
] | [((305, 324), 'torch.device', 'torch.device', (['"""cpu"""'], {}), "('cpu')\n", (317, 324), False, 'import torch\n'), ((637, 688), 'os.path.join', 'os.path.join', (['model_def', '"""config"""', '"""yolov3-spp.cfg"""'], {}), "(model_def, 'config', 'yolov3-spp.cfg')\n", (649, 688), False, 'import os\n'), ((520, 545), 'os... |
#!/usr/bin/python3.2
import time
#Get the time
theTime=time.localtime()
theSecs=time.strftime("%S",theTime)
print("Secs: " + theSecs)
if int(theSecs)<10:
print("One digits")
theSecs=bin(int(theSecs))
theSecs=theSecs.lstrip('-0b')
print(theSecs)
print(str(len(theSecs)) + " Length")
for i in range(len(theSecs),... | [
"time.localtime",
"time.strftime"
] | [((57, 73), 'time.localtime', 'time.localtime', ([], {}), '()\n', (71, 73), False, 'import time\n'), ((83, 111), 'time.strftime', 'time.strftime', (['"""%S"""', 'theTime'], {}), "('%S', theTime)\n", (96, 111), False, 'import time\n')] |
import os
import re
import sys
import toml
from argparse import ArgumentParser
from .runner import Runner
from .cli import CLI
class RustRunner(Runner):
MOD_REGEX = re.compile(r'^\s*mod\s+(.*?);\s*$')
def reset(self):
self.modules = []
def make_code(self, file, filepath, filename):
fil... | [
"os.path.exists",
"argparse.ArgumentParser",
"re.compile",
"os.path.join",
"os.path.normpath",
"os.path.dirname",
"toml.load",
"sys.exit"
] | [((173, 210), 're.compile', 're.compile', (['"""^\\\\s*mod\\\\s+(.*?);\\\\s*$"""'], {}), "('^\\\\s*mod\\\\s+(.*?);\\\\s*$')\n", (183, 210), False, 'import re\n'), ((677, 707), 'os.path.normpath', 'os.path.normpath', (['module_name_'], {}), '(module_name_)\n', (693, 707), False, 'import os\n'), ((898, 925), 'os.path.exi... |
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 5 01:30:35 2020
@author: a
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import numpy as np
from torch.autograd import Function
from matplotlib import pyplot as plt
from itertools import product
EPS =... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"numpy.sqrt",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"torch.nn.Sequential",
"torch.exp",
"matplotlib.pyplot.fill_between",
"torch.pow",
"matplotlib.pyplot.contourf",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"torch.nn.init.zeros... | [((597, 623), 'torch.nn.Linear', 'nn.Linear', (['in_dim', 'hid_dim'], {}), '(in_dim, hid_dim)\n', (606, 623), True, 'import torch.nn as nn\n'), ((628, 696), 'torch.nn.init.normal_', 'nn.init.normal_', (['self.linear_in.weight'], {'std': '(1 / (4 * hid_dim) ** 0.5)'}), '(self.linear_in.weight, std=1 / (4 * hid_dim) ** 0... |
"""
Plot the relationship (mean of heads) for global Transformer.
Plot the relationship of local-transformer and global-transformer.
python3 plot_relation2.py --id 26 --point_id 10 --stage 0 --save
"""
import argparse
from matplotlib import pyplot
from mpl_toolkits.mplot3d import Axes3D
import random
import os
import n... | [
"argparse.ArgumentParser",
"data.ModelNet40",
"matplotlib.pyplot.close",
"matplotlib.pyplot.figure",
"sys.path.append",
"utils.set_seed",
"mpl_toolkits.mplot3d.Axes3D",
"matplotlib.pyplot.show"
] | [((402, 423), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (417, 423), False, 'import sys\n'), ((803, 838), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""training"""'], {}), "('training')\n", (826, 838), False, 'import argparse\n'), ((1366, 1381), 'matplotlib.pyplot.figure', 'pypl... |
import glob
import json
import os
import sys
def eprint(*args, **kwargs):
print(*args, file=sys.stderr, **kwargs)
def get_path_label(path):
if path.startswith('pipe:'):
return 'pipe'
if path.startswith('/workspace/'):
return 'src'
if path.startswith('/'):
return 'sys'
return 'src'
def collect_j... | [
"os.path.abspath",
"json.dumps",
"os.path.join",
"os.path.basename"
] | [((4267, 4297), 'os.path.join', 'os.path.join', (['sys.argv[1]', '"""*"""'], {}), "(sys.argv[1], '*')\n", (4279, 4297), False, 'import os\n'), ((4363, 4388), 'os.path.basename', 'os.path.basename', (['datadir'], {}), '(datadir)\n', (4379, 4388), False, 'import os\n'), ((376, 415), 'os.path.join', 'os.path.join', (['dat... |
class World(object):
pass
class Field(object):
pass
from typing import Union
import numpy as np
import random
import math
from tocenv.env import TOCEnv
import tocenv.components.item as items
import tocenv.components.agent as agent
import tocenv.components.skill as skills
import tocenv.components.block as... | [
"random.sample",
"tocenv.components.agent.PurpleAgent",
"tocenv.components.item.append",
"tocenv.components.item.Apple",
"tocenv.components.block.Block",
"tocenv.components.agent.BlueAgent",
"tocenv.components.position.Position",
"numpy.zeros",
"tocenv.components.agent.OrangeAgent",
"numpy.empty",... | [((854, 878), 'tocenv.components.position.Position', 'Position', ([], {'x': 'p1_x', 'y': 'p1_y'}), '(x=p1_x, y=p1_y)\n', (862, 878), False, 'from tocenv.components.position import Position\n'), ((897, 921), 'tocenv.components.position.Position', 'Position', ([], {'x': 'p2_x', 'y': 'p2_y'}), '(x=p2_x, y=p2_y)\n', (905, ... |
# -*- coding: utf-8 -*-
"""
Created on Sun Nov 14 21:24:02 2021
@author: JOSEP
"""
import pandas as pd
import numpy as np
import matplotlib
df = pd.read_csv("NFT_Sales.csv")
nft_df = df
nft_df.head()
nft_df["NaN"] = df.apply(lambda x: 1 if x.isna() else 0, axis=1)
missing_values = nft_df.isnull()
nft_df["NaN"] = mis... | [
"pandas.read_csv"
] | [((148, 176), 'pandas.read_csv', 'pd.read_csv', (['"""NFT_Sales.csv"""'], {}), "('NFT_Sales.csv')\n", (159, 176), True, 'import pandas as pd\n')] |
# Copyright 2013 Google Inc. All Rights Reserved.
"""This file can be executed directly to run the CLI or loaded as a module.
"""
import os
from googlecloudsdk.core import cli
_loader = cli.CLI(
name='sql',
command_root_directory=os.path.join(
cli.GoogleCloudSDKPackageRoot(),
'sql',
'... | [
"googlecloudsdk.core.cli.GoogleCloudSDKPackageRoot"
] | [((263, 294), 'googlecloudsdk.core.cli.GoogleCloudSDKPackageRoot', 'cli.GoogleCloudSDKPackageRoot', ([], {}), '()\n', (292, 294), False, 'from googlecloudsdk.core import cli\n')] |
from newspaper import Article
import random
import string
import nltk
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
import warnings
warnings.filterwarnings('ignore')
#Download the punkt package
nltk.download('punkt', quiet=True)
a... | [
"random.choice",
"sklearn.metrics.pairwise.cosine_similarity",
"nltk.download",
"sklearn.feature_extraction.text.CountVectorizer",
"nltk.sent_tokenize",
"newspaper.Article",
"warnings.filterwarnings"
] | [((220, 253), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (243, 253), False, 'import warnings\n'), ((283, 317), 'nltk.download', 'nltk.download', (['"""punkt"""'], {'quiet': '(True)'}), "('punkt', quiet=True)\n", (296, 317), False, 'import nltk\n'), ((329, 436), 'newspa... |
import requests
from bs4 import BeautifulSoup
LIMIT = 50
INDEED_URL = f'https://www.indeed.com/jobs?as_and=python&limit={LIMIT}'
if __name__ == '__main__':
indeed_results = requests.get(INDEED_URL)
indeed_soup = BeautifulSoup(indeed_results.text, 'html.parser')
pagination = indeed_soup.find("div", class_... | [
"bs4.BeautifulSoup",
"requests.get"
] | [((180, 204), 'requests.get', 'requests.get', (['INDEED_URL'], {}), '(INDEED_URL)\n', (192, 204), False, 'import requests\n'), ((223, 272), 'bs4.BeautifulSoup', 'BeautifulSoup', (['indeed_results.text', '"""html.parser"""'], {}), "(indeed_results.text, 'html.parser')\n", (236, 272), False, 'from bs4 import BeautifulSou... |
from django.conf.urls import url
import views
urlpatterns = [
url(r'^$', views.index),
url(r'^register$', views.register),
url(r'^login$', views.login),
url(r'^dashboard', views.dashboard),
url(r'^logout', views.logout),
url(r'^', views.index),
]
| [
"django.conf.urls.url"
] | [((67, 89), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.index'], {}), "('^$', views.index)\n", (70, 89), False, 'from django.conf.urls import url\n'), ((96, 129), 'django.conf.urls.url', 'url', (['"""^register$"""', 'views.register'], {}), "('^register$', views.register)\n", (99, 129), False, 'from django.conf.... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Tests for nussl/utils.py
"""
import unittest
import nussl
import numpy as np
from scipy import signal
class TestUtils(unittest.TestCase):
"""
"""
def test_find_peak_indices(self):
array = np.arange(0, 100)
peak = nussl.find_peak_indices(a... | [
"numpy.ones",
"numpy.equal",
"numpy.array",
"nussl.find_peak_values",
"nussl.find_peak_indices",
"nussl.add_mismatched_arrays",
"numpy.arange"
] | [((262, 279), 'numpy.arange', 'np.arange', (['(0)', '(100)'], {}), '(0, 100)\n', (271, 279), True, 'import numpy as np\n'), ((424, 469), 'nussl.find_peak_indices', 'nussl.find_peak_indices', (['array', '(3)'], {'min_dist': '(0)'}), '(array, 3, min_dist=0)\n', (447, 469), False, 'import nussl\n'), ((572, 589), 'numpy.ar... |
#
# COPYRIGHT (C) 2002-2011 <NAME>
#
"""
.. module:: dbconfig
:platform: Unix, Windows, MacOSX
:synopsis: Configuration for Database connections
.. moduleauthor:: <NAME> (<EMAIL>); modified by <EMAIL>
The module defines a dictionary *DBCONFIG* that provides the parameters needed
to connect to various database... | [
"gcn.config.lib_config.gcn_path",
"os.path.join"
] | [((1308, 1341), 'gcn.config.lib_config.gcn_path', 'lib_config.gcn_path', (['"""GCN_DB_DIR"""'], {}), "('GCN_DB_DIR')\n", (1327, 1341), False, 'from gcn.config import lib_config\n'), ((1506, 1540), 'os.path.join', 'os.path.join', (['_LOCALDIR', '"""refmrna"""'], {}), "(_LOCALDIR, 'refmrna')\n", (1518, 1540), False, 'imp... |
import webapp2
from google.appengine.ext import ndb
from google.appengine.api import users
from datetime import datetime
import time
import re
import base_handler
import logging
import matches
import winners
import clubs
import tourneys
import players
import handicap
import signup
class DataStore(webapp2.RequestHan... | [
"winners.Winner",
"players.Player",
"matches.Match.query",
"clubs.Club.get_by_id",
"google.appengine.ext.ndb.AND",
"google.appengine.api.users.get_current_user",
"logging.info",
"google.appengine.api.users.create_login_url",
"signup.Signup.query",
"tourneys.Tourney",
"signup.Signup",
"matches.... | [((18285, 18781), 'webapp2.WSGIApplication', 'webapp2.WSGIApplication', (["[('/Match/', DataStore), ('/Winner/', WinnerStore), ('/Config/(.*)', Config\n ), ('/Create/', Create), ('/Invite/', Invite), ('/Race/', Race), ('/',\n IndexHandler), ('/Tourney/(.*)/create', CreateTourneyHandler), (\n '/Tourney/(.*)/(.*... |
# Generated by Django 3.0.8 on 2020-09-13 14:43
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('site_settings', '0004_si... | [
"django.db.models.FloatField",
"django.db.migrations.RemoveField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
] | [((227, 284), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (258, 284), False, 'from django.db import migrations, models\n'), ((456, 526), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name... |
# Generated by Django 3.1.13 on 2021-10-06 19:21
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('users', '0002_user_user_type'),
]
operations = [
migrations.CreateModel(
... | [
"django.db.models.DateTimeField",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((392, 485), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (408, 485), False, 'from django.db import migrations, models\... |
"""Change from the previous keywords to the new ones.
For each `videos` record, switch from one of the previous keywords to the new ones.
Requirements: kinto_http
$ pip install kinto_http
To use: run the following
$ python 009_videos_freeform_keywords.py --auth "<admin login>:<admin password>" --server "https://<k... | [
"collections_metadata.update_videos",
"kinto_http.cli_utils.create_client_from_args",
"kinto_http.cli_utils.add_parser_options"
] | [((2264, 2465), 'kinto_http.cli_utils.add_parser_options', 'cli_utils.add_parser_options', ([], {'description': '"""Switch from the previous keywords to the new ones for the `videos` collection"""', 'default_bucket': 'DEFAULT_BUCKET', 'default_collection': 'DEFAULT_COLLECTION'}), "(description=\n 'Switch from the pr... |
# python clone of tagtime http://messymatters.com/tagtime/
# set cron job with $crontab -e
# * * * * * DISPLAY=:1 python3 /path/to/prompt.py 2> /tmp/err
# this fires once a minute
# set debugging = True first to make sure cron job fires
# check /tmp/err for problems if it doesn't fire
# or use a cron alternative as ... | [
"datetime.datetime.now",
"time.time",
"numpy.random.exponential",
"pymsgbox.prompt"
] | [((877, 900), 'pymsgbox.prompt', 'pymsgbox.prompt', (['prompt'], {}), '(prompt)\n', (892, 900), False, 'import pymsgbox\n'), ((1155, 1190), 'numpy.random.exponential', 'numpy.random.exponential', (['avg_delay'], {}), '(avg_delay)\n', (1179, 1190), False, 'import numpy\n'), ((726, 737), 'time.time', 'time.time', ([], {}... |
import torch
import torch.nn.functional as F
def aggregate_sbg(prob, keep_bg=False, hard=False):
device = prob.device
k, _, h, w = prob.shape
ex_prob = torch.zeros((k+1, 1, h, w), device=device)
ex_prob[0] = 0.5
ex_prob[1:] = prob
ex_prob = torch.clamp(ex_prob, 1e-7, 1-1e-7)
logits = torch.... | [
"torch.log",
"torch.prod",
"torch.zeros",
"torch.nn.functional.softmax",
"torch.clamp"
] | [((165, 209), 'torch.zeros', 'torch.zeros', (['(k + 1, 1, h, w)'], {'device': 'device'}), '((k + 1, 1, h, w), device=device)\n', (176, 209), False, 'import torch\n'), ((266, 304), 'torch.clamp', 'torch.clamp', (['ex_prob', '(1e-07)', '(1 - 1e-07)'], {}), '(ex_prob, 1e-07, 1 - 1e-07)\n', (277, 304), False, 'import torch... |
# Copyright 2022 Open Source Robotics Foundation, Inc.
# Licensed under the Apache License, Version 2.0
import os
from colcon_core.dependency_descriptor import DependencyDescriptor
from colcon_core.location import get_relative_package_index_path
from colcon_core.package_augmentation \
import PackageAugmentationEx... | [
"colcon_core.location.get_relative_package_index_path",
"colcon_core.dependency_descriptor.DependencyDescriptor",
"colcon_core.plugin_system.satisfies_version"
] | [((882, 970), 'colcon_core.plugin_system.satisfies_version', 'satisfies_version', (['PackageAugmentationExtensionPoint.EXTENSION_POINT_VERSION', '"""^1.0"""'], {}), "(PackageAugmentationExtensionPoint.EXTENSION_POINT_VERSION,\n '^1.0')\n", (899, 970), False, 'from colcon_core.plugin_system import satisfies_version\n... |
# -*- coding: utf-8 -*-
#__author__="ZJL"
from flask import Flask
from flask import request
from flask import Response
import json
app = Flask(__name__)
def Response_headers(content):
resp = Response(content)
resp.headers['Access-Control-Allow-Origin'] = '*'
return resp
@app.route('/')
def hello_worl... | [
"json.dumps",
"flask.Response",
"flask.Flask"
] | [((140, 155), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (145, 155), False, 'from flask import Flask\n'), ((200, 217), 'flask.Response', 'Response', (['content'], {}), '(content)\n', (208, 217), False, 'from flask import Response\n'), ((981, 998), 'json.dumps', 'json.dumps', (['datas'], {}), '(datas)\n... |
'''
Code from my DenseNet repository : https://github.com/titu1994/DenseNet
'''
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Dense, Dropout, Activation
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import AveragePooling2D
from tensorflow.keras.layers import Gl... | [
"tensorflow.keras.layers.Input",
"tensorflow.keras.layers.Concatenate",
"tensorflow.keras.layers.Dropout",
"tensorflow.keras.layers.AveragePooling2D",
"tensorflow.keras.models.Model",
"tensorflow.keras.layers.Activation",
"tensorflow.keras.layers.GlobalAveragePooling2D",
"tensorflow.keras.backend.imag... | [((3946, 3966), 'tensorflow.keras.layers.Input', 'Input', ([], {'shape': 'img_dim'}), '(shape=img_dim)\n', (3951, 3966), False, 'from tensorflow.keras.layers import Input, Concatenate\n'), ((5306, 5367), 'tensorflow.keras.models.Model', 'Model', ([], {'inputs': 'model_input', 'outputs': 'x', 'name': '"""create_dense_ne... |
from http import HTTPStatus
import responses
from lighthouse.helpers.labwhere import get_locations_from_labwhere, set_locations_in_labwhere
def test_get_locations_from_labwhere(app, labwhere_samples_simple):
with app.app_context():
response = get_locations_from_labwhere(["plate_123"])
assert re... | [
"responses.json_params_matcher",
"lighthouse.helpers.labwhere.set_locations_in_labwhere",
"lighthouse.helpers.labwhere.get_locations_from_labwhere"
] | [((259, 301), 'lighthouse.helpers.labwhere.get_locations_from_labwhere', 'get_locations_from_labwhere', (["['plate_123']"], {}), "(['plate_123'])\n", (286, 301), False, 'from lighthouse.helpers.labwhere import get_locations_from_labwhere, set_locations_in_labwhere\n'), ((1308, 1369), 'lighthouse.helpers.labwhere.set_lo... |
from fastapi import APIRouter
from .api.v1.job import router as job_router
from .api.v1.record import router as record_router
router = APIRouter()
router.include_router(job_router)
router.include_router(record_router) | [
"fastapi.APIRouter"
] | [((136, 147), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (145, 147), False, 'from fastapi import APIRouter\n')] |
# Generated by Django 3.0.3 on 2020-02-22 06:29
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('crime', '0003_area'),
]
operations = [
migrations.CreateModel(
name='complaint_details',
fields=[
('... | [
"django.db.models.ImageField",
"django.db.models.EmailField",
"django.db.models.AutoField",
"django.db.models.CharField"
] | [((989, 1020), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (1005, 1020), False, 'from django.db import migrations, models\n'), ((1141, 1172), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (1157, 1172), False,... |
#!usr/bin/env python
#coding:utf8
from nltk.tokenize import TweetTokenizer
from nltk.stem.cistem import Cistem
from nltk.corpus import stopwords
import nltk
from sklearn.feature_extraction.text import CountVectorizer
import matplotlib.pyplot as plt
from wordcloud import WordCloud
from pathlib import Path
from sklearn.c... | [
"matplotlib.pyplot.imshow",
"sklearn.cluster.KMeans",
"nltk.tokenize.TweetTokenizer",
"matplotlib.pyplot.savefig",
"nltk.stem.cistem.Cistem",
"nltk.download",
"pathlib.Path",
"sklearn.feature_extraction.text.CountVectorizer",
"nltk.corpus.stopwords.words",
"matplotlib.pyplot.clf",
"sklearn.manif... | [((376, 402), 'nltk.download', 'nltk.download', (['"""stopwords"""'], {}), "('stopwords')\n", (389, 402), False, 'import nltk\n'), ((410, 426), 'nltk.tokenize.TweetTokenizer', 'TweetTokenizer', ([], {}), '()\n', (424, 426), False, 'from nltk.tokenize import TweetTokenizer\n'), ((437, 449), 'nltk.stem.cistem.Cistem', 'C... |
from matplotlib import pyplot as plt # Pyplot for nice graphs
import numpy as np # NumPy
from numpy import linalg as LA
from Functions import ImportSystem
from progress.bar import Bar
# Retrieve unit cell
xyz, shiftx, shifty, filename = ImportSystem(1)
repx = int(input('Repetition in x? '))
r... | [
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"Functions.ImportSystem",
"numpy.subtract",
"numpy.append",
"numpy.array",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.show"
] | [((263, 278), 'Functions.ImportSystem', 'ImportSystem', (['(1)'], {}), '(1)\n', (275, 278), False, 'from Functions import ImportSystem\n'), ((705, 723), 'numpy.array', 'np.array', (['[[0, 0]]'], {}), '([[0, 0]])\n', (713, 723), True, 'import numpy as np\n'), ((731, 749), 'numpy.array', 'np.array', (['[[0, 0]]'], {}), '... |
from import_lib import lib
from tensor.main_module import Tensor
from cnn.struct.layer_module import Layer
from ctypes import Structure, c_int, POINTER
def createReluLayer():
return lib.cnn_create_relu_layer()
#lib.cnn_create_relu_layer.argtypes = (Layer, Layer)
lib.cnn_create_relu_layer.restype = Layer
| [
"import_lib.lib.cnn_create_relu_layer"
] | [((187, 214), 'import_lib.lib.cnn_create_relu_layer', 'lib.cnn_create_relu_layer', ([], {}), '()\n', (212, 214), False, 'from import_lib import lib\n')] |
from collections import namedtuple, defaultdict, deque
from contextlib import contextmanager
from bits import *
Anchor = namedtuple('Anchor', ['symbol', 'stars'])
Star = namedtuple('Star', ['row', 'col', 'offsets', 'link', 'symbol'])
Structure = namedtuple('Structure', ['anchors', 'stars', 'shapes', 'tables'])
# nu... | [
"collections.namedtuple",
"collections.defaultdict"
] | [((124, 165), 'collections.namedtuple', 'namedtuple', (['"""Anchor"""', "['symbol', 'stars']"], {}), "('Anchor', ['symbol', 'stars'])\n", (134, 165), False, 'from collections import namedtuple, defaultdict, deque\n'), ((173, 236), 'collections.namedtuple', 'namedtuple', (['"""Star"""', "['row', 'col', 'offsets', 'link'... |
#!/usr/bin/env python
"""
Test the model build
"""
from cfgmdl import Model, Property, Derived, Ref
from collections import OrderedDict as odict
def test_ref():
class TestClass(Model):
x = Property(dtype=float, default=1., help='variable x')
y = Property(dtype=float, default=2., help='v... | [
"cfgmdl.Ref",
"cfgmdl.Derived",
"cfgmdl.Property"
] | [((214, 267), 'cfgmdl.Property', 'Property', ([], {'dtype': 'float', 'default': '(1.0)', 'help': '"""variable x"""'}), "(dtype=float, default=1.0, help='variable x')\n", (222, 267), False, 'from cfgmdl import Model, Property, Derived, Ref\n'), ((279, 332), 'cfgmdl.Property', 'Property', ([], {'dtype': 'float', 'default... |
from django.conf.urls import url
from . import views
app_name = "user_feedback"
def flow_patterns():
return [url(r"^post", views.post_feedback_json, name="post")]
urlpatterns = sum([flow_patterns()], [])
| [
"django.conf.urls.url"
] | [((118, 169), 'django.conf.urls.url', 'url', (['"""^post"""', 'views.post_feedback_json'], {'name': '"""post"""'}), "('^post', views.post_feedback_json, name='post')\n", (121, 169), False, 'from django.conf.urls import url\n')] |
from examples.contacts import PARSER, EXPECTED
class Test_Contacts(object):
def test_contacs_output(self):
output = PARSER.parse()
assert output == EXPECTED
| [
"examples.contacts.PARSER.parse"
] | [((130, 144), 'examples.contacts.PARSER.parse', 'PARSER.parse', ([], {}), '()\n', (142, 144), False, 'from examples.contacts import PARSER, EXPECTED\n')] |
import os
import cv2 as cv
import numpy as np
import tensorflow as tf
CWD_PATH = os.getcwd()
MODEL_NAME = "scribbler_graph_board_v3/"
# PATH_TO_CKPT = '{}frozen_inference_graph.pb'.format(MODEL_NAME)
PATH_TO_CKPT = "{}opt_graph.pb".format(MODEL_NAME)
PATH_TO_LABELS = "object-detection.pbtxt"
cvNet = cv.dnn.readNetF... | [
"cv2.dnn.blobFromImage",
"cv2.dnn.readNetFromTensorflow",
"cv2.imshow",
"os.getcwd",
"cv2.waitKey",
"cv2.imread"
] | [((84, 95), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (93, 95), False, 'import os\n'), ((305, 362), 'cv2.dnn.readNetFromTensorflow', 'cv.dnn.readNetFromTensorflow', (['PATH_TO_CKPT', '"""graph.pbtxt"""'], {}), "(PATH_TO_CKPT, 'graph.pbtxt')\n", (333, 362), True, 'import cv2 as cv\n'), ((370, 394), 'cv2.imread', 'cv.i... |
import dash_html_components as html
import dash_vtk
from dash_docs import tools
from dash_docs import styles
from dash_docs import reusable_components as rc
examples = tools.load_examples(__file__)
layout = html.Div([
rc.Markdown('''
# Click and Hover Callbacks
It's possible to create callbacks based on ... | [
"dash_docs.reusable_components.Markdown",
"dash_docs.tools.load_examples",
"dash_html_components.Div",
"dash_html_components.Summary"
] | [((169, 198), 'dash_docs.tools.load_examples', 'tools.load_examples', (['__file__'], {}), '(__file__)\n', (188, 198), False, 'from dash_docs import tools\n'), ((224, 1644), 'dash_docs.reusable_components.Markdown', 'rc.Markdown', (['"""\n # Click and Hover Callbacks\n\n It\'s possible to create callbacks based on... |
import socketio
import time
import psutil
from util import path2title, get_interface
from termcolor import colored
SERVER_ADDR = "localhost"
ARGS = {}
# this is used internally by ServerConnection
class VLC_signals(socketio.ClientNamespace):
def bind(self):
""" Binds the player instance to this class in... | [
"util.print_qr",
"termcolor.colored",
"util.print_url",
"util.path2title",
"util.get_interface",
"time.time",
"socketio.Client",
"psutil.net_if_addrs"
] | [((1912, 1926), 'util.print_url', 'print_url', (['url'], {}), '(url)\n', (1921, 1926), False, 'from util import print_url\n'), ((2219, 2236), 'socketio.Client', 'socketio.Client', ([], {}), '()\n', (2234, 2236), False, 'import socketio\n'), ((630, 651), 'termcolor.colored', 'colored', (['data', '"""blue"""'], {}), "(da... |
from keras.models import Sequential
from keras.layers import BatchNormalization, Dense, Dropout, Flatten
from keras.layers.convolutional import Conv1D
from keras.layers.recurrent import LSTM
from keras.layers.pooling import MaxPool1D
from keras.regularizers import l2
def conv_lstm(num_of_window, coefficient_vector_si... | [
"keras.layers.pooling.MaxPool1D",
"keras.layers.Flatten",
"keras.regularizers.l2",
"keras.layers.Dense",
"keras.layers.BatchNormalization",
"keras.layers.Dropout"
] | [((718, 729), 'keras.layers.pooling.MaxPool1D', 'MaxPool1D', ([], {}), '()\n', (727, 729), False, 'from keras.layers.pooling import MaxPool1D\n'), ((739, 756), 'keras.layers.Dropout', 'Dropout', ([], {'rate': '(0.1)'}), '(rate=0.1)\n', (746, 756), False, 'from keras.layers import BatchNormalization, Dense, Dropout, Fla... |
import pytest
from pystratis.nodes import CirrusMinerNode
from pystratis.core.types import Money, Address
@pytest.mark.integration_test
@pytest.mark.cirrus_integration_test
def test_over_amount_at_height(cirrusminer_node: CirrusMinerNode):
response = cirrusminer_node.balances.over_amount_at_height(block_height=10... | [
"pystratis.core.types.Money"
] | [((329, 337), 'pystratis.core.types.Money', 'Money', (['(1)'], {}), '(1)\n', (334, 337), False, 'from pystratis.core.types import Money, Address\n')] |
import pathlib
import tempfile
import cairo
from gi.repository import Pango, PangoCairo
from Definitions import *
import subprocess
import Colour
end_cap_round = object()
class Canvas:
def __init__(self, corner, width, height, surface=None, context=None):
"""Create a new drawing surface.
corne... | [
"cairo.PSSurface",
"pathlib.Path",
"cairo.Context",
"subprocess.run",
"gi.repository.PangoCairo.show_layout",
"gi.repository.PangoCairo.create_layout",
"tempfile.NamedTemporaryFile",
"cairo.Rectangle",
"cairo.ImageSurface.create_from_png"
] | [((7851, 7884), 'gi.repository.PangoCairo.create_layout', 'PangoCairo.create_layout', (['context'], {}), '(context)\n', (7875, 7884), False, 'from gi.repository import Pango, PangoCairo\n'), ((9176, 9215), 'gi.repository.PangoCairo.show_layout', 'PangoCairo.show_layout', (['context', 'layout'], {}), '(context, layout)\... |
import tensorflow as tf
class Loss(object):
@classmethod
def gram_matrix(cls, arr):
"""Gramian matrix for calculating style loss"""
x = tf.transpose(arr, (2, 0, 1))
features = tf.reshape(x, (tf.shape(x)[0], -1))
gram = tf.matmul(features, tf.transpose(features))
return gram
@classmetho... | [
"tensorflow.shape",
"tensorflow.transpose",
"tensorflow.square"
] | [((153, 181), 'tensorflow.transpose', 'tf.transpose', (['arr', '(2, 0, 1)'], {}), '(arr, (2, 0, 1))\n', (165, 181), True, 'import tensorflow as tf\n'), ((264, 286), 'tensorflow.transpose', 'tf.transpose', (['features'], {}), '(features)\n', (276, 286), True, 'import tensorflow as tf\n'), ((451, 481), 'tensorflow.square... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import data_manager
class Attention(nn.Module):
def __init__(self, device, w2v_weights, decoder_embedding_size, hidden_dim, tagset_size, drop_rate=0.5, bidirectional=False,
freeze=True, max_norm_emb1=10, max_norm_emb2=1, padded_... | [
"torch.nn.BatchNorm2d",
"torch.nn.Dropout",
"torch.cat",
"torch.zeros",
"torch.add",
"data_manager.batch_sequence",
"torch.nn.Linear",
"torch.nn.LogSoftmax",
"torch.bmm",
"torch.nn.functional.relu",
"torch.FloatTensor",
"torch.nn.Embedding",
"torch.nn.GRU"
] | [((1871, 1897), 'torch.nn.Dropout', 'nn.Dropout', (['self.drop_rate'], {}), '(self.drop_rate)\n', (1881, 1897), True, 'import torch.nn as nn\n'), ((2241, 2371), 'torch.nn.GRU', 'nn.GRU', (['self.embedding_dim', '(self.hidden_dim // (1 if not bidirectional else 2))'], {'batch_first': '(True)', 'bidirectional': 'bidirect... |
import re
from datetime import datetime
from boto3 import Session
from moto.core import BaseBackend
from moto.core.utils import iso_8601_datetime_without_milliseconds
from moto.sts.models import ACCOUNT_ID
from uuid import uuid4
from .exceptions import (
InvalidArn,
InvalidName,
WorkspaceDoesNotExist,
)
... | [
"boto3.Session",
"random.choice",
"re.compile"
] | [((981, 1041), 're.compile', 're.compile', (['"""arn:aws:iam::(?P<account_id>[0-9]{12}):role/.+"""'], {}), "('arn:aws:iam::(?P<account_id>[0-9]{12}):role/.+')\n", (991, 1041), False, 'import re\n'), ((2652, 2661), 'boto3.Session', 'Session', ([], {}), '()\n', (2659, 2661), False, 'from boto3 import Session\n'), ((2771,... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from visdom import Visdom
import numpy as np
import math
import os.path
import getpass
from sys import platform as _platform
from six.moves import urllib
vi... | [
"numpy.array",
"visdom.Visdom"
] | [((324, 353), 'visdom.Visdom', 'Visdom', ([], {'port': '(8098)', 'env': '"""main"""'}), "(port=8098, env='main')\n", (330, 353), False, 'from visdom import Visdom\n'), ((426, 442), 'numpy.array', 'np.array', (['[0, 1]'], {}), '([0, 1])\n', (434, 442), True, 'import numpy as np\n'), ((449, 465), 'numpy.array', 'np.array... |
"""
day 24 of Advent of Code 2018
by <NAME>
"""
from copy import deepcopy
from dataclasses import dataclass
from enum import Enum
import heapq
from itertools import chain
import re
BOOST = 0
class Team(Enum):
IMMUNE = 0
INFECTION = 1
class AttackType(Enum):
FIRE = 0
BLUDGEONING = 1
SLASHING = 2
... | [
"itertools.chain",
"dataclasses.dataclass",
"re.findall",
"heapq.heappop",
"copy.deepcopy",
"heapq.heappush",
"re.search"
] | [((353, 375), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (362, 375), False, 'from dataclasses import dataclass\n'), ((429, 451), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (438, 451), False, 'from dataclasses import dataclass\n'), ((540... |
import random
from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware
from joblib import load
import pandas as pd
from pydantic import BaseModel, confloat
description = """
Deploys a K Nearest Neighbor Model fit on the [Spotify](https://www.kaggle.com/yamaerenay/spotify-dataset-19212020-160k-tr... | [
"pydantic.confloat",
"fastapi.FastAPI",
"random.choice",
"joblib.load"
] | [((989, 1074), 'fastapi.FastAPI', 'FastAPI', ([], {'title': '"""Spotfy Song redictor API"""', 'description': 'description', 'docs_url': '"""/"""'}), "(title='Spotfy Song redictor API', description=description, docs_url='/'\n )\n", (996, 1074), False, 'from fastapi import FastAPI\n'), ((1191, 1220), 'joblib.load', 'l... |
import torch
import torch.nn as nn
from torch.utils.data import Dataset
import numpy as np
RICO_LABELS_LOWER = [
'text',
'image',
'icon',
'list item',
'text button',
'toolbar',
'web view',
'input',
'card',
'advertisement',
... | [
"torch.nn.TransformerEncoder",
"torch.nn.Embedding",
"torch.rand",
"pickle.load",
"torch.relu",
"numpy.array",
"numpy.zeros",
"torch.nn.Linear",
"copy.deepcopy",
"torch.nn.TransformerEncoderLayer",
"torch.zeros",
"torch.cat",
"torch.randn"
] | [((8072, 8099), 'copy.deepcopy', 'deepcopy', (['label_with_number'], {}), '(label_with_number)\n', (8080, 8099), False, 'from copy import deepcopy\n'), ((8116, 8131), 'copy.deepcopy', 'deepcopy', (['label'], {}), '(label)\n', (8124, 8131), False, 'from copy import deepcopy\n'), ((1912, 1959), 'numpy.zeros', 'np.zeros',... |
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed unde... | [
"mock.Mock",
"mock.patch.object",
"senlin.tests.unit.common.utils.dummy_context",
"senlin.engine.actions.cluster_action.ClusterAction",
"mock.call"
] | [((816, 853), 'mock.patch.object', 'mock.patch.object', (['cm.Cluster', '"""load"""'], {}), "(cm.Cluster, 'load')\n", (833, 853), False, 'import mock\n'), ((1020, 1065), 'mock.patch.object', 'mock.patch.object', (['ca.ClusterAction', '"""_sleep"""'], {}), "(ca.ClusterAction, '_sleep')\n", (1037, 1065), False, 'import m... |
"""
Octave
======
Module for working with octaves.
The following is an example on how to use :class:`acoustics.octave.Octave`.
.. literalinclude:: ../examples/octave.py
"""
from __future__ import division
import numpy as np
REFERENCE = 1000.0
"""
Reference frequency.
"""
def band_of_frequency(f, order=1, ref=REF... | [
"numpy.array",
"numpy.log2"
] | [((550, 566), 'numpy.log2', 'np.log2', (['(f / ref)'], {}), '(f / ref)\n', (557, 566), True, 'import numpy as np\n'), ((3467, 3478), 'numpy.array', 'np.array', (['x'], {}), '(x)\n', (3475, 3478), True, 'import numpy as np\n')] |
from django.conf.urls import url
from . import views
urlpatterns = [
url(r'^$', views.validation_form, name='validation_form'),
]
| [
"django.conf.urls.url"
] | [((74, 130), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.validation_form'], {'name': '"""validation_form"""'}), "('^$', views.validation_form, name='validation_form')\n", (77, 130), False, 'from django.conf.urls import url\n')] |
import asyncio
import elasticsearch
import json
import logging
import requests
import time
from urllib.parse import urlencode
from datamart_core import Discoverer
from datamart_core.common import setup_logging
logger = logging.getLogger(__name__)
class ZenodoDiscoverer(Discoverer):
EXTENSIONS = ('.xls', '.xlsx... | [
"logging.getLogger",
"requests.get",
"time.sleep",
"json.load",
"datamart_core.common.setup_logging",
"asyncio.get_event_loop"
] | [((222, 249), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (239, 249), False, 'import logging\n'), ((5217, 5232), 'datamart_core.common.setup_logging', 'setup_logging', ([], {}), '()\n', (5230, 5232), False, 'from datamart_core.common import setup_logging\n'), ((543, 556), 'json.load', ... |
from setuptools import find_packages, setup
setup(
name='src',
packages=find_packages(),
version='0.1.0',
description='The project deals with the competition in Professor Iddo Drori class. In the project, we will be predicitng the pm2.5 level for the competition. ',
author='<NAME>',
license='MI... | [
"setuptools.find_packages"
] | [((81, 96), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (94, 96), False, 'from setuptools import find_packages, setup\n')] |
from django.contrib import admin
from .models import *
# Register your models here.
admin.site.register(Instructor)
class InstructorAdmin(admin.ModelAdmin):
list_display = ['instructor_name ']
admin.site.register(Category)
class CategoryAdmin(admin.ModelAdmin):
list_display = ['name','slug']
prepop... | [
"django.contrib.admin.site.register"
] | [((84, 115), 'django.contrib.admin.site.register', 'admin.site.register', (['Instructor'], {}), '(Instructor)\n', (103, 115), False, 'from django.contrib import admin\n'), ((205, 234), 'django.contrib.admin.site.register', 'admin.site.register', (['Category'], {}), '(Category)\n', (224, 234), False, 'from django.contri... |
from django.shortcuts import render,get_object_or_404,redirect
from django.http import HttpResponse
from django.contrib.auth.decorators import login_required
from django.contrib import auth
from django.contrib.auth import authenticate, login, logout
from django.conf import settings
from django.db.models import Count,Ma... | [
"django.shortcuts.render",
"django.contrib.auth.authenticate",
"apps.paginacion.paginacion",
"axes.models.AccessAttempt.objects.filter",
"axes.models.AccessAttempt.objects.all",
"django.db.models.Count",
"django.http.HttpResponse",
"axes.models.AccessAttempt.objects.get",
"time.strftime",
"django.... | [((625, 648), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (646, 648), False, 'import datetime, time\n'), ((694, 719), 'time.strftime', 'time.strftime', (['"""%H:%M:%S"""'], {}), "('%H:%M:%S')\n", (707, 719), False, 'import datetime, time\n'), ((2267, 2296), 'django.contrib.auth.decorators.login_... |
#!/usr/bin/env python
"""
================================================
ABElectronics Servo Pi pwm controller | PWM servo controller demo
run with: python demo_servomove.py
================================================
This demo shows how to set the limits of movement on a servo
and then move between those positi... | [
"sys.path.append",
"ServoPi.Servo",
"time.sleep"
] | [((1028, 1038), 'ServoPi.Servo', 'Servo', (['(111)'], {}), '(111)\n', (1033, 1038), False, 'from ServoPi import Servo\n'), ((730, 751), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (745, 751), False, 'import sys\n'), ((2267, 2280), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (2277, 2280... |
import os
from time_lapse import make_movie
NAME = os.path.basename(__file__).replace('.py', '')
PATTERNS = [
'/Volumes/Falcon/tl_temp/130305_1/*.tiff', # ARN_038167 - ARN_038476
'/Volumes/Falcon/tl_temp/130305_2/*.tiff', # ARN_038495 - ARN_039026
]
# poster: ARN_038262
if __name__ == '__main__':
make... | [
"os.path.basename",
"time_lapse.make_movie"
] | [((316, 395), 'time_lapse.make_movie', 'make_movie', (['NAME', 'PATTERNS', '(48)', '(10)'], {'watermark': '(True)', 'verbose': '(False)', 'dryrun': '(False)'}), '(NAME, PATTERNS, 48, 10, watermark=True, verbose=False, dryrun=False)\n', (326, 395), False, 'from time_lapse import make_movie\n'), ((53, 79), 'os.path.basen... |
#!/usr/bin/env python3
import os
import sys
if len(sys.argv) != 2:
print ("\nUsage:\n\t%s instance-id\n\n" % sys.argv[0])
exit(0)
os.system('apt update')
os.system('apt -y install nginx')
os.system('systemctl enable --now nginx')
instance_id = sys.argv[1]
print ("Instance id: ", instance_id)
index_file = "/var... | [
"os.system"
] | [((137, 160), 'os.system', 'os.system', (['"""apt update"""'], {}), "('apt update')\n", (146, 160), False, 'import os\n'), ((161, 194), 'os.system', 'os.system', (['"""apt -y install nginx"""'], {}), "('apt -y install nginx')\n", (170, 194), False, 'import os\n'), ((195, 236), 'os.system', 'os.system', (['"""systemctl ... |
import torch
from torch import Tensor
from torch.nn import Module
class ExponentialMovingAverage(Module):
def __init__(self, *size: int, momentum: float = 0.995):
super(ExponentialMovingAverage, self).__init__()
self.register_buffer("average", torch.ones(*size))
self.register_buffer("init... | [
"torch.no_grad",
"torch.tensor",
"torch.ones"
] | [((390, 405), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (403, 405), False, 'import torch\n'), ((267, 284), 'torch.ones', 'torch.ones', (['*size'], {}), '(*size)\n', (277, 284), False, 'import torch\n'), ((330, 349), 'torch.tensor', 'torch.tensor', (['(False)'], {}), '(False)\n', (342, 349), False, 'import tor... |
#!/usr/bin/env python3
#
# Display download URL of a Firefox addon for Windows.
#
# Usage: ./parse-html.py adblock-plus
import sys
import urllib.request
from bs4 import BeautifulSoup
firefox_addon = 'https://addons.mozilla.org'
en_us_addons = firefox_addon + '/en-US/firefox/addon/'
page = urllib.request.urlopen(en_u... | [
"bs4.BeautifulSoup"
] | [((370, 389), 'bs4.BeautifulSoup', 'BeautifulSoup', (['html'], {}), '(html)\n', (383, 389), False, 'from bs4 import BeautifulSoup\n')] |
"""Ansible module for managing blueprints."""
#!/usr/bin/python
# Copyright: (c) 2022, <NAME> (@cdot65) <<EMAIL>>
from __future__ import absolute_import, division, print_function
from traceback import format_exc
from ansible.module_utils.basic import AnsibleModule # pylint: disable=import-error
from ansible_collectio... | [
"traceback.format_exc",
"ansible.module_utils.basic.AnsibleModule",
"ansible_collections.cdot65.apstra.plugins.module_utils.apstra.api.ApstraHelper.blueprint_spec",
"ansible.module_utils._text.to_native",
"ansible_collections.cdot65.apstra.plugins.module_utils.apstra.api.ApstraHelper"
] | [((4964, 4984), 'ansible_collections.cdot65.apstra.plugins.module_utils.apstra.api.ApstraHelper', 'ApstraHelper', (['module'], {}), '(module)\n', (4976, 4984), False, 'from ansible_collections.cdot65.apstra.plugins.module_utils.apstra.api import ApstraHelper\n'), ((6541, 6570), 'ansible_collections.cdot65.apstra.plugin... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri May 31 15:36:31 2019
@author: gaetandissez
Important note:
We initialize factor matrices once and for all so that each new model uses the same ones as the previous ones.
It makes the results more stable because they depend on the initialization... | [
"numpy.trace",
"numpy.multiply",
"numpy.linalg.multi_dot",
"sklearn.metrics.average_precision_score",
"scipy.sparse.load_npz",
"sklearn.metrics.auc",
"spherecluster.SphericalKMeans",
"numpy.dot",
"sklearn.metrics.roc_curve",
"numpy.vectorize"
] | [((709, 729), 'numpy.vectorize', 'np.vectorize', (['update'], {}), '(update)\n', (721, 729), True, 'import numpy as np\n'), ((3664, 3684), 'numpy.vectorize', 'np.vectorize', (['update'], {}), '(update)\n', (3676, 3684), True, 'import numpy as np\n'), ((7504, 7524), 'numpy.vectorize', 'np.vectorize', (['update'], {}), '... |
"""edited from https://github.com/mightydeveloper/Deep-Compression-PyTorch"""
import torch
import numpy as np
from sklearn.cluster import KMeans, MiniBatchKMeans, AffinityPropagation, DBSCAN
# from sklearn.cluster import OPTICS
from scipy.sparse import csc_matrix, csr_matrix
def apply_weight_sharing(model, bits=10, c... | [
"scipy.sparse.csr_matrix",
"numpy.linspace",
"scipy.sparse.csc_matrix",
"torch.from_numpy"
] | [((1000, 1038), 'numpy.linspace', 'np.linspace', (['min_', 'max_'], {'num': '(2 ** bits)'}), '(min_, max_, num=2 ** bits)\n', (1011, 1038), True, 'import numpy as np\n'), ((848, 866), 'scipy.sparse.csr_matrix', 'csr_matrix', (['weight'], {}), '(weight)\n', (858, 866), False, 'from scipy.sparse import csc_matrix, csr_ma... |
######################################################################
#
# File: mhMultiListBox.py
#
# Purpose: Multi-column list box. Acts mostly like a regular
# tkinter listbox + scrollbar, but supports multiple
# columns with heading labels.
#
# o Enhance... | [
"copy.deepcopy"
] | [((7673, 7697), 'copy.deepcopy', 'copy.deepcopy', (['tableData'], {}), '(tableData)\n', (7686, 7697), False, 'import copy\n')] |
from django.contrib import admin
from qaa.apps.answer.models import Answer
admin.site.register([Answer]) | [
"django.contrib.admin.site.register"
] | [((77, 106), 'django.contrib.admin.site.register', 'admin.site.register', (['[Answer]'], {}), '([Answer])\n', (96, 106), False, 'from django.contrib import admin\n')] |
import os
import codecs
import jinja2
import markdown
from pathlib import Path
def convert_md(file):
file = open(file, encoding='utf-8')
text = file.read()
mark = markdown.Markdown()
md = mark.convert(text)
file.close()
return md
def write_blog(articles, template, template_path):
loade... | [
"jinja2.FileSystemLoader",
"markdown.Markdown",
"jinja2.select_autoescape"
] | [((179, 198), 'markdown.Markdown', 'markdown.Markdown', ([], {}), '()\n', (196, 198), False, 'import markdown\n'), ((324, 362), 'jinja2.FileSystemLoader', 'jinja2.FileSystemLoader', (['template_path'], {}), '(template_path)\n', (347, 362), False, 'import jinja2\n'), ((439, 473), 'jinja2.select_autoescape', 'jinja2.sele... |
# Copyright (C) 2019 <NAME>, <NAME>, <NAME>, <NAME>
# All rights reserved.
# This code is licensed under BSD 3-Clause License.
import sys
import os
import numpy as np
if __name__ == '__main__':
xyz_list_path = sys.argv[1]
xyzs = [xyz for xyz in os.listdir(xyz_list_path) if xyz.endswith('_predict_3.xyz')]
... | [
"os.listdir",
"numpy.hstack",
"os.path.join",
"numpy.full",
"numpy.loadtxt"
] | [((325, 348), 'numpy.full', 'np.full', (['[2466, 1]', '"""v"""'], {}), "([2466, 1], 'v')\n", (332, 348), True, 'import numpy as np\n'), ((511, 578), 'numpy.loadtxt', 'np.loadtxt', (['"""/home/wc/workspace/P2MPP/data/face3.obj"""'], {'dtype': '"""|S32"""'}), "('/home/wc/workspace/P2MPP/data/face3.obj', dtype='|S32')\n",... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.9 on 2018-01-29 16:50
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('wagtailimages', '0019_delete_filter'),
('home', '00... | [
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((478, 522), 'django.db.models.CharField', 'models.CharField', ([], {'default': '""""""', 'max_length': '(255)'}), "(default='', max_length=255)\n", (494, 522), False, 'from django.db import migrations, models\n'), ((684, 819), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True... |
from django.conf.urls import url
from dojo.engagement import views
urlpatterns = [
# engagements and calendar
url(r'^calendar$', views.engagement_calendar, name='calendar'),
url(r'^calendar/engagements$', views.engagement_calendar, name='engagement_calendar'),
url(r'^engagement$', views.engagement, n... | [
"django.conf.urls.url"
] | [((121, 182), 'django.conf.urls.url', 'url', (['"""^calendar$"""', 'views.engagement_calendar'], {'name': '"""calendar"""'}), "('^calendar$', views.engagement_calendar, name='calendar')\n", (124, 182), False, 'from django.conf.urls import url\n'), ((189, 278), 'django.conf.urls.url', 'url', (['"""^calendar/engagements$... |
import numpy as np
import tensorflow as tf
from deep_da.model.util import util_tf
"""
Models used in DANN paper
"""
class Model:
__base_n_hidden = [3072, 2048]
def __init__(self,
output_size: int=10,
n_hidden: list=None):
__n_hidden = n_hidden or self.__base_n_hid... | [
"tensorflow.nn.max_pool",
"tensorflow.variable_scope",
"tensorflow.nn.relu",
"tensorflow.nn.sigmoid",
"tensorflow.nn.dropout",
"tensorflow.nn.softmax",
"tensorflow.reshape",
"deep_da.model.util.util_tf.full_connected",
"deep_da.model.util.util_tf.convolution"
] | [((4208, 4230), 'tensorflow.nn.sigmoid', 'tf.nn.sigmoid', (['feature'], {}), '(feature)\n', (4221, 4230), True, 'import tensorflow as tf\n'), ((562, 622), 'tensorflow.variable_scope', 'tf.variable_scope', (["(scope or 'domain_classifier')"], {'reuse': 'reuse'}), "(scope or 'domain_classifier', reuse=reuse)\n", (579, 62... |
from django.utils import timezone
from django.db.models.signals import pre_save
from webapp.middleware import get_current_user
from .models import (
Event,
Distance,
Result,
)
def set_defaults(sender, instance, **kwargs):
""" Give (meta) fields default values on model save. """
if not instance.pub... | [
"django.utils.timezone.now",
"webapp.middleware.get_current_user",
"django.db.models.signals.pre_save.connect"
] | [((473, 491), 'webapp.middleware.get_current_user', 'get_current_user', ([], {}), '()\n', (489, 491), False, 'from webapp.middleware import get_current_user\n'), ((537, 581), 'django.db.models.signals.pre_save.connect', 'pre_save.connect', (['set_defaults'], {'sender': 'model'}), '(set_defaults, sender=model)\n', (553,... |
import os
from setuptools import setup
PROJECT_NAME = 'actionslog'
ROOT = os.path.abspath(os.path.dirname(__file__))
VENV = os.path.join(ROOT, '.venv')
VENV_LINK = os.path.join(VENV, 'local')
install_requires = [
'Django>=1.11.20',
'django-jsonfield>=0.9.15',
'pytz>=2015.7',
]
project = __import__(PROJEC... | [
"os.path.join",
"os.chdir",
"os.path.dirname",
"os.path.abspath",
"os.walk"
] | [((125, 152), 'os.path.join', 'os.path.join', (['ROOT', '""".venv"""'], {}), "(ROOT, '.venv')\n", (137, 152), False, 'import os\n'), ((165, 192), 'os.path.join', 'os.path.join', (['VENV', '"""local"""'], {}), "(VENV, 'local')\n", (177, 192), False, 'import os\n'), ((340, 365), 'os.path.dirname', 'os.path.dirname', (['_... |
#!/usr/bin/env python3
import argparse
import readline
from subprocess import PIPE, run
from sys import exit, stdout
import requests
from jprint import jprint
import signal
import json
from enum import Enum
ES_SEARCH_ENDPOINT = "_search"
_input = input
class LocationType(Enum):
LOCATION_TYPE_UNSPECIFIED = 0
... | [
"signal.signal",
"requests.post",
"json.loads",
"argparse.ArgumentParser",
"readline.set_startup_hook",
"subprocess.run",
"readline.insert_text",
"sys.exit",
"sys.stdout.write"
] | [((1264, 1271), 'sys.exit', 'exit', (['(0)'], {}), '(0)\n', (1268, 1271), False, 'from sys import exit, stdout\n'), ((1625, 1645), 'sys.stdout.write', 'stdout.write', (['output'], {}), '(output)\n', (1637, 1645), False, 'from sys import exit, stdout\n'), ((6184, 6228), 'signal.signal', 'signal.signal', (['signal.SIGINT... |
"""
spectral.py
Frequency domain analysis of neural signals: creating PSD, fitting 1/f, spectral histograms
"""
import numpy as np
from scipy import signal
import matplotlib.pylab as plt
from sklearn import linear_model
def psd(x, Fs, method='mean', window='hann', nperseg=None, noverlap=None, filtlen=1.):
"""
... | [
"numpy.log10",
"numpy.polyfit",
"scipy.signal.spectrogram",
"matplotlib.pylab.imshow",
"numpy.mean",
"numpy.histogram",
"matplotlib.pylab.figure",
"matplotlib.pylab.legend",
"numpy.fft.fft",
"numpy.linspace",
"matplotlib.pylab.plot",
"numpy.abs",
"numpy.flipud",
"numpy.random.choice",
"m... | [((5201, 5253), 'scipy.signal.spectrogram', 'signal.spectrogram', (['x', 'Fs', 'window', 'nperseg', 'noverlap'], {}), '(x, Fs, window, nperseg, noverlap)\n', (5219, 5253), False, 'from scipy import signal\n'), ((8015, 8067), 'scipy.signal.spectrogram', 'signal.spectrogram', (['x', 'Fs', 'window', 'nperseg', 'noverlap']... |
##### Folder Cleaner
#####
##### © <NAME> - 2020
##### for Python 3
#####
from subprocess import check_output # Using this import just to install the dependencies if not.
# I will only use my two libraries filecenter and lifeeasy and will not import anything else after they are installed.
#... | [
"filecenter.files_in_dir",
"lifeeasy.stop_display",
"lifeeasy.current_time",
"filecenter.exists",
"lifeeasy.display_body",
"filecenter.extension_from_base",
"filecenter.get_correct_path",
"filecenter.open",
"filecenter.isdir",
"lifeeasy.display_action",
"lifeeasy.display_title",
"subprocess.ch... | [((1062, 1078), 'lifeeasy.clear', 'lifeeasy.clear', ([], {}), '()\n', (1076, 1078), False, 'import lifeeasy\n'), ((2369, 2385), 'lifeeasy.clear', 'lifeeasy.clear', ([], {}), '()\n', (2383, 2385), False, 'import lifeeasy\n'), ((3784, 3852), 'lifeeasy.display_body', 'lifeeasy.display_body', (["['Chosen mode: No Sorting',... |
import time
import numpy as np
import tensorflow as tf
from dater import reader
from modeler.multirnnmodel import MultiRNNModel
from trainer.tftrainer import TFTrainer
class MutiRNNTrainer(TFTrainer):
def __init__(self):
self.config = SmallConfig()
self.eval_config = SmallConfig()
self.e... | [
"tensorflow.Graph",
"tensorflow.variable_scope",
"numpy.exp",
"dater.reader.ptb_raw_data",
"tensorflow.name_scope",
"tensorflow.train.Supervisor",
"dater.reader.ptb_producer",
"tensorflow.random_uniform_initializer",
"time.time"
] | [((524, 577), 'dater.reader.ptb_raw_data', 'reader.ptb_raw_data', (['"""data/simple-examples.tar/data/"""'], {}), "('data/simple-examples.tar/data/')\n", (543, 577), False, 'from dater import reader\n'), ((3122, 3133), 'time.time', 'time.time', ([], {}), '()\n', (3131, 3133), False, 'import time\n'), ((4054, 4075), 'nu... |
import unittest
from flapi.core.rules import _CollectionRule
class CollectionRuleTest(unittest.TestCase):
def test_fails(self):
rule = _CollectionRule()
self.assertRaises(NotImplementedError, rule, "token")
| [
"flapi.core.rules._CollectionRule"
] | [((150, 167), 'flapi.core.rules._CollectionRule', '_CollectionRule', ([], {}), '()\n', (165, 167), False, 'from flapi.core.rules import _CollectionRule\n')] |
# Copyright (c) 2014 Mirantis Inc.
#
# Licensed under the Apache License, Version 2.0 (the License);
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, so... | [
"copy.deepcopy"
] | [((782, 801), 'copy.deepcopy', 'copy.deepcopy', (['info'], {}), '(info)\n', (795, 801), False, 'import copy\n')] |
import numpy as np
from ..utils import slice_row_sparse
from .metrics import NDCG
def evaluate(model, Xtr, Xts, target_users,
topk=100, metrics=[NDCG], min_targets=1000,
from_to=('user', 'item')):
"""
"""
if target_users is None:
target_users = np.random.choice(Xts.shape... | [
"numpy.random.choice"
] | [((294, 344), 'numpy.random.choice', 'np.random.choice', (['Xts.shape[0]', 'min_targets', '(False)'], {}), '(Xts.shape[0], min_targets, False)\n', (310, 344), True, 'import numpy as np\n')] |
import os
import sys
from openbabel import openbabel as ob
from openbabel import pybel as pb
import gen3D
import numpy as np
from statistics import mean
import props
ELEMENT_TABLE = props.ElementData()
class FILTER(object):
def __init__(self, reactant_file, cluster_bond_file = None, fixed_atoms = None... | [
"statistics.mean",
"openbabel.openbabel.OBAtom",
"openbabel.pybel.ob.OBMolBondIter",
"gen3D.Molecule",
"openbabel.pybel.ob.OBMol",
"numpy.array",
"numpy.linalg.norm",
"props.ElementData",
"openbabel.pybel.readfile"
] | [((192, 211), 'props.ElementData', 'props.ElementData', ([], {}), '()\n', (209, 211), False, 'import props\n'), ((680, 718), 'openbabel.pybel.readfile', 'pb.readfile', (['"""xyz"""', 'self.reactant_file'], {}), "('xyz', self.reactant_file)\n", (691, 718), True, 'from openbabel import pybel as pb\n'), ((773, 786), 'open... |
import sys
import cv2
import math
import os
import json
import pandas as pd
import numpy as np
import json
stroke_data = {
"data" : []
}
stroke_data_ = open('result.json', 'r')
stroke_data = json.loads(stroke_data_.read())
print(stroke_data['data'])
stroke_data_.close()
speed_for_each_stroke = {}
def read_coor... | [
"pandas.read_csv",
"cv2.getPerspectiveTransform",
"numpy.asarray",
"math.sqrt",
"numpy.array",
"numpy.zeros",
"json.dump"
] | [((1182, 1224), 'math.sqrt', 'math.sqrt', (['((x1 - x2) ** 2 + (y1 - y2) ** 2)'], {}), '((x1 - x2) ** 2 + (y1 - y2) ** 2)\n', (1191, 1224), False, 'import math\n'), ((1422, 1453), 'pandas.read_csv', 'pd.read_csv', (['"""final_result.csv"""'], {}), "('final_result.csv')\n", (1433, 1453), True, 'import pandas as pd\n'), ... |
#!/usr/bin/env python3
import os
import time
import subprocess
import random
import inquirer
import stat
import wget
from libsw import php, nginx, user, bind, cert, db, settings, input_util
from getpass import getpass
from mysql import connector
from pwd import getpwnam
def list_installations():
"""
List all ... | [
"subprocess.getoutput",
"wget.download",
"libsw.bind.make_zone",
"libsw.nginx.bypass_modsec_rule",
"time.sleep",
"inquirer.List",
"libsw.db.clone",
"libsw.php.make_vhost",
"libsw.settings.get",
"libsw.php.get_site_version",
"libsw.input_util.random_string",
"os.path.exists",
"pwd.getpwnam",
... | [((384, 405), 'libsw.nginx.enabled_sites', 'nginx.enabled_sites', ([], {}), '()\n', (403, 405), False, 'from libsw import php, nginx, user, bind, cert, db, settings, input_util\n'), ((1218, 1248), 'libsw.nginx.user_from_domain', 'nginx.user_from_domain', (['domain'], {}), '(domain)\n', (1240, 1248), False, 'from libsw ... |
__all__ = [
"to_str",
"to_bytes",
"strip_punctuation",
"to_ascii_str",
"is_number",
"count_digit",
"count_alpha",
"count_upper",
"count_space",
"count_punctuation",
"split",
"decode_escaped_bytes",
"word_ngrams",
"sentences",
"has_1a1d",
]
f... | [
"re.split",
"re.escape",
"unicodedata.normalize",
"re.compile"
] | [((4191, 4251), 're.compile', 're.compile', (['"""(?<!\\\\w\\\\.\\\\w.)(?<![A-Z][a-z]\\\\.)(?<=[.?!])\\\\s"""'], {}), "('(?<!\\\\w\\\\.\\\\w.)(?<![A-Z][a-z]\\\\.)(?<=[.?!])\\\\s')\n", (4201, 4251), False, 'import re\n'), ((3848, 3878), 're.split', 're.split', (['pattern', 's', 'maxsplit'], {}), '(pattern, s, maxsplit)\... |
import unittest
import backpack_test
import item_test
import env_test
# initialize the test suite
loader = unittest.TestLoader()
suite = unittest.TestSuite()
suite.addTests(loader.loadTestsFromModule(backpack_test))
suite.addTests(loader.loadTestsFromModule(item_test))
suite.addTests(loader.loadTestsFromModule(env_t... | [
"unittest.TestSuite",
"unittest.TextTestRunner",
"unittest.TestLoader"
] | [((109, 130), 'unittest.TestLoader', 'unittest.TestLoader', ([], {}), '()\n', (128, 130), False, 'import unittest\n'), ((139, 159), 'unittest.TestSuite', 'unittest.TestSuite', ([], {}), '()\n', (157, 159), False, 'import unittest\n'), ((336, 372), 'unittest.TextTestRunner', 'unittest.TextTestRunner', ([], {'verbosity':... |
import socket
import asyncio
import time
import random
import json
import requests
from walkoff_app_sdk.app_base import AppBase
class BreachSense(AppBase):
__version__ = "1.0.0"
app_name = "Breachsense" # this needs to match "name" in api.yaml
def __init__(self, redis, logger, console_logger=None):
... | [
"requests.get"
] | [((856, 873), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (868, 873), False, 'import requests\n'), ((1314, 1331), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (1326, 1331), False, 'import requests\n'), ((1771, 1788), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (1783, 1788), Fals... |
#! python3
import sys
import openpyxl
def blankRowInserter(index, num_blanks, filename):
"""
Args:
index (int): row in file to start insert
num_blanks (int): number of blank rows to insert
filename (str): filename to insert blanks
Returns:
None
"""
wb = openpyxl.loa... | [
"openpyxl.load_workbook"
] | [((308, 340), 'openpyxl.load_workbook', 'openpyxl.load_workbook', (['filename'], {}), '(filename)\n', (330, 340), False, 'import openpyxl\n')] |
from pyrosim.neuron import NEURON
from pyrosim.synapse import SYNAPSE
class NEURAL_NETWORK:
def __init__(self,nndfFileName):
self.neurons = {}
self.synapses = {}
f = open(nndfFileName,"r")
for line in f.readlines():
self.Digest(line)
f.close()
def P... | [
"pyrosim.synapse.SYNAPSE",
"pyrosim.neuron.NEURON"
] | [((1504, 1516), 'pyrosim.neuron.NEURON', 'NEURON', (['line'], {}), '(line)\n', (1510, 1516), False, 'from pyrosim.neuron import NEURON\n'), ((1634, 1647), 'pyrosim.synapse.SYNAPSE', 'SYNAPSE', (['line'], {}), '(line)\n', (1641, 1647), False, 'from pyrosim.synapse import SYNAPSE\n')] |
import setuptools
setup_args = dict(
name="grr-grafanalib-dashboards",
description="GRR grafanalib Monitoring Dashboards",
license="Apache License, Version 2.0",
url="https://github.com/google/grr/tree/master/monitoring/grafana",
maintainer="GRR Development Team",
maintainer_email="<EMAIL>",
packages=set... | [
"setuptools.find_packages",
"setuptools.setup"
] | [((587, 617), 'setuptools.setup', 'setuptools.setup', ([], {}), '(**setup_args)\n', (603, 617), False, 'import setuptools\n'), ((317, 343), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (341, 343), False, 'import setuptools\n')] |
#
# Copyright (c) 2021 Project CHIP Authors
#
# 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 i... | [
"memdf.Config.group_def",
"pathlib.Path",
"pandas.api.types.is_string_dtype",
"cxxfilt.demangle",
"memdf.Config.group_map"
] | [((1033, 1059), 'memdf.Config.group_map', 'Config.group_map', (['"""report"""'], {}), "('report')\n", (1049, 1059), False, 'from memdf import Config, ConfigDescription, DF, DFs\n'), ((1361, 1387), 'memdf.Config.group_map', 'Config.group_map', (['"""report"""'], {}), "('report')\n", (1377, 1387), False, 'from memdf impo... |
try:
from setuptools import setup, find_packages
except ImportError:
from ez_setup import use_setuptools
use_setuptools()
from setuptools import setup, find_packages
longdesc = """
PyBagIt Version 1.5.3
This module helps with creating an managing BagIt-compliant packages. It has
been created to confor... | [
"setuptools.find_packages",
"ez_setup.use_setuptools"
] | [((117, 133), 'ez_setup.use_setuptools', 'use_setuptools', ([], {}), '()\n', (131, 133), False, 'from ez_setup import use_setuptools\n'), ((1516, 1551), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "['ez_setup']"}), "(exclude=['ez_setup'])\n", (1529, 1551), False, 'from setuptools import setup, find_pa... |
import os
import pytest
from jina import __default_host__, __docker_host__
from ..helpers import create_workspace, wait_for_workspace, create_flow, assert_request
cur_dir = os.path.dirname(os.path.abspath(__file__))
compose_yml = os.path.join(cur_dir, 'docker-compose.yml')
flow_yaml = os.path.join(cur_dir, 'flow.yml... | [
"os.path.abspath",
"pytest.mark.parametrize",
"pytest.mark.skip",
"os.path.join"
] | [((233, 276), 'os.path.join', 'os.path.join', (['cur_dir', '"""docker-compose.yml"""'], {}), "(cur_dir, 'docker-compose.yml')\n", (245, 276), False, 'import os\n'), ((289, 322), 'os.path.join', 'os.path.join', (['cur_dir', '"""flow.yml"""'], {}), "(cur_dir, 'flow.yml')\n", (301, 322), False, 'import os\n'), ((428, 495)... |
import math
from openmdao.main.api import Component
from openmdao.lib.datatypes.api import Float, VarTree, Event
from pycycle.flowstation import FlowStation, FlowStationVar, GAS_CONSTANT
from pycycle.cycle_component import CycleComponent
class Compressor(CycleComponent):
"""Axial Compressor performance calcu... | [
"pycycle.flowstation.FlowStationVar",
"pycycle.flowstation.FlowStation",
"openmdao.lib.datatypes.api.Float",
"math.log"
] | [((346, 415), 'openmdao.lib.datatypes.api.Float', 'Float', (['(12.47)'], {'iotype': '"""in"""', 'desc': '"""Pressure ratio at design conditions"""'}), "(12.47, iotype='in', desc='Pressure ratio at design conditions')\n", (351, 415), False, 'from openmdao.lib.datatypes.api import Float, VarTree, Event\n'), ((433, 525), ... |
import unittest
import note
import chord
class TestCorrectLocation(unittest.TestCase):
"""Test cases for the correct_location method in the Chord class."""
def test_start_at_end(self):
"""Start searching from the last index in the Chord."""
n = note.Note('Ab3', True)
c = ... | [
"unittest.main",
"chord.Chord",
"note.Note"
] | [((2159, 2174), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2172, 2174), False, 'import unittest\n'), ((284, 306), 'note.Note', 'note.Note', (['"""Ab3"""', '(True)'], {}), "('Ab3', True)\n", (293, 306), False, 'import note\n'), ((320, 334), 'chord.Chord', 'chord.Chord', (['n'], {}), '(n)\n', (331, 334), False,... |