code stringlengths 20 1.04M | apis list | extract_api stringlengths 75 9.94M |
|---|---|---|
from __future__ import absolute_import
__license__ = """
Copyright (c) 2020 <NAME>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
"""
from phyprof.computation import Distributed, CPU, GPU
from phyprof.runtime import ... | [
"phyprof.computation.GPU",
"phyprof.computation.CPU",
"phyprof.computation.Distributed"
] | [((701, 728), 'phyprof.computation.Distributed', 'Distributed', (['node_0', 'node_1'], {}), '(node_0, node_1)\n', (712, 728), False, 'from phyprof.computation import Distributed, CPU, GPU\n'), ((638, 650), 'phyprof.computation.GPU', 'GPU', (['(1024)', '(1)'], {}), '(1024, 1)\n', (641, 650), False, 'from phyprof.computa... |
'''
Last update: 2018/11/28 by <NAME>
Compares two haplotypes (from .fa files) and
reports variants.
'''
import sys
# inputs
hap1_fn = '/scratch/groups/blangme2/naechyun/relaxing/na12878/na12878-chr9-phase3_hapA.fa'
hap2_fn = '/scratch/groups/blangme2/naechyun/relaxing/na12878/na12878-chr9-phase3_hapB.fa'
# laod f... | [
"sys.stderr.write"
] | [((647, 693), 'sys.stderr.write', 'sys.stderr.write', (['"""WARNING: different lengths"""'], {}), "('WARNING: different lengths')\n", (663, 693), False, 'import sys\n')] |
import subprocess
import typer
from typer.testing import CliRunner
from parameter_types.index import tutorial001 as mod
runner = CliRunner()
app = typer.Typer()
app.command()(mod.main)
def test_help():
result = runner.invoke(app, ["--help"])
assert result.exit_code == 0
assert "--age INTEGER" in resul... | [
"typer.Typer",
"subprocess.run",
"typer.testing.CliRunner"
] | [((132, 143), 'typer.testing.CliRunner', 'CliRunner', ([], {}), '()\n', (141, 143), False, 'from typer.testing import CliRunner\n'), ((151, 164), 'typer.Typer', 'typer.Typer', ([], {}), '()\n', (162, 164), False, 'import typer\n'), ((1091, 1221), 'subprocess.run', 'subprocess.run', (["['coverage', 'run', mod.__file__, ... |
# -*- coding: utf-8 -*-
"""
RelatedFunctionCondition
~~~~~~~~~
:copyright: (c) 2018 by geeksaga.
:license: MIT LICENSE 2.0, see license for more details.
"""
from sqlalchemy import Column, Integer, ForeignKey
from sqlalchemy.orm import relationship, backref
from . import Base
class RelatedFunctionCo... | [
"sqlalchemy.ForeignKey"
] | [((421, 448), 'sqlalchemy.ForeignKey', 'ForeignKey', (['"""gs_version.id"""'], {}), "('gs_version.id')\n", (431, 448), False, 'from sqlalchemy import Column, Integer, ForeignKey\n'), ((484, 512), 'sqlalchemy.ForeignKey', 'ForeignKey', (['"""gs_function.id"""'], {}), "('gs_function.id')\n", (494, 512), False, 'from sqla... |
# -*- coding: utf-8 -*-
from pathlib import Path
from io import StringIO
import logging
from dotenv import find_dotenv, load_dotenv
import boto3
import json
import datetime
import gzip
import shutil
import re
import os
import io
import pandas as pd
import numpy as np
from sqlalchemy import create_engine
import prepro... | [
"nltk.stem.PorterStemmer",
"boto3.client",
"dotenv.find_dotenv",
"json.dumps",
"pathlib.Path",
"json.loads",
"spacy.load",
"shutil.copyfileobj",
"re.sub",
"pandas.DataFrame.from_dict",
"nltk.corpus.stopwords.words",
"os.getenv",
"preprocessor.clean",
"gzip.open",
"logging.basicConfig",
... | [((9788, 9815), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (9805, 9815), False, 'import logging\n'), ((10054, 10109), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': 'log_fmt'}), '(level=logging.INFO, format=log_fmt)\n', (10073, 10109), False, 'i... |
from django.urls import path
from events.api.views import (
EventListAPIView, EventUpdateAPIView,
EventDetailAPIView, EventCreateAPIView,
ParticipantCreateAPIView,
)
app_name = 'events-api'
urlpatterns = [
path('', EventListAPIView.as_view(), name='list'),
path('create/', EventCreateAPIView.as_vie... | [
"events.api.views.ParticipantCreateAPIView.as_view",
"events.api.views.EventListAPIView.as_view",
"events.api.views.EventUpdateAPIView.as_view",
"events.api.views.EventDetailAPIView.as_view",
"events.api.views.EventCreateAPIView.as_view"
] | [((233, 259), 'events.api.views.EventListAPIView.as_view', 'EventListAPIView.as_view', ([], {}), '()\n', (257, 259), False, 'from events.api.views import EventListAPIView, EventUpdateAPIView, EventDetailAPIView, EventCreateAPIView, ParticipantCreateAPIView\n'), ((295, 323), 'events.api.views.EventCreateAPIView.as_view'... |
import scandir
import os
from data import common
from data import srdata
import numpy as np
import scipy.misc as misc
import torch
import torch.utils.data as data
class Benchmark(srdata.SRData):
def __init__(self, args, train=True):
super(Benchmark, self).__init__(args, train, benchmark=True)
def _... | [
"scandir.scandir",
"os.path.join",
"os.path.splitext"
] | [((417, 445), 'scandir.scandir', 'scandir.scandir', (['self.dir_hr'], {}), '(self.dir_hr)\n', (432, 445), False, 'import scandir\n'), ((960, 1016), 'os.path.join', 'os.path.join', (['dir_data', '"""benchmark"""', 'self.args.data_test'], {}), "(dir_data, 'benchmark', self.args.data_test)\n", (972, 1016), False, 'import ... |
import random
import gym.spaces
import matplotlib.pyplot as plt
import numpy as np
import tqdm
import emdp.actions
import emdp.gridworld.plotting
import emdp.gridworld.plotting
from . import builder_tools
from . import txt_utilities
from .helper_utilities import flatten_state, unflatten_state
from ..common import MDP... | [
"numpy.zeros_like",
"matplotlib.pyplot.show",
"numpy.abs",
"numpy.copy",
"tqdm.trange",
"numpy.zeros",
"random.choice",
"numpy.clip",
"numpy.einsum",
"matplotlib.pyplot.figure",
"numpy.arange",
"numpy.array",
"matplotlib.pyplot.gca",
"numpy.random.rand"
] | [((1630, 1655), 'numpy.zeros', 'np.zeros', (['self.num_states'], {}), '(self.num_states)\n', (1638, 1655), True, 'import numpy as np\n'), ((2356, 2381), 'random.choice', 'random.choice', (['self.goals'], {}), '(self.goals)\n', (2369, 2381), False, 'import random\n'), ((3242, 3289), 'numpy.zeros', 'np.zeros', (['builder... |
import glob
from citeomatic.grobid_parser import GrobidParser, parse_full_text
from citeomatic import file_util
def test_grobid_reed():
parser = parse_full_text(
file_util.slurp(file_util.test_file(__file__, 'reed.xml'))
)
assert parser.title == 'Optimizing Cauchy Reed-Solomon Codes for Fault-Tol... | [
"pytest.main",
"citeomatic.file_util.test_file",
"citeomatic.grobid_parser.GrobidParser",
"glob.glob"
] | [((3111, 3141), 'glob.glob', 'glob.glob', (['"""./data/pdfs/*.pdf"""'], {}), "('./data/pdfs/*.pdf')\n", (3120, 3141), False, 'import glob\n'), ((3479, 3508), 'pytest.main', 'pytest.main', (["['-s', __file__]"], {}), "(['-s', __file__])\n", (3490, 3508), False, 'import pytest\n'), ((193, 234), 'citeomatic.file_util.test... |
from tiktok_api_python.TikTokApi import TikTokApi
api = TikTokApi()
challenge_feed = api.get_challenge_feed('foryou')
print(challenge_feed)
| [
"tiktok_api_python.TikTokApi.TikTokApi"
] | [((57, 68), 'tiktok_api_python.TikTokApi.TikTokApi', 'TikTokApi', ([], {}), '()\n', (66, 68), False, 'from tiktok_api_python.TikTokApi import TikTokApi\n')] |
# Generated by Django 2.2.13 on 2021-03-18 12:41
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('materials', '0003_new_sharekit'),
]
operations = [
migrations.RemoveField(
model_name='material',
name='description... | [
"django.db.migrations.RemoveField",
"django.db.models.DateTimeField"
] | [((232, 297), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""material"""', 'name': '"""description"""'}), "(model_name='material', name='description')\n", (254, 297), False, 'from django.db import migrations, models\n'), ((342, 404), 'django.db.migrations.RemoveField', 'migrations... |
from django.shortcuts import render
from django.conf import settings
from django.contrib.auth import REDIRECT_FIELD_NAME, login
from django.http import Http404
from django.urls import reverse
from django.views.decorators.cache import never_cache
from social_core.actions import do_auth, do_complete, do_disconnect
from s... | [
"social_core.backends.utils.get_backend",
"social_core.actions.do_complete",
"social_django.strategy.DjangoStrategy",
"django.urls.reverse",
"django.http.Http404",
"social_core.actions.do_disconnect",
"social_core.actions.do_auth"
] | [((676, 720), 'django.urls.reverse', 'reverse', (['"""social:complete"""'], {'args': '(provider,)'}), "('social:complete', args=(provider,))\n", (683, 720), False, 'from django.urls import reverse\n'), ((751, 789), 'social_django.strategy.DjangoStrategy', 'DjangoStrategy', (['DjangoStorage', 'request'], {}), '(DjangoSt... |
# -*- coding:utf-8 -*-
# 解析维基百科页面，提取事件关键词
from bs4 import BeautifulSoup
import requests
import pymongo
from pymongo import InsertOne
from pymongo.errors import BulkWriteError
import random
from pprint import pprint
from tqdm import tqdm
client = pymongo.MongoClient('172.16.31.10:27017') # 与服务器上的MongoDB数据库建立连接
db = ... | [
"pymongo.MongoClient",
"tqdm.tqdm",
"random.randint",
"pprint.pprint",
"requests.get",
"bs4.BeautifulSoup"
] | [((249, 290), 'pymongo.MongoClient', 'pymongo.MongoClient', (['"""172.16.31.10:27017"""'], {}), "('172.16.31.10:27017')\n", (268, 290), False, 'import pymongo\n'), ((623, 670), 'requests.get', 'requests.get', (['url'], {'headers': 'header', 'verify': '(False)'}), '(url, headers=header, verify=False)\n', (635, 670), Fal... |
"""Module for getting Polygons."""
import logging
import requests
from shapely.geometry import Polygon
class GeoLocation:
"""Class for getting polygons."""
OPEN_STREET_MAP_BASE_ENDPOINT = "https://nominatim.openstreetmap.org/details.php"
PARAMS = {
'polygon_geojson': 1,
'format': 'json'
... | [
"shapely.geometry.Polygon",
"logging.getLogger",
"requests.get"
] | [((855, 934), 'requests.get', 'requests.get', ([], {'url': 'GeoLocation.OPEN_STREET_MAP_BASE_ENDPOINT', 'params': 'self.params'}), '(url=GeoLocation.OPEN_STREET_MAP_BASE_ENDPOINT, params=self.params)\n', (867, 934), False, 'import requests\n'), ((1151, 1174), 'shapely.geometry.Polygon', 'Polygon', (['coordinates[0]'], ... |
from flask import render_template, request
from app import db
from app.errors import bp
from app.api.errors import error_response as er
def needs_json():
return request.accept_mimetypes['application/json'] >= \
request.accept_mimetypes['text/html']
@bp.app_errorhandler(404)
def not_found_error(error):... | [
"flask.render_template",
"app.errors.bp.app_errorhandler",
"app.db.session.rollback",
"app.api.errors.error_response"
] | [((268, 292), 'app.errors.bp.app_errorhandler', 'bp.app_errorhandler', (['(404)'], {}), '(404)\n', (287, 292), False, 'from app.errors import bp\n'), ((418, 442), 'app.errors.bp.app_errorhandler', 'bp.app_errorhandler', (['(500)'], {}), '(500)\n', (437, 442), False, 'from app.errors import bp\n'), ((474, 495), 'app.db.... |
from django.test import TestCase
from ...profile_data.indicators import Grants
from constance.test import override_config
class MockAPIData:
def __init__(self, results):
self.results = results
class GrantsTests(TestCase):
def test_group_years(self):
"""Data is grouped by year. Order of value... | [
"constance.test.override_config"
] | [((4839, 4904), 'constance.test.override_config', 'override_config', ([], {'GRANTS_LATEST_YEAR': '(2040)', 'GRANTS_LATEST_QUARTER': '(2)'}), '(GRANTS_LATEST_YEAR=2040, GRANTS_LATEST_QUARTER=2)\n', (4854, 4904), False, 'from constance.test import override_config\n')] |
import scrapy
import csv
import json
from york_scraper.items import YorkSubjectItem
# grabs list of subjects from York's subject page
class SubjectScraper(scrapy.Spider):
name = "subjects"
custom_settings = {
'FEED_FORMAT': 'csv',
'FEED_URI': 'csv/subjects.csv',
'FEED_EXPORT_FIELDS': ['... | [
"json.load",
"york_scraper.items.YorkSubjectItem",
"scrapy.Request"
] | [((552, 564), 'json.load', 'json.load', (['f'], {}), '(f)\n', (561, 564), False, 'import json\n'), ((721, 784), 'scrapy.Request', 'scrapy.Request', ([], {'url': 'start_url[0]', 'callback': 'self.set_subject_url'}), '(url=start_url[0], callback=self.set_subject_url)\n', (735, 784), False, 'import scrapy\n'), ((1093, 114... |
# BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
import numpy
import awkward as ak
np = ak.nplike.NumpyMetadata.instance()
def to_numpy(array, allow_missing=True):
"""
Converts `array` (many types supported, including all Awkward Arrays and
Records) into a NumPy a... | [
"awkward.nplike.NumpyMetadata.instance",
"numpy.asarray",
"awkward._v2.operations.convert.to_layout"
] | [((130, 164), 'awkward.nplike.NumpyMetadata.instance', 'ak.nplike.NumpyMetadata.instance', ([], {}), '()\n', (162, 164), True, 'import awkward as ak\n'), ((1671, 1750), 'awkward._v2.operations.convert.to_layout', 'ak._v2.operations.convert.to_layout', (['array'], {'allow_record': '(True)', 'allow_other': '(True)'}), '(... |
from typing import Tuple
import jax.numpy as np
import numpy as onp
def get_data(
N: int = 30,
input_noise: float = 0.15,
output_noise: float = 0.15,
N_test: int = 400,
) -> Tuple[np.ndarray, np.ndarray, np.ndarray]:
onp.random.seed(0)
X = np.linspace(-1, 1, N)
Y = X + 0.2 * np.power(X, 3... | [
"jax.numpy.power",
"numpy.random.seed",
"jax.numpy.std",
"numpy.random.randn",
"jax.numpy.linspace",
"numpy.random.RandomState",
"numpy.sin",
"jax.numpy.mean",
"numpy.vstack",
"jax.numpy.sin"
] | [((240, 258), 'numpy.random.seed', 'onp.random.seed', (['(0)'], {}), '(0)\n', (255, 258), True, 'import numpy as onp\n'), ((267, 288), 'jax.numpy.linspace', 'np.linspace', (['(-1)', '(1)', 'N'], {}), '(-1, 1, N)\n', (278, 288), True, 'import jax.numpy as np\n'), ((426, 436), 'jax.numpy.mean', 'np.mean', (['Y'], {}), '(... |
# -*- coding: utf-8 -*-
# vim:fenc=utf-8
'''
Intuition remote data
---------------------
Provides functions to access various trading data accross internet wires
:copyright (c) 2014 <NAME>.
:license: Apache2.0, see LICENSE for more details.
'''
import json
import requests
import pandas as pd
from pandas.i... | [
"pandas.io.data.DataReader",
"pandas.io.data.get_quote_yahoo",
"pandas.DataFrame",
"json.loads",
"intuition.data.utils.apply_mapping",
"requests.get"
] | [((800, 848), 'pandas.io.data.DataReader', 'DataReader', (['symbol', 'source'], {'start': 'start', 'end': 'end'}), '(symbol, source, start=start, end=end)\n', (810, 848), False, 'from pandas.io.data import DataReader, get_quote_yahoo\n'), ((1382, 1406), 'pandas.io.data.get_quote_yahoo', 'get_quote_yahoo', (['symbols'],... |
#!/usr/bin/env python
# Licensed to Cloudera, Inc. under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. Cloudera, Inc. licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you ma... | [
"cStringIO.StringIO",
"desktop.lib.rest.resource.Resource",
"logging.getLogger",
"desktop.lib.rest.http_client.HttpClient"
] | [((992, 1019), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1009, 1019), False, 'import logging\n'), ((1356, 1394), 'desktop.lib.rest.http_client.HttpClient', 'HttpClient', (['self._base_url'], {'logger': 'LOG'}), '(self._base_url, logger=LOG)\n', (1366, 1394), False, 'from desktop.lib... |
"""Classes and functions for handling variant calling
"""
import re
from pandas import read_table
class AbstractSequenceMotif(object):
def __init__(self, motif, dna_sequence, offset):
self.dna_sequence = dna_sequence.upper()
self.forward_positions = [m.start() for m in re.finditer(moti... | [
"pandas.read_table",
"re.finditer"
] | [((3537, 3665), 'pandas.read_table', 'read_table', (['file_'], {'usecols': '(0, 1, 2, 3, 4)', 'names': "['contig', 'ref_pos', 'variant_call', 'pC', 'p5mC']", 'header': 'None', 'sep': '"""\t"""'}), "(file_, usecols=(0, 1, 2, 3, 4), names=['contig', 'ref_pos',\n 'variant_call', 'pC', 'p5mC'], header=None, sep='\\t')\n... |
import logging
import sys
from colorama import Style, Fore
def init_logging(app="pajbot"):
class LogFilter(logging.Filter):
def __init__(self, level):
super().__init__()
self.level = level
def filter(self, record):
return record.levelno < self.level
color... | [
"logging.Formatter.format",
"logging.StreamHandler",
"logging.getLogger"
] | [((1089, 1111), 'logging.getLogger', 'logging.getLogger', (['app'], {}), '(app)\n', (1106, 1111), False, 'import logging\n'), ((1302, 1335), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (1323, 1335), False, 'import logging\n'), ((1489, 1522), 'logging.StreamHandler', 'loggin... |
import json
from django.core.management import call_command
from nose.tools import eq_
import amo
import amo.tests
from amo.helpers import url
from applications.models import AppVersion, Application
from applications.management.commands import dump_apps
class TestAppVersion(amo.tests.TestCase):
def test_major_... | [
"applications.models.Application.objects.all",
"applications.models.Application.objects.get",
"json.load",
"amo.helpers.url",
"applications.models.AppVersion.objects.filter",
"django.core.management.call_command",
"nose.tools.eq_",
"applications.models.AppVersion"
] | [((404, 434), 'applications.models.AppVersion', 'AppVersion', ([], {'version': '"""3.0.12b2"""'}), "(version='3.0.12b2')\n", (414, 434), False, 'from applications.models import AppVersion, Application\n'), ((443, 458), 'nose.tools.eq_', 'eq_', (['v.major', '(3)'], {}), '(v.major, 3)\n', (446, 458), False, 'from nose.to... |
"""
Functions for simple MODFLOW boundary conditions such as ghb, drain, etc.
"""
import numbers
import shutil
import flopy
import numpy as np
import pandas as pd
fm = flopy.modflow
import pyproj
import rasterio
from gisutils import project
from rasterstats import zonal_stats
from shapely.geometry import Polygon
fro... | [
"pandas.DataFrame",
"mfsetup.discretization.cellids_to_kij",
"rasterio.open",
"gisutils.project",
"shapely.geometry.Polygon",
"mfsetup.discretization.get_layer",
"numpy.isnan",
"numpy.indices",
"gisutils.get_authority_crs",
"mfsetup.units.convert_length_units",
"numpy.array",
"rasterstats.zona... | [((1918, 1946), 'numpy.indices', 'np.indices', (['(m.nrow, m.ncol)'], {}), '((m.nrow, m.ncol))\n', (1928, 1946), True, 'import numpy as np\n'), ((1956, 2014), 'pandas.DataFrame', 'pd.DataFrame', (["{'per': 0, 'k': 0, 'i': i.flat, 'j': j.flat}"], {}), "({'per': 0, 'k': 0, 'i': i.flat, 'j': j.flat})\n", (1968, 2014), Tru... |
import re
fo = open('sanitized_data.txt')
fo_ = open('training_data.txt', 'w')
try:
text = fo.read()
sentences = text.split('\n')
for sentence in sentences:
sentence = re.sub(r'\b(\w+)( \1\b)+', r'\1', sentence)
fo_.write(sentence + ' ')
finally:
fo.close()
fo_.close() | [
"re.sub"
] | [((194, 240), 're.sub', 're.sub', (['"""\\\\b(\\\\w+)( \\\\1\\\\b)+"""', '"""\\\\1"""', 'sentence'], {}), "('\\\\b(\\\\w+)( \\\\1\\\\b)+', '\\\\1', sentence)\n", (200, 240), False, 'import re\n')] |
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from config import Config
from flask_bootstrap import Bootstrap
from flask_mail import Mail
app = Flask(__name__, static_folder='static', static_url_path='')
app.config.from_object(Config)
mail = Mail(app)
db = SQLAlchemy... | [
"flask.Flask",
"flask_mail.Mail",
"flask_sqlalchemy.SQLAlchemy",
"flask_migrate.Migrate",
"flask_bootstrap.Bootstrap"
] | [((197, 256), 'flask.Flask', 'Flask', (['__name__'], {'static_folder': '"""static"""', 'static_url_path': '""""""'}), "(__name__, static_folder='static', static_url_path='')\n", (202, 256), False, 'from flask import Flask\n'), ((295, 304), 'flask_mail.Mail', 'Mail', (['app'], {}), '(app)\n', (299, 304), False, 'from fl... |
# file: dataset_reader.py
#
# Contains helper class dataset
# which is able to return mini batches of a desired
# size of <label, image> pairs
#
# For this the class constructor needs to be passed
# a imagePath in which it expects a subfolder for each
# image category.
#
# It automatically will traverse each subfolder ... | [
"cv2.resize",
"numpy.random.shuffle",
"cv2.waitKey",
"cv2.cvtColor",
"numpy.asarray",
"numpy.zeros",
"cv2.imshow",
"cv2.imread",
"numpy.random.randint",
"os.path.splitext",
"cv2.moveWindow",
"cv2.destroyAllWindows",
"os.path.join",
"os.listdir",
"numpy.unique",
"os.path.split"
] | [((9861, 9876), 'os.listdir', 'os.listdir', (['top'], {}), '(top)\n', (9871, 9876), False, 'import os\n'), ((2009, 2037), 'numpy.random.shuffle', 'np.random.shuffle', (['self.data'], {}), '(self.data)\n', (2026, 2037), True, 'import numpy as np\n'), ((2856, 2873), 'cv2.waitKey', 'cv2.waitKey', (['(1000)'], {}), '(1000)... |
from django import forms
from cities.models import City
from routes.models import Route
class RouteForm(forms.Form):
from_city = forms.ModelChoiceField(label='Откуда',queryset=City.objects.all(),
widget=forms.Select(
... | [
"django.forms.Select",
"django.forms.TextInput",
"django.forms.NumberInput",
"cities.models.City.objects.all",
"django.forms.HiddenInput",
"django.forms.SelectMultiple"
] | [((188, 206), 'cities.models.City.objects.all', 'City.objects.all', ([], {}), '()\n', (204, 206), False, 'from cities.models import City\n'), ((261, 330), 'django.forms.Select', 'forms.Select', ([], {'attrs': "{'class': 'form-control js-example-basic-single'}"}), "(attrs={'class': 'form-control js-example-basic-single'... |
"""
Django settings for ersteops project.
Generated by 'django-admin startproject' using Django 1.11.7.
For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
"""
import o... | [
"os.path.abspath",
"os.environ.get",
"ast.literal_eval",
"os.path.join",
"os.getenv",
"dj_database_url.config"
] | [((974, 1017), 'ast.literal_eval', 'ast.literal_eval', (["os.environ['DEBUG_STATE']"], {}), "(os.environ['DEBUG_STATE'])\n", (990, 1017), False, 'import ast\n'), ((1146, 1188), 'ast.literal_eval', 'ast.literal_eval', (["os.environ['PRODUCTION']"], {}), "(os.environ['PRODUCTION'])\n", (1162, 1188), False, 'import ast\n'... |
import csv
from django.core.management.base import BaseCommand
from pfb_analysis.models import AnalysisJob
def load_speed_limit(job, csv_filename):
with open(csv_filename, 'r') as csv_file:
reader = csv.DictReader(csv_file)
row = next(reader)
# Take the city value if there is one, or fall ba... | [
"pfb_analysis.models.AnalysisJob.objects.get",
"csv.DictReader"
] | [((215, 239), 'csv.DictReader', 'csv.DictReader', (['csv_file'], {}), '(csv_file)\n', (229, 239), False, 'import csv\n'), ((1550, 1586), 'pfb_analysis.models.AnalysisJob.objects.get', 'AnalysisJob.objects.get', ([], {'pk': 'job_uuid'}), '(pk=job_uuid)\n', (1573, 1586), False, 'from pfb_analysis.models import AnalysisJo... |
from __future__ import unicode_literals
import os
import shutil
from django.conf import settings
from docutil.commands_util import mkdir_safe
from project.models import Project, ProjectRelease
CLONE_PATH = 'clone'
DOC_PATH = 'doc'
STHREAD_PATH = 'support'
CODEBASE_PATH = 'code'
NOT_INITIALIZED = 'not initialized'
de... | [
"os.listdir",
"docutil.commands_util.mkdir_safe",
"project.models.ProjectRelease",
"project.models.Project.objects.get",
"shutil.rmtree",
"os.path.join",
"project.models.Project.objects.all",
"project.models.Project"
] | [((478, 510), 'os.path.join', 'os.path.join', (['basepath', 'dir_name'], {}), '(basepath, dir_name)\n', (490, 510), False, 'import os\n'), ((515, 539), 'docutil.commands_util.mkdir_safe', 'mkdir_safe', (['project_path'], {}), '(project_path)\n', (525, 539), False, 'from docutil.commands_util import mkdir_safe\n'), ((77... |
from django.urls import path
from rest_framework_jwt.views import refresh_jwt_token, verify_jwt_token
from authorization.api import resources
app_name = 'authorization'
urlpatterns = (
path(
'login/',
resources.LoginView.as_view(),
name='login'
),
path(
'logout/',
... | [
"authorization.api.resources.LoginView.as_view",
"authorization.api.resources.LogoutView.as_view",
"django.urls.path",
"authorization.api.resources.RestorePasswordRequestView.as_view",
"authorization.api.resources.RegistrationView.as_view",
"authorization.api.resources.RestoreVerifyTokenView.as_view",
"... | [((903, 970), 'django.urls.path', 'path', (['"""token/refresh/"""', 'refresh_jwt_token'], {'name': '"""refresh_jwt_token"""'}), "('token/refresh/', refresh_jwt_token, name='refresh_jwt_token')\n", (907, 970), False, 'from django.urls import path\n'), ((1006, 1070), 'django.urls.path', 'path', (['"""token/verify/"""', '... |
import csv
import uuid
from datetime import datetime
from random import random
file_name = 'C:\\Users\\admin\\Downloads\\meta.csv'
with open(file_name,'w',newline='') as file:
for r in range(300000):
PartitionKey = "File_%s" %r
RowKey = uuid.uuid4().hex
TimeStamp = datetime.now()
... | [
"random.random",
"uuid.uuid4",
"datetime.datetime.now",
"csv.writer"
] | [((297, 311), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (309, 311), False, 'from datetime import datetime\n'), ((395, 403), 'random.random', 'random', ([], {}), '()\n', (401, 403), False, 'from random import random\n'), ((423, 439), 'csv.writer', 'csv.writer', (['file'], {}), '(file)\n', (433, 439), Fa... |
import sys
import logging
logger = logging.getLogger('os-conductor')
handlr = logging.StreamHandler(sys.stderr)
formatter = logging.Formatter('%(asctime)s %(levelname)s %(message)s')
handlr.setFormatter(formatter)
logger.addHandler(handlr)
logger.setLevel(logging.INFO)
es_logger = logging.getLogger('elasticsearch')
e... | [
"logging.Formatter",
"logging.StreamHandler",
"logging.getLogger"
] | [((36, 69), 'logging.getLogger', 'logging.getLogger', (['"""os-conductor"""'], {}), "('os-conductor')\n", (53, 69), False, 'import logging\n'), ((79, 112), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stderr'], {}), '(sys.stderr)\n', (100, 112), False, 'import logging\n'), ((125, 183), 'logging.Formatter', ... |
import os
from setuptools import setup, find_packages
def parse_requirements(file):
with open(os.path.join(os.path.dirname(__file__), file)) as req_file:
return [line.strip() for line in req_file if "/" not in line]
def get_version():
for line in open(os.path.join(os.path.dirname(__file__), "hiector... | [
"os.path.dirname",
"setuptools.find_packages"
] | [((827, 842), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (840, 842), False, 'from setuptools import setup, find_packages\n'), ((285, 310), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (300, 310), False, 'import os\n'), ((113, 138), 'os.path.dirname', 'os.path.dirname', (... |
from typing import List
from neuralogic.core import Relation, Template, Var, Metadata, Activation, Aggregation
from neuralogic.utils.templates.modules import AbstractModule
class GINConv(AbstractModule):
def __init__(
self,
in_channels: int,
out_channels: int,
*,
activatio... | [
"neuralogic.core.Metadata",
"neuralogic.core.Relation.get"
] | [((1555, 1573), 'neuralogic.core.Relation.get', 'Relation.get', (['name'], {}), '(name)\n', (1567, 1573), False, 'from neuralogic.core import Relation, Template, Var, Metadata, Activation, Aggregation\n'), ((1073, 1097), 'neuralogic.core.Relation.get', 'Relation.get', (['embed_name'], {}), '(embed_name)\n', (1085, 1097... |
import traceback
from typing import Callable, Any
from enum import IntEnum
import asyncio
from .frame import read_frame
from .sender import (
send_connection_start,
send_connection_tune,
send_connection_ok,
send_connection_close_ok,
send_heartbeat,
send_content_header,
send_content_body,
... | [
"traceback.format_exception"
] | [((1825, 1893), 'traceback.format_exception', 'traceback.format_exception', (['None', 'exception', 'exception.__traceback__'], {}), '(None, exception, exception.__traceback__)\n', (1851, 1893), False, 'import traceback\n')] |
"""
Package manifest related functionalities
"""
import logging
from ocs_ci.ocs.ocp import OCP, defaults
from ocs_ci.utility.utils import TimeoutSampler
log = logging.getLogger(__name__)
class PackageManifest(OCP):
"""
This class represent PackageManifest and contains all related methods.
"""
def ... | [
"logging.getLogger",
"ocs_ci.utility.utils.TimeoutSampler"
] | [((162, 189), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (179, 189), False, 'import logging\n'), ((3059, 3118), 'ocs_ci.utility.utils.TimeoutSampler', 'TimeoutSampler', ([], {'timeout': 'timeout', 'sleep': 'sleep', 'func': 'self.get'}), '(timeout=timeout, sleep=sleep, func=self.get)\n... |
import os
import subprocess
from setuptools import setup, find_packages
# Version number is determined either by git revision (which takes precendence)
# or a static version number which is updated by bump2version
__version_tag__ = "3.3.dev"
console_scripts = [
"dev.xia2.check_mosaic=xia2.cli.check_mosaic:run",
... | [
"subprocess.run",
"os.path.realpath",
"os.path.join",
"setuptools.find_packages"
] | [((2213, 2371), 'subprocess.run', 'subprocess.run', (["('git', 'describe', '--long')"], {'check': '(True)', 'cwd': 'xia2_root_path', 'encoding': '"""latin-1"""', 'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.DEVNULL'}), "(('git', 'describe', '--long'), check=True, cwd=\n xia2_root_path, encoding='latin-1', stdo... |
# Generated by Django 2.1.2 on 2018-12-06 04:28
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
... | [
"django.db.models.TextField",
"django.db.migrations.swappable_dependency",
"django.db.models.BinaryField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.migrations.DeleteModel",
"django.db.models.AutoField",
"django.db.models.IntegerField",
"django.db.models.DecimalField",
... | [((256, 313), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (287, 313), False, 'from django.db import migrations, models\n'), ((2940, 2975), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
cobra
~~~~~
Implements cobra main
:author: Feei <<EMAIL>>
:homepage: https://github.com/wufeifei/cobra
:license: MIT, see LICENSE for more details.
:copyright: Copyright (c) 2017 Feei. All rights reserved
"""
import codecs
import dic... | [
"codecs.open",
"setuptools.find_packages"
] | [((2449, 2492), 'setuptools.find_packages', 'setuptools.find_packages', ([], {'exclude': "['tests']"}), "(exclude=['tests'])\n", (2473, 2492), False, 'import setuptools\n'), ((456, 494), 'codecs.open', 'codecs.open', (['"""README.md"""', '"""r"""', '"""utf-8"""'], {}), "('README.md', 'r', 'utf-8')\n", (467, 494), False... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import django.core.validators
import uuid
class Migration(migrations.Migration):
dependencies = [
('assets', '0001_initial'),
('terms_of_service', '0001_initial'),
]
operations = [
... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.PositiveIntegerField",
"django.db.models.AutoField",
"django.db.models.DecimalField"
] | [((8573, 8737), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'related_name': '"""activitypricelistitem_set"""', 'to': '"""price_list.PriceList"""', 'help_text': "b'Which price list does this price list item belong in?'"}), "(related_name='activitypricelistitem_set', to=\n 'price_list.PriceList', help_te... |
"""微信支付模块主文件"""
from socket import gethostname
from typing import Tuple, Dict, Callable, Optional, NoReturn
import cacheout
from ...core.schedule import DAY
from ...core.tools import web, time
from ...core.abstract import payment
from . import const
from . import settings
from . import signature
class WXPayment(p... | [
"cacheout.Cache",
"socket.gethostname"
] | [((428, 451), 'cacheout.Cache', 'cacheout.Cache', ([], {'ttl': 'DAY'}), '(ttl=DAY)\n', (442, 451), False, 'import cacheout\n'), ((2261, 2274), 'socket.gethostname', 'gethostname', ([], {}), '()\n', (2272, 2274), False, 'from socket import gethostname\n')] |
# *-* coding: utf-8 *-*
from __future__ import unicode_literals
import argparse
import datetime
from langdetect import detect
import MySQLdb
import pandas as pd
import sys
# USES PYTHON 2!!
def addNegatives(conn, tablename, fakeSrcDict):
err_count = 0
nb_negatives = 0
cur = executeSql(conn, "SELECT * fro... | [
"pandas.DataFrame",
"MySQLdb.connect",
"argparse.ArgumentParser",
"sys.stderr.write",
"langdetect.detect",
"datetime.datetime.now",
"pandas.concat"
] | [((6142, 6203), 'pandas.DataFrame', 'pd.DataFrame', (['(train_data_isPP + train_data_noPP)'], {'columns': 'keys'}), '(train_data_isPP + train_data_noPP, columns=keys)\n', (6154, 6203), True, 'import pandas as pd\n'), ((6220, 6279), 'pandas.DataFrame', 'pd.DataFrame', (['(test_data_isPP + test_data_noPP)'], {'columns': ... |
#!/usr/bin/env python3
from setuptools import setup, find_packages
import platform
__requires = list(filter(None, open('requirements.txt').read().splitlines()))
if platform.python_implementation() == 'PyPy':
__requires.append('git+git://github.com/schmir/gevent@pypy-hacks')
__requires.append('git+git://github.... | [
"platform.python_implementation",
"setuptools.find_packages"
] | [((165, 197), 'platform.python_implementation', 'platform.python_implementation', ([], {}), '()\n', (195, 197), False, 'import platform\n'), ((629, 644), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (642, 644), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/env python3
import os
from hashing.hash import compute_file_hash
from clients.http import HttpClient
def is_valid_file(abs_path):
"""
Checking validity of file path provided
"""
if os.path.exists(abs_path) and os.path.isfile(abs_path) \
and not os.path.islink(abs_path):
re... | [
"os.walk",
"os.path.exists",
"hashing.hash.compute_file_hash",
"clients.http.HttpClient",
"os.path.isfile",
"os.path.islink",
"os.path.join"
] | [((640, 785), 'clients.http.HttpClient', 'HttpClient', ([], {'api_scheme': 'api_scheme', 'api_host': 'api_host', 'api_port': 'api_port', 'logger': 'logger', 'version': 'version', 'username': 'username', 'password': 'password'}), '(api_scheme=api_scheme, api_host=api_host, api_port=api_port,\n logger=logger, version=... |
# -*- coding: utf-8 -*-
from collections import OrderedDict
from django import template
from django.conf import settings
from django.utils.html import escape
from django.utils.http import urlencode
from django.utils.safestring import mark_safe
register = template.Library()
GITHUB_HOSTNAME = 'github'
GITLAB_HOSTNAME... | [
"collections.OrderedDict",
"django.template.Library",
"django.utils.http.urlencode"
] | [((257, 275), 'django.template.Library', 'template.Library', ([], {}), '()\n', (273, 275), False, 'from django import template\n'), ((1124, 1137), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1135, 1137), False, 'from collections import OrderedDict\n'), ((1216, 1246), 'django.utils.http.urlencode', 'url... |
import inspect
import types
import typing
import forge._immutable as immutable
from forge._marker import empty
class CallArguments(immutable.Immutable):
"""
An immutable container for call arguments, i.e. term:`var-positional`
(e.g. ``*args``) and :term:`var-keyword` (e.g. ``**kwargs``).
:param args... | [
"types.MappingProxyType",
"inspect.signature"
] | [((7924, 7951), 'inspect.signature', 'inspect.signature', (['callable'], {}), '(callable)\n', (7941, 7951), False, 'import inspect\n'), ((4396, 4418), 'inspect.signature', 'inspect.signature', (['to_'], {}), '(to_)\n', (4413, 4418), False, 'import inspect\n'), ((616, 646), 'types.MappingProxyType', 'types.MappingProxyT... |
from __future__ import print_function
import os
from struct import unpack
import zipfile
import numpy as np
import csv
from operator import itemgetter
from datetime import datetime, timedelta, timezone
import warnings
from collections import namedtuple
# Error Management
class SatlanticInstrumentError(Exception):
... | [
"zipfile.ZipFile",
"csv.writer",
"os.stat",
"os.path.basename",
"os.path.isdir",
"os.path.dirname",
"struct.unpack",
"datetime.datetime",
"datetime.datetime.utcfromtimestamp",
"datetime.datetime.strptime",
"datetime.timedelta",
"collections.namedtuple",
"os.path.splitext",
"warnings.warn",... | [((901, 971), 'collections.namedtuple', 'namedtuple', (['"""FrameContainer"""', "['header', 'data', 'timestamp', 'valid']"], {}), "('FrameContainer', ['header', 'data', 'timestamp', 'valid'])\n", (911, 971), False, 'from collections import namedtuple\n'), ((23454, 23473), 'os.listdir', 'os.listdir', (['dirname'], {}), ... |
import logging
import os
import pickle as pkl
import tempfile
import threading
import queue
import re
import xgboost as xgb
from xgboost import rabit
from xgboost.core import Booster, XGBoostError
from xgboost.callback import _fmt_metric as format_metric
TEMP_FILE_SUFFIX = ".sagemaker-ignore"
FILE_LOCK_SUFFIX = ".sag... | [
"pickle.dump",
"os.remove",
"os.path.isfile",
"os.path.join",
"xgboost.train",
"os.path.exists",
"xgboost.core.Booster",
"threading.Thread",
"os.rename",
"re.match",
"os.listdir",
"queue.Queue",
"tempfile.NamedTemporaryFile",
"logging.debug",
"os.makedirs",
"logging.basicConfig",
"xg... | [((433, 460), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (450, 460), False, 'import logging\n'), ((461, 500), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (480, 500), False, 'import logging\n'), ((1898, 1921), 'xgboost.train'... |
import importlib
import pytest
from mock import Mock
from datman.scanid import ParseException
import datman.config
rc = importlib.import_module('bin.dm_redcap_scan_completed')
class TestParseID:
datman_id = "ABC01_DEF_0001_01_01"
def test_datman_id_parsed_correctly(self, config):
rc.cfg = config
... | [
"pytest.raises",
"mock.Mock",
"importlib.import_module"
] | [((123, 178), 'importlib.import_module', 'importlib.import_module', (['"""bin.dm_redcap_scan_completed"""'], {}), "('bin.dm_redcap_scan_completed')\n", (146, 178), False, 'import importlib\n'), ((2622, 2653), 'mock.Mock', 'Mock', ([], {'spec': 'datman.config.config'}), '(spec=datman.config.config)\n', (2626, 2653), Fal... |
# Author: <NAME> (<EMAIL>)
# Center for Machine Perception, Czech Technical University in Prague
"""Visualizes object models in the ground-truth poses."""
import os
import numpy as np
from lib.pysixd import config
from lib.pysixd import dataset_params
from lib.pysixd import inout
from lib.pysixd import misc
from lib... | [
"numpy.dstack",
"lib.pysixd.renderer.create_renderer",
"os.path.dirname",
"lib.pysixd.visualization.vis_object_poses",
"lib.pysixd.misc.log",
"lib.pysixd.dataset_params.get_present_scene_ids",
"lib.pysixd.dataset_params.get_model_params",
"lib.pysixd.dataset_params.get_split_params",
"lib.pysixd.ino... | [((2580, 2695), 'lib.pysixd.dataset_params.get_split_params', 'dataset_params.get_split_params', (["p['datasets_path']", "p['dataset']", "p['dataset_split']", "p['dataset_split_type']"], {}), "(p['datasets_path'], p['dataset'], p[\n 'dataset_split'], p['dataset_split_type'])\n", (2611, 2695), False, 'from lib.pysixd... |
# -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------
#
# Copyright 2018-2019 Fetch.AI Limited
#
# 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 ... | [
"json.loads",
"json.dumps"
] | [((2075, 2091), 'json.loads', 'json.loads', (['data'], {}), '(data)\n', (2085, 2091), False, 'import json\n'), ((2397, 2415), 'json.dumps', 'json.dumps', (['loaded'], {}), '(loaded)\n', (2407, 2415), False, 'import json\n')] |
"""
.. module:: test_class
:synopsis: python script for testing CLASS using nose
.. moduleauthor:: <NAME> <<EMAIL>>
.. credits:: <NAME>, <NAME>
.. version:: 1.0
This is a python script for testing CLASS and its wrapper Classy using nose.
To run the test suite, type
nosetests test_class.py
If you want to extract th... | [
"sys.stdout.write",
"os.mkdir",
"numpy.abs",
"numpy.shape",
"matplotlib.pyplot.figure",
"shutil.rmtree",
"numpy.testing.assert_array_almost_equal",
"os.path.join",
"unittest.main",
"nose_parameterized.parameterized.expand",
"math.log10",
"itertools.product",
"numpy.testing.assert_allclose",
... | [((8319, 8352), 'nose_parameterized.parameterized.expand', 'parameterized.expand', (['TUPLE_ARRAY'], {}), '(TUPLE_ARRAY)\n', (8339, 8352), False, 'from nose_parameterized import parameterized\n'), ((20305, 20320), 'unittest.main', 'unittest.main', ([], {}), '()\n', (20318, 20320), False, 'import unittest\n'), ((5874, 5... |
import keras
from keras.datasets import cifar10
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
from keras.callbacks import TensorBoard
from keras.constraints import max_norm
import matplotlib.pyplot as plt... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"keras.datasets.cifar10.load_data",
"matplotlib.pyplot.plot",
"keras.backend.image_data_format",
"keras.optimizers.SGD",
"keras.layers.Dropout",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.ylabel",
"keras.layers.Flatten",
"keras.optimizers.... | [((676, 695), 'keras.datasets.cifar10.load_data', 'cifar10.load_data', ([], {}), '()\n', (693, 695), False, 'from keras.datasets import cifar10\n'), ((1677, 1729), 'keras.utils.to_categorical', 'keras.utils.to_categorical', (['target_train', 'no_classes'], {}), '(target_train, no_classes)\n', (1703, 1729), False, 'impo... |
import sys
import os
if __name__ == "__main__":
try:
if len(sys.argv) < 2:
raise Exception("Need a path as parameter.")
path = sys.argv[1]
if os.path.isfile(path):
theFile = open(path)
content = theFile.read(4096)
print(content)
elif o... | [
"os.path.isdir",
"os.path.isfile",
"os.listdir"
] | [((183, 203), 'os.path.isfile', 'os.path.isfile', (['path'], {}), '(path)\n', (197, 203), False, 'import os\n'), ((319, 338), 'os.path.isdir', 'os.path.isdir', (['path'], {}), '(path)\n', (332, 338), False, 'import os\n'), ((365, 381), 'os.listdir', 'os.listdir', (['path'], {}), '(path)\n', (375, 381), False, 'import o... |
import random
import string
import traceback
from ceph.ceph import CommandFailed
from tests.cephfs.cephfs_utilsV1 import FsUtils
from utility.log import Log
log = Log(__name__)
def run(ceph_cluster, **kw):
try:
log.info(f"MetaData Information {log.metadata} in {__name__}")
fs_util = FsUtils(ceph... | [
"utility.log.Log",
"tests.cephfs.cephfs_utilsV1.FsUtils",
"random.choice",
"traceback.format_exc",
"ceph.ceph.CommandFailed"
] | [((165, 178), 'utility.log.Log', 'Log', (['__name__'], {}), '(__name__)\n', (168, 178), False, 'from utility.log import Log\n'), ((308, 329), 'tests.cephfs.cephfs_utilsV1.FsUtils', 'FsUtils', (['ceph_cluster'], {}), '(ceph_cluster)\n', (315, 329), False, 'from tests.cephfs.cephfs_utilsV1 import FsUtils\n'), ((1354, 139... |
# -*- coding: utf-8 -*-
#
# Copyright (C) 2019 CERN.
#
# My site is free software; you can redistribute it and/or modify it under
# the terms of the MIT License; see LICENSE file for more details.
"""JSON Schemas."""
from __future__ import absolute_import, print_function
from invenio_jsonschemas.proxies import curre... | [
"marshmallow.fields.Str",
"invenio_records_rest.schemas.fields.PersistentIdentifier",
"invenio_records_rest.schemas.fields.SanitizedUnicode",
"marshmallow.fields.Nested"
] | [((656, 678), 'invenio_records_rest.schemas.fields.PersistentIdentifier', 'PersistentIdentifier', ([], {}), '()\n', (676, 678), False, 'from invenio_records_rest.schemas.fields import DateString, PersistentIdentifier, SanitizedUnicode\n'), ((690, 721), 'invenio_records_rest.schemas.fields.SanitizedUnicode', 'SanitizedU... |
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
df1 = pd.DataFrame({'one': [1,2,3], 'two': [10,20,30]}, index=['a','b','c'])
df2 = pd.DataFrame({'one': [4], 'three': [400]}, index=['d'])
df = pd.concat([df1,df2])
print(df)
#フォルダ指定
output_folder = (r'C:\Users\pcabe1908\Documents\Git... | [
"pandas.DataFrame",
"cv2.line",
"cv2.bitwise_not",
"cv2.cvtColor",
"cv2.imwrite",
"numpy.zeros",
"cv2.imread",
"cv2.HoughLinesP",
"pandas.concat"
] | [((89, 165), 'pandas.DataFrame', 'pd.DataFrame', (["{'one': [1, 2, 3], 'two': [10, 20, 30]}"], {'index': "['a', 'b', 'c']"}), "({'one': [1, 2, 3], 'two': [10, 20, 30]}, index=['a', 'b', 'c'])\n", (101, 165), True, 'import pandas as pd\n'), ((166, 221), 'pandas.DataFrame', 'pd.DataFrame', (["{'one': [4], 'three': [400]}... |
"""Some PyNE testing utilities."""
from __future__ import print_function
import os
import sys
import ssl
from hashlib import md5
try:
import urllib.request as urllib
except ImportError:
import urllib2 as urllib
def ssl_context():
# this is compitble for both Python 2 & 3
# on Python 3, you can do jus... | [
"ssl.create_default_context",
"os.path.isfile",
"urllib2.Request",
"hashlib.md5"
] | [((349, 377), 'ssl.create_default_context', 'ssl.create_default_context', ([], {}), '()\n', (375, 377), False, 'import ssl\n'), ((576, 601), 'os.path.isfile', 'os.path.isfile', (['localfile'], {}), '(localfile)\n', (590, 601), False, 'import os\n'), ((798, 856), 'urllib2.Request', 'urllib.Request', (['url'], {'headers'... |
from datetime import datetime, timedelta
import humanize
from PySide2.QtWidgets import QSystemTrayIcon
from node_launcher.node_set.lib.managed_process import ManagedProcess
from node_launcher.node_set.lib.node_status import NodeStatus
class BitcoindProcess(ManagedProcess):
def __init__(self, binary, args):
... | [
"datetime.datetime.strptime",
"datetime.timedelta"
] | [((1457, 1507), 'datetime.datetime.strptime', 'datetime.strptime', (['timestamp', '"""%Y-%m-%dT%H:%M:%SZ"""'], {}), "(timestamp, '%Y-%m-%dT%H:%M:%SZ')\n", (1474, 1507), False, 'from datetime import datetime, timedelta\n'), ((2427, 2463), 'datetime.timedelta', 'timedelta', ([], {'seconds': 'average_time_left'}), '(secon... |
#
# -= ml_frameGraphEditor.py =-
# __ by <NAME>
# ____ ___ / / http://morganloomis.com
# / __ `__ \/ / Licensed under Creative Commons BY-SA
# / / / / / / / http://creativecommons.org/licenses/by-sa/3.0/
# /_/ /_/ /_/_/ _________
# /___... | [
"maya.cmds.showHelp",
"maya.mel.eval",
"ml_utilities.KeySelection",
"maya.cmds.confirmDialog",
"maya.cmds.animView",
"maya.cmds.getPanel",
"maya.cmds.animCurveEditor",
"ml_utilities.upToDateCheck",
"maya.cmds.scriptedPanel"
] | [((2355, 2376), 'ml_utilities.upToDateCheck', 'utl.upToDateCheck', (['(18)'], {}), '(18)\n', (2372, 2376), True, 'import ml_utilities as utl\n'), ((3363, 3383), 'maya.cmds.getPanel', 'mc.getPanel', ([], {'up': '(True)'}), '(up=True)\n', (3374, 3383), True, 'import maya.cmds as mc\n'), ((3501, 3522), 'maya.cmds.getPanel... |
"""Wrapper objects for Unreal code templates."""
# Standard Library
import copy
import re
from typing import Set
class CodeTemplateError(Exception):
"""Custom exception representing errors encountered with CodeTemplate."""
class CodeTemplate(object):
"""Object wrapper for working with Unreal's code templat... | [
"copy.copy",
"re.compile"
] | [((359, 408), 're.compile', 're.compile', (['"""\\\\%([A-Z_]+)\\\\%"""'], {'flags': 're.MULTILINE'}), "('\\\\%([A-Z_]+)\\\\%', flags=re.MULTILINE)\n", (369, 408), False, 'import re\n'), ((1431, 1462), 'copy.copy', 'copy.copy', (['self.template_string'], {}), '(self.template_string)\n', (1440, 1462), False, 'import copy... |
import os
from collections import OrderedDict
from ..base import get_logger
from .base import Generator, filepath, mode_iter, ISO_KEYS, get_bin_resource
from ..cldr import CP_REGEX
logger = get_logger(__name__)
keysym_to_str = {}
with get_bin_resource("keysym.tsv", text=True) as f:
line = f.readline()
while... | [
"collections.OrderedDict",
"os.path.abspath",
"os.path.join",
"os.makedirs"
] | [((724, 737), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (735, 737), False, 'from collections import OrderedDict\n'), ((1061, 1082), 'os.path.abspath', 'os.path.abspath', (['base'], {}), '(base)\n', (1076, 1082), False, 'import os\n'), ((1091, 1133), 'os.makedirs', 'os.makedirs', (['self.build_dir'], {... |
#!/usr/bin/env python3
import utils
utils.check_version((3,7))
utils.clear()
print('Hello, my name is <NAME>')
print('My favorite game is Devil Survivor.')
print('I dont have any particular concerns about this class')
print('Im excited to make some games')
print('My Stackoverflow number is 11980745')
print('The url ... | [
"utils.clear",
"utils.check_version"
] | [((38, 65), 'utils.check_version', 'utils.check_version', (['(3, 7)'], {}), '((3, 7))\n', (57, 65), False, 'import utils\n'), ((65, 78), 'utils.clear', 'utils.clear', ([], {}), '()\n', (76, 78), False, 'import utils\n')] |
#!/usr/bin/env python
import os
import os.path
import json
from flask import Flask, request, render_template
import requests
import sys
import subprocess
from pathlib import Path
import time
from flask import jsonify
app = Flask(__name__)
##############################################################################... | [
"subprocess.Popen",
"os.remove",
"json.load",
"json.loads",
"flask.Flask",
"os.path.exists",
"json.dumps",
"time.sleep",
"flask.jsonify",
"pathlib.Path",
"sys.stdout.flush",
"flask.render_template",
"os.path.expanduser",
"flask.request.get_json"
] | [((225, 240), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (230, 240), False, 'from flask import Flask, request, render_template\n'), ((913, 946), 'os.path.exists', 'os.path.exists', (['database_filename'], {}), '(database_filename)\n', (927, 946), False, 'import os\n'), ((1275, 1306), 'os.path.exists', ... |
# encoding: utf-8
import sys
import traceback
from datetime import timedelta
from django.contrib.contenttypes import generic
from django.db import models
from django.utils.translation import ugettext_lazy as _
from tagging.models import TaggedItem, Tag
from laws import constants
from laws.enums import VOTE_TYPES
from... | [
"django.db.models.TextField",
"simple.management.commands.syncdata.Command",
"tagvotes.models.TagVote.objects.filter",
"agendas.models.AgendaVote.objects.filter",
"laws.models.vote_action.VoteAction.objects.get_or_create",
"tagging.models.Tag.objects.get_for_object",
"django.utils.translation.ugettext_l... | [((591, 636), 'logging.getLogger', 'logging.getLogger', (['"""open-knesset.laws.models"""'], {}), "('open-knesset.laws.models')\n", (608, 636), False, 'import logging\n'), ((2762, 2804), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'null': '(True)', 'blank': '(True)'}), '(null=True, blank=True)\n', (27... |
from cumulusci.core.exceptions import DependencyLookupError
from datetime import datetime
import pytest
import responses
from cumulusci.core.config import OrgConfig
from cumulusci.core.config import ServiceConfig
from cumulusci.core.config import TaskConfig
from cumulusci.tests.util import create_project_config
from ... | [
"cumulusci.tasks.github.commit_status.GetPackageDataFromCommitStatus",
"responses.add",
"cumulusci.core.config.ServiceConfig",
"cumulusci.core.config.TaskConfig",
"pytest.raises",
"cumulusci.tests.util.create_project_config",
"datetime.datetime.now",
"cumulusci.core.config.OrgConfig"
] | [((737, 815), 'responses.add', 'responses.add', ([], {'method': 'responses.GET', 'url': 'self.repo_api_url', 'json': 'repo_response'}), '(method=responses.GET, url=self.repo_api_url, json=repo_response)\n', (750, 815), False, 'import responses\n'), ((1000, 1499), 'responses.add', 'responses.add', ([], {'method': 'respo... |
import argparse
import itertools
from doc2vec.data import batch_dm, batch_dbow, doc
from doc2vec.model import dm, dbow, model
from doc2vec import vocab
MODEL_TYPES = {
'dm': (dm.DM, batch_dm.data_generator, batch_dm.batch),
'dbow': (dbow.DBOW, batch_dbow.data_generator, batch_dbow.batch)
}
def _parse_args(... | [
"doc2vec.vocab.Vocabulary",
"argparse.ArgumentParser",
"doc2vec.data.doc.tokens_by_doc_id"
] | [((336, 361), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (359, 361), False, 'import argparse\n'), ((3202, 3233), 'doc2vec.data.doc.tokens_by_doc_id', 'doc.tokens_by_doc_id', (['args.path'], {}), '(args.path)\n', (3222, 3233), False, 'from doc2vec.data import batch_dm, batch_dbow, doc\n'), (... |
from huobi.constant import *
class OrderListItem:
"""
The order update received by request of order list.
:member
symbol: The symbol you subscribed.
timestamp: The UNIX formatted timestamp generated by server in UTC.
topic: request topic
client_req_id: client request ID
... | [
"huobi.utils.print_mix_object.PrintBasic.print_basic"
] | [((987, 1038), 'huobi.utils.print_mix_object.PrintBasic.print_basic', 'PrintBasic.print_basic', (['self.id', "(format_data + 'ID')"], {}), "(self.id, format_data + 'ID')\n", (1009, 1038), False, 'from huobi.utils.print_mix_object import PrintBasic\n'), ((1047, 1106), 'huobi.utils.print_mix_object.PrintBasic.print_basic... |
"""
Convenience functions for moving around runtime configuration parameters
(e.g., batch size), and neural network training parameters (e.g.,
hyperparameters).
This file also contains the fixed parameters used by previous paper
for various different tasks.
"""
import argparse
GLUE_TASK_NAMES = [
"cola",
"ss... | [
"argparse.Namespace"
] | [((921, 941), 'argparse.Namespace', 'argparse.Namespace', ([], {}), '()\n', (939, 941), False, 'import argparse\n')] |
import base64
import io
import keras
import numpy as np
from flask import Flask, jsonify, request
from keras import backend as K
from keras.models import Sequential, load_model
from keras.preprocessing.image import ImageDataGenerator, img_to_array
from PIL import Image
app = Flask(__name__)
def get_model():
glob... | [
"keras.models.load_model",
"io.BytesIO",
"flask.Flask",
"numpy.expand_dims",
"base64.b64decode",
"keras.preprocessing.image.img_to_array",
"flask.jsonify",
"flask.request.get_json"
] | [((278, 293), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (283, 293), False, 'from flask import Flask, jsonify, request\n'), ((341, 377), 'keras.models.load_model', 'load_model', (['"""VGG16_cats_and_dogs.h5"""'], {}), "('VGG16_cats_and_dogs.h5')\n", (351, 377), False, 'from keras.models import Sequenti... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import zmq, time
_PORT = 'tcp://127.0.0.1:42569'
if(__name__ == '__main__'):
_context = zmq.Context()
socket = _context.socket(zmq.PUB)
socket.connect(_PORT)
num = 0
while(True):
string = socket.send(str(num))
print(num)
num = ... | [
"zmq.Context"
] | [((141, 154), 'zmq.Context', 'zmq.Context', ([], {}), '()\n', (152, 154), False, 'import zmq, time\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
:Mod: embargo_pool
:Synopsis:
:Author:
servilla
:Created:
7/31/20
"""
from datetime import datetime
from pathlib import Path
from typing import List, Tuple, Set
import daiquiri
from lxml import etree
import requests
from sqlalchemy.exc import IntegrityError... | [
"sniffer.model.embargo_db.EmbargoDB",
"sniffer.package.package_pool.PackagePool",
"sniffer.config.Config.METADATA_URL.replace",
"sniffer.last_date.write",
"sniffer.model.pasta_data_package_manager_db.query",
"requests.get",
"daiquiri.getLogger",
"sniffer.last_date.read"
] | [((572, 600), 'daiquiri.getLogger', 'daiquiri.getLogger', (['__name__'], {}), '(__name__)\n', (590, 600), False, 'import daiquiri\n'), ((2031, 2083), 'sniffer.model.pasta_data_package_manager_db.query', 'pasta_data_package_manager_db.query', (['SQL_NEWEST_PIDS'], {}), '(SQL_NEWEST_PIDS)\n', (2066, 2083), False, 'from s... |
#!/usr/bin/env python
# -*- mode: python; encoding: utf-8 -*-
"""An implementation of a data store based on mysql."""
import Queue
import threading
import time
import MySQLdb
from MySQLdb import cursors
from grr.lib import config_lib
from grr.lib import data_store
from grr.lib import rdfvalue
from grr.lib import ut... | [
"MySQLdb.connect",
"grr.lib.rdfvalue.RDFDatetime",
"grr.lib.utils.SmartUnicode",
"Queue.Queue",
"time.time",
"threading.Lock",
"time.sleep",
"grr.lib.data_store.TransactionError",
"grr.lib.utils.SmartStr"
] | [((2930, 2943), 'Queue.Queue', 'Queue.Queue', ([], {}), '()\n', (2941, 2943), False, 'import Queue\n'), ((3390, 3406), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (3404, 3406), False, 'import threading\n'), ((10641, 10668), 'grr.lib.utils.SmartUnicode', 'utils.SmartUnicode', (['subject'], {}), '(subject)\n', ... |
from unittest import TestCase, main
from project import Mammal
class TestMammal(TestCase):
def setUp(self) -> None:
self.mammal = Mammal('Peter', 'Lion', 'Roar')
def test_initializer(self):
self.assertEqual('Peter', self.mammal.name)
self.assertEqual('Lion', self.mammal.type)
... | [
"unittest.main",
"project.Mammal"
] | [((1012, 1018), 'unittest.main', 'main', ([], {}), '()\n', (1016, 1018), False, 'from unittest import TestCase, main\n'), ((144, 175), 'project.Mammal', 'Mammal', (['"""Peter"""', '"""Lion"""', '"""Roar"""'], {}), "('Peter', 'Lion', 'Roar')\n", (150, 175), False, 'from project import Mammal\n')] |
from setuptools import setup
setup(
name='formal-changer',
version='0.0.1',
description='formal text change test Forked from Alpjt-1',
url='https://github.com/alalshow/AIpjt-1.git',
author='alalshow',
author_email='<EMAIL>',
license='MIT',
packages=['formal_changer'],
zip_safe=False... | [
"setuptools.setup"
] | [((30, 376), 'setuptools.setup', 'setup', ([], {'name': '"""formal-changer"""', 'version': '"""0.0.1"""', 'description': '"""formal text change test Forked from Alpjt-1"""', 'url': '"""https://github.com/alalshow/AIpjt-1.git"""', 'author': '"""alalshow"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'pack... |
from pathlib import Path
import pandas as pd
from DigitOps import DigitTranscriber
FOLDER_WITH_TRANSCRIPTS = Path("b:/!DATASETS/CommonVoice/cs/")
PATHS_TO_TRANSCRIPTS = [str(f) for f in FOLDER_WITH_TRANSCRIPTS.glob("**/*.tsv")]
if __name__ == '__main__':
print(PATHS_TO_TRANSCRIPTS)
dt = DigitTranscriber()
... | [
"pandas.read_csv",
"pathlib.Path",
"DigitOps.DigitTranscriber"
] | [((112, 148), 'pathlib.Path', 'Path', (['"""b:/!DATASETS/CommonVoice/cs/"""'], {}), "('b:/!DATASETS/CommonVoice/cs/')\n", (116, 148), False, 'from pathlib import Path\n'), ((301, 319), 'DigitOps.DigitTranscriber', 'DigitTranscriber', ([], {}), '()\n', (317, 319), False, 'from DigitOps import DigitTranscriber\n'), ((371... |
#!/usr/bin/env python
__author__ = "<NAME>"
"""
Dear god this is the ugliest piece of shit source I've ever written.
Here's a cat to cheer you up until I fix it.
\`*-.
) _`-.
. : `. .
: _ ' \
; *` _. `*-._
`-.-' ... | [
"matplotlib.colors.LinearSegmentedColormap",
"argparse.ArgumentParser",
"pyDNase.BAMHandler",
"pylab.gca",
"pylab.xticks",
"pylab.savefig",
"pylab.subplot2grid",
"pylab.figure",
"pylab.tight_layout",
"numpy.mean",
"numpy.array",
"pyDNase.GenomicIntervalSet",
"clint.textui.progress.bar"
] | [((794, 903), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Plots a report of cuts, footprint scores, and conservation scores"""'}), "(description=\n 'Plots a report of cuts, footprint scores, and conservation scores')\n", (817, 903), False, 'import argparse\n'), ((1460, 1490), 'pyDN... |
from os import path
from typing import Any, Union
import yaml
from kubernetes import client, config, utils
import boto3
import string
import random
import base64
from botocore.signers import RequestSigner
import re
from awsdest.utils.core_aws import *
import time
############
def _get_bearer_token(aw... | [
"boto3.client",
"kubernetes.client.V1DeleteOptions",
"yaml.dump",
"kubernetes.client.V1ObjectMeta",
"kubernetes.client.api_client.ApiClient",
"kubernetes.client.V1PodSpec",
"os.path.exists",
"kubernetes.client.CoreV1Api",
"kubernetes.client.AppsV1Api",
"re.sub",
"time.sleep",
"kubernetes.clien... | [((519, 677), 'boto3.session.Session', 'boto3.session.Session', ([], {'aws_access_key_id': "awsconfig['aws_access_key_id']", 'aws_secret_access_key': "awsconfig['aws_secret_access_key']", 'region_name': 'region'}), "(aws_access_key_id=awsconfig['aws_access_key_id'],\n aws_secret_access_key=awsconfig['aws_secret_acce... |
r"""
Pruning methods
"""
import numbers
from abc import ABC, abstractmethod
from collections.abc import Iterable
from typing import Tuple
import torch
class BasePruningMethod(ABC):
r"""Abstract base class for creation of new pruning techniques.
Provides a skeleton for customization requiring the overriding ... | [
"torch.ones_like",
"torch.topk",
"torch.zeros_like",
"torch.norm",
"torch.rand_like",
"torch.kthvalue",
"torch.rand",
"torch.abs"
] | [((56681, 56709), 'torch.norm', 'torch.norm', (['t'], {'p': 'n', 'dim': 'dims'}), '(t, p=n, dim=dims)\n', (56691, 56709), False, 'import torch\n'), ((31704, 31752), 'torch.topk', 'torch.topk', (['norm'], {'k': 'nparams_tokeep', 'largest': '(True)'}), '(norm, k=nparams_tokeep, largest=True)\n', (31714, 31752), False, 'i... |
n = int(input())
words = {}
for i in range(n):
words[input()] = 1
def compare(x, y):
if x == y:
return 0
elif len(x) != len(y):
return len(x) - len(y)
elif x < y:
return -1
else:
return 1
import functools
cmp = functools.cmp_to_key(compare)
dedup = list(word... | [
"functools.cmp_to_key"
] | [((273, 302), 'functools.cmp_to_key', 'functools.cmp_to_key', (['compare'], {}), '(compare)\n', (293, 302), False, 'import functools\n')] |
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import math
matplotlib.style.use('seaborn')
data = np.genfromtxt(fname="../build/random_avg_error.txt", # globalerror / relative_error / random_avg_error
dtype=np.float32,
delimiter=' ',
... | [
"matplotlib.pyplot.show",
"matplotlib.style.use",
"matplotlib.pyplot.legend",
"numpy.genfromtxt",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.semilogy",
"matplotlib.pyplot.xlabel"
] | [((82, 113), 'matplotlib.style.use', 'matplotlib.style.use', (['"""seaborn"""'], {}), "('seaborn')\n", (102, 113), False, 'import matplotlib\n'), ((122, 226), 'numpy.genfromtxt', 'np.genfromtxt', ([], {'fname': '"""../build/random_avg_error.txt"""', 'dtype': 'np.float32', 'delimiter': '""" """', 'skip_header': '(0)'}),... |
from lxml.html import document_fromstring
from lxml.etree import strip_elements
from pathlib import Path
# from urllib.parse import urlparse, unquote
# from urllib.robotparser import RobotFileParser
# from urllib.request import urlopen, Request
# import json
class WikipediaArticle:
"""Structured reprenstentation ... | [
"lxml.etree.strip_elements",
"pathlib.Path",
"lxml.html.document_fromstring"
] | [((789, 822), 'lxml.html.document_fromstring', 'document_fromstring', (['html_content'], {}), '(html_content)\n', (808, 822), False, 'from lxml.html import document_fromstring\n'), ((831, 869), 'lxml.etree.strip_elements', 'strip_elements', (['self.document', '"""style"""'], {}), "(self.document, 'style')\n", (845, 869... |
import logging as log
import sys
from datetime import timedelta
from computerSitTimer.GraphicalUI import MainTray
def main(args=None):
# from https://chriswarrick.com/blog/2014/09/15/python-apps-the-right-way-entry_points-and-scripts/
if args is None:
args = sys.argv[1:]
m = MainTray(timedelta(h... | [
"datetime.timedelta",
"logging.basicConfig"
] | [((415, 482), 'logging.basicConfig', 'log.basicConfig', ([], {'format': '"""%(levelname)s:%(message)s"""', 'level': 'log.INFO'}), "(format='%(levelname)s:%(message)s', level=log.INFO)\n", (430, 482), True, 'import logging as log\n'), ((309, 327), 'datetime.timedelta', 'timedelta', ([], {'hours': '(1)'}), '(hours=1)\n',... |
import numpy as np
from mountainlab_pytools import mdaio
class TimeseriesMdaReader:
def __init__(self,path,*,samplerate):
self._samplerate=samplerate
self._mda_path=path
X=mdaio.DiskReadMda(path)
self._num_channels=X.N1()
self._num_timepoints=X.N2()
def numChannels(self)... | [
"mountainlab_pytools.mdaio.DiskReadMda",
"numpy.array"
] | [((201, 224), 'mountainlab_pytools.mdaio.DiskReadMda', 'mdaio.DiskReadMda', (['path'], {}), '(path)\n', (218, 224), False, 'from mountainlab_pytools import mdaio\n'), ((684, 717), 'mountainlab_pytools.mdaio.DiskReadMda', 'mdaio.DiskReadMda', (['self._mda_path'], {}), '(self._mda_path)\n', (701, 717), False, 'from mount... |
import pandas as pd
from typing import List
from rdkit import Chem
from rdkit.Chem import AllChem, MACCSkeys
from rdkit.Chem import Draw
def df_canonicalize_from_smiles(df, smiles_col: str, include_stereocenters=True)->pd.Series:
"""
Canonicalize the SMILES strings with RDKit.
Args:
df: dataframe... | [
"rdkit.Chem.AllChem.GetMorganFingerprintAsBitVect",
"rdkit.Chem.Draw.MolToFile",
"rdkit.Chem.SanitizeMol",
"rdkit.Chem.MolToSmiles",
"rdkit.Chem.MACCSkeys.GenMACCSKeys",
"rdkit.Chem.MolFromSmiles"
] | [((623, 658), 'rdkit.Chem.MolFromSmiles', 'Chem.MolFromSmiles', (['row[smiles_col]'], {}), '(row[smiles_col])\n', (641, 658), False, 'from rdkit import Chem\n'), ((1221, 1256), 'rdkit.Chem.MolFromSmiles', 'Chem.MolFromSmiles', (['row[smiles_col]'], {}), '(row[smiles_col])\n', (1239, 1256), False, 'from rdkit import Che... |
import rpy2.robjects as robjects
robjects.r('''
if (!requireNamespace("BiocManager"))
install.packages("BiocManager")
BiocManager::install(version="3.8")''')
robjects.r('''
if (!requireNamespace("BiocManager", quietly = TRUE))
install.packages("BiocManager")
BiocManager::install("edgeR... | [
"rpy2.robjects.r"
] | [((34, 184), 'rpy2.robjects.r', 'robjects.r', (['"""\n if (!requireNamespace("BiocManager"))\n install.packages("BiocManager")\n BiocManager::install(version="3.8")"""'], {}), '(\n """\n if (!requireNamespace("BiocManager"))\n install.packages("BiocManager")\n BiocManager::install(version="... |
import sys, os, math
import re
import argparse
from subprocess import Popen, PIPE
from benchmark_tools.stats import save_stats, compute_stats
import platform
def create_parser():
parser = argparse.ArgumentParser()
parser.add_argument('--bin_path', type=str, default='')
parser.add_argument('--problems_clas... | [
"benchmark_tools.stats.save_stats",
"subprocess.Popen",
"os.path.abspath",
"argparse.ArgumentParser",
"math.pow",
"re.search",
"platform.system",
"benchmark_tools.stats.compute_stats",
"sys.exit"
] | [((193, 218), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (216, 218), False, 'import argparse\n'), ((3222, 3286), 'subprocess.Popen', 'Popen', (['string_start_examin'], {'shell': '(True)', 'stdout': 'PIPE', 'stderr': 'PIPE'}), '(string_start_examin, shell=True, stdout=PIPE, stderr=PIPE)\n', ... |
import tensorflow as tf
from tensorflow import keras
from keras.callbacks import EarlyStopping
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.model_selection import train_test_split
import numpy as np
import matplotlib.pyplot as plt
plt.style.use("seaborn-white")
import os
import s... | [
"tensorflow.keras.preprocessing.image.ImageDataGenerator",
"tensorflow.keras.layers.MaxPooling2D",
"tensorflow.keras.layers.Dense",
"sklearn.model_selection.train_test_split",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.figure",
"tensorflow.keras.models.Sequential",
"os.path.join",
"tensorflow... | [((270, 300), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""seaborn-white"""'], {}), "('seaborn-white')\n", (283, 300), True, 'import matplotlib.pyplot as plt\n'), ((768, 808), 'cv2.dnn.readNet', 'cv2.dnn.readNet', (['face_model', 'face_config'], {}), '(face_model, face_config)\n', (783, 808), False, 'import cv... |
# -*- coding: utf-8 -*-
from torch import tensor
from torch import cuda
from torch import optim
from torch.nn.utils import clip_grad_value_
from model import Model
from numpy import argmax,concatenate
from dataloader import read_data,DataLoader
from sklearn.model_selection import train_test_split
from sklearn.... | [
"dataloader.read_data",
"sklearn.metrics.roc_curve",
"numpy.argmax",
"sklearn.model_selection.train_test_split",
"sklearn.metrics.accuracy_score",
"model.Model",
"dataloader.DataLoader",
"sklearn.metrics.auc",
"torch.cuda.empty_cache",
"torch.tensor",
"numpy.concatenate"
] | [((386, 404), 'torch.cuda.empty_cache', 'cuda.empty_cache', ([], {}), '()\n', (402, 404), False, 'from torch import cuda\n'), ((419, 449), 'dataloader.read_data', 'read_data', (['"""../classic_kt.dat"""'], {}), "('../classic_kt.dat')\n", (428, 449), False, 'from dataloader import read_data, DataLoader\n'), ((474, 511),... |
from absl import logging
from src.model.notation_graph import NotationGraph
from src.object_detector.music_object_detector import MusicObjectDetector
from src.object_detector.staffline_detector import StafflineDetector
class ObjectDetector(object):
def __init__(self, flags):
self.__flags = flags
... | [
"src.object_detector.staffline_detector.StafflineDetector",
"src.object_detector.music_object_detector.MusicObjectDetector",
"absl.logging.warning",
"src.model.notation_graph.NotationGraph"
] | [((342, 357), 'src.model.notation_graph.NotationGraph', 'NotationGraph', ([], {}), '()\n', (355, 357), False, 'from src.model.notation_graph import NotationGraph\n'), ((395, 426), 'src.object_detector.staffline_detector.StafflineDetector', 'StafflineDetector', (['self.__flags'], {}), '(self.__flags)\n', (412, 426), Fal... |
# standard library imports
# third party imports
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn import init
# local imports
import config
from .. import geometric_transformer
geo_tnf_tps = geometric_transformer.GeometricTransformer(geometric_model="tps", tps_grid_size=config.TPS_G... | [
"torch.nn.init.xavier_normal",
"torch.nn.ConvTranspose2d",
"torch.nn.functional.grid_sample",
"torch.nn.ModuleList",
"torch.nn.init.constant",
"torch.nn.Conv2d",
"torch.cat",
"torch.nn.Upsample",
"torch.nn.MaxPool2d"
] | [((551, 665), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_channels', 'out_channels'], {'kernel_size': '(3)', 'stride': 'stride', 'padding': 'padding', 'bias': 'bias', 'groups': 'groups'}), '(in_channels, out_channels, kernel_size=3, stride=stride, padding=\n padding, bias=bias, groups=groups)\n', (560, 665), True, 'import... |
from distutils.core import setup
from distutils.extension import Extension
# from Cython.Distutils import build_ext
import numpy as np
import os
import re
import sys
import tensorflow as tf
tf_include = tf.sysconfig.get_include()
# gcc 4 or using already-built binary,then set USE_CXX11_ABI=1
USE_CXX11_ABI = 0
def f... | [
"numpy.get_numpy_include",
"os.walk",
"tensorflow.sysconfig.get_include",
"distutils.extension.Extension",
"numpy.get_include"
] | [((204, 230), 'tensorflow.sysconfig.get_include', 'tf.sysconfig.get_include', ([], {}), '()\n', (228, 230), True, 'import tensorflow as tf\n'), ((765, 1028), 'distutils.extension.Extension', 'Extension', (['"""autogp.util.matpackops"""', "['autogp/util/tf_ops/vec_to_tri.cc', 'autogp/util/tf_ops/tri_to_vec.cc']"], {'lan... |
from sklearn.metrics import accuracy_score
from utils.metrics.Metrics import Metrics
class ACC(Metrics):
def __init__(self, if_use=True, gpu=False):
super().__init__()
self.name = 'acc'
self.if_use = if_use
self.model = None
self.data_loader = None
self.gpu = gpu
... | [
"sklearn.metrics.accuracy_score"
] | [((1045, 1084), 'sklearn.metrics.accuracy_score', 'accuracy_score', (['self.predictions', 'yVals'], {}), '(self.predictions, yVals)\n', (1059, 1084), False, 'from sklearn.metrics import accuracy_score\n')] |
#!/usr/bin/env python
import time
import zmq
def subscriber():
ctx = zmq.Context()
zmq_socket = ctx.socket(zmq.SUB)
zmq_socket.connect('tcp://127.0.0.1:8211')
zmq_socket.setsockopt(zmq.SUBSCRIBE, '')
while True:
string = zmq_socket.recv()
print('Subscriber received: >>%s<<' % string.encode("hex"))
if __nam... | [
"zmq.Context"
] | [((72, 85), 'zmq.Context', 'zmq.Context', ([], {}), '()\n', (83, 85), False, 'import zmq\n')] |
import logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
import matplotlib.pyplot as plt
import casatools as tools
import casatasks as tasks
import os.path
import shutil
def gensources(complist='src.cl', caldirection="J... | [
"casatools.image",
"casatools.measures",
"casatools.vpmanager",
"logging.basicConfig",
"casatools.calibrater",
"casatools.componentlist",
"matplotlib.pyplot.show",
"casatools.simulator",
"matplotlib.pyplot.figure",
"shutil.rmtree",
"casatools.ms",
"logging.getLogger"
] | [((15, 122), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)s - %(name)s - %(levelname)s - %(message)s"""'}), "(level=logging.INFO, format=\n '%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n", (34, 122), False, 'import logging\n'), ((127, 154), 'logging.... |
#!/usr/bin/env python3
version = '1.0.0'
R = '\033[31m' # red
G = '\033[32m' # green
C = '\033[36m' # cyan
W = '\033[0m' # white
Y = '\033[33m' # yellow
import argparse
import os
parser = argparse.ArgumentParser(description=f'nexfil - Find social media profiles on the web | v{version}')
parser.add_argument('-u... | [
"asyncio.gather",
"tldextract.extract",
"aiohttp.ClientTimeout",
"argparse.ArgumentParser",
"asyncio.new_event_loop",
"asyncio.sleep",
"os.getcwd",
"json.loads",
"os.makedirs",
"os.path.exists",
"aiohttp.ClientSession",
"aiohttp.AsyncResolver",
"requests.get",
"datetime.datetime.now",
"o... | [((197, 301), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'f"""nexfil - Find social media profiles on the web | v{version}"""'}), "(description=\n f'nexfil - Find social media profiles on the web | v{version}')\n", (220, 301), False, 'import argparse\n'), ((2456, 2470), 'os.getenv', 'g... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from... | [
"pulumi.get",
"pulumi.getter",
"pulumi.set",
"pulumi.InvokeOptions",
"pulumi.runtime.invoke"
] | [((1948, 1979), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""cidrBlock"""'}), "(name='cidrBlock')\n", (1961, 1979), False, 'import pulumi\n'), ((2162, 2196), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""creationTime"""'}), "(name='creationTime')\n", (2175, 2196), False, 'import pulumi\n'), ((2542, 2581), ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.