code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import pathlib
import os.path
cwd = pathlib.Path(__file__).parent.absolute()
cwd = os.path.abspath(cwd)
fp = os.path.join(cwd, 'ProjectSettings', 'InputManager.asset')
def output_unity_axis(f, joy_idx, name, button='', axis_type=0, joy_axis=0):
f.write(' - serializedVersion: 3\n')
f.write(' m_Name: joyst... | [
"pathlib.Path"
] | [((37, 59), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (49, 59), False, 'import pathlib\n')] |
# Copyright 2019 The Johns Hopkins University Applied Physics Laboratory
#
# 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 ... | [
"numpy.load",
"numpy.save",
"argparse.ArgumentParser",
"numpy.zeros",
"numpy.array",
"itertools.product"
] | [((862, 881), 'numpy.load', 'np.load', (['args.input'], {}), '(args.input)\n', (869, 881), True, 'import numpy as np\n'), ((1066, 1090), 'numpy.zeros', 'np.zeros', (['cell_map.shape'], {}), '(cell_map.shape)\n', (1074, 1090), True, 'import numpy as np\n'), ((1804, 1872), 'argparse.ArgumentParser', 'argparse.ArgumentPar... |
# Copyright (C) 2010 Google Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the ... | [
"webkitpy.tool.steps.abstractstep.AbstractStep.options",
"urlparse.urlparse",
"re.match"
] | [((1864, 1886), 'webkitpy.tool.steps.abstractstep.AbstractStep.options', 'AbstractStep.options', ([], {}), '()\n', (1884, 1886), False, 'from webkitpy.tool.steps.abstractstep import AbstractStep\n'), ((2516, 2539), 'urlparse.urlparse', 'urlparse', (['user_response'], {}), '(user_response)\n', (2524, 2539), False, 'from... |
from PIL import Image
from pylab import *
img = Image.open('images/profile.jpg').convert('L')
print(array(img)[500])
imgArray = array(img)
figure()
hist(imgArray.flatten(), 300)
show()
# img.show()
| [
"PIL.Image.open"
] | [((52, 84), 'PIL.Image.open', 'Image.open', (['"""images/profile.jpg"""'], {}), "('images/profile.jpg')\n", (62, 84), False, 'from PIL import Image\n')] |
# -*- coding: utf-8 -*-
##
# @file data_context.py
# @brief
# @author wondereamer
# @version 0.1
# @date 2016-11-27
import datetime
from quantity.digger.engine.series import SeriesBase, NumberSeries, DateTimeSeries
from quantity.digger.technicals.base import TechnicalBase
from quantity.digger.util import elogger as ... | [
"quantity.digger.datastruct.Bar",
"datetime.datetime",
"quantity.digger.engine.series.DateTimeSeries",
"quantity.digger.engine.series.NumberSeries",
"quantity.digger.util.elogger.error"
] | [((659, 697), 'quantity.digger.engine.series.NumberSeries', 'NumberSeries', (['data.open.values', '"""open"""'], {}), "(data.open.values, 'open')\n", (671, 697), False, 'from quantity.digger.engine.series import SeriesBase, NumberSeries, DateTimeSeries\n'), ((719, 759), 'quantity.digger.engine.series.NumberSeries', 'Nu... |
#! /usr/bin/env python
'''
Solvers and example test cases for Day 5 of the Advent of Code 2021.
Problem description: <https://adventofcode.com/2021/day/5>
'''
from collections import Counter
from dataclasses import dataclass
from typing import Iterable, List, Tuple
import unittest
def part1(lines: Iterable[str]) ->... | [
"collections.Counter",
"dataclasses.dataclass"
] | [((974, 996), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (983, 996), False, 'from dataclasses import dataclass\n'), ((429, 438), 'collections.Counter', 'Counter', ([], {}), '()\n', (436, 438), False, 'from collections import Counter\n'), ((799, 808), 'collections.Counter', 'Cou... |
__copyright__ = """This code is licensed under the 3-clause BSD license.
Copyright ETH Zurich, Laboratory of Physical Chemistry, Reiher Group.
See LICENSE.txt for details.
"""
import pytest
import scine_utilities as scine
import numpy as np
import os
class SigmaVectorEvaluatorPython(scine.SigmaVectorEvaluator):
d... | [
"scine_utilities.NonOrthogonalDavidson",
"scine_utilities.OrthogonalDavidson",
"numpy.diag_indices_from",
"scine_utilities.core.Log.silent",
"numpy.transpose",
"numpy.ones",
"numpy.linalg.eig",
"scine_utilities.SigmaVectorEvaluator.__init__",
"numpy.identity",
"scine_utilities.IndirectSigmaVectorE... | [((687, 711), 'numpy.random.rand', 'np.random.rand', (['(100)', '(100)'], {}), '(100, 100)\n', (701, 711), True, 'import numpy as np\n'), ((927, 969), 'scine_utilities.IndirectSigmaVectorEvaluator', 'scine.IndirectSigmaVectorEvaluator', (['matrix'], {}), '(matrix)\n', (961, 969), True, 'import scine_utilities as scine\... |
import os
from keras import layers
from keras.layers import Input, merge
from keras.layers.convolutional import (AveragePooling2D, Conv2D, MaxPooling2D,
ZeroPadding2D)
from keras.layers.core import Activation, Dense, Flatten
from keras.layers.normalization import BatchNormalizat... | [
"keras.layers.core.Dense",
"keras.layers.convolutional.AveragePooling2D",
"keras.layers.add",
"keras.layers.core.Activation",
"keras.layers.convolutional.MaxPooling2D",
"keras.models.Model",
"keras.utils.plot_model",
"keras.layers.convolutional.Conv2D",
"keras.layers.core.Flatten",
"keras.layers.I... | [((987, 1014), 'keras.layers.add', 'layers.add', (['[out, shortcut]'], {}), '([out, shortcut])\n', (997, 1014), False, 'from keras import layers\n'), ((1772, 1799), 'keras.layers.add', 'layers.add', (['[out, shortcut]'], {}), '([out, shortcut])\n', (1782, 1799), False, 'from keras import layers\n'), ((1877, 1903), 'ker... |
"""
<NAME> 2014-2016
Python Progress Indicator Utility
Author: <NAME> <<EMAIL>>
License: BSD 3 clause
Contributors: https://github.com/rasbt/pyprind/graphs/contributors
Code Repository: https://github.com/rasbt/pyprind
PyPI: https://pypi.python.org/pypi/PyPrind
"""
import sys
import time
import pyprind
n = 100
slee... | [
"pyprind.ProgPercent",
"time.sleep"
] | [((372, 394), 'pyprind.ProgPercent', 'pyprind.ProgPercent', (['n'], {}), '(n)\n', (391, 394), False, 'import pyprind\n'), ((502, 543), 'pyprind.ProgPercent', 'pyprind.ProgPercent', (['n'], {'stream': 'sys.stdout'}), '(n, stream=sys.stdout)\n', (521, 543), False, 'import pyprind\n'), ((773, 809), 'pyprind.ProgPercent', ... |
# coding: utf-8
# # 使用预训练的VGG模型Fine-tune CNN
# In[1]:
# Import packs
import numpy as np
import os
import scipy.io
from scipy.misc import imread, imresize
import matplotlib.pyplot as plt
import skimage.io
import skimage.transform
import tensorflow as tf
get_ipython().magic(u'matplotlib inline')
cwd = os.getcwd()
pri... | [
"tensorflow.matmul",
"os.path.isfile",
"numpy.random.randint",
"numpy.mean",
"os.path.join",
"numpy.ndarray",
"tensorflow.nn.relu",
"tensorflow.nn.softmax_cross_entropy_with_logits",
"numpy.transpose",
"tensorflow.placeholder",
"tensorflow.cast",
"numpy.reshape",
"tensorflow.initialize_all_v... | [((305, 316), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (314, 316), False, 'import os\n'), ((1812, 1840), 'numpy.ndarray', 'np.ndarray', (['(imgcnt, nclass)'], {}), '((imgcnt, nclass))\n', (1822, 1840), True, 'import numpy as np\n'), ((2630, 2668), 'numpy.random.randint', 'np.random.randint', (['imgcnt'], {'size': 'i... |
from setuptools import setup
requires = [
'click==6.7',
'bucketstore==0.1.1'
]
setup(
name="s3env",
version="0.0.4",
author="<NAME>",
description="Manipulate a key/value JSON object file in an S3 bucket through the CLI",
author_email="<EMAIL>",
url='https://github.com/cameronmaske/s3e... | [
"setuptools.setup"
] | [((90, 456), 'setuptools.setup', 'setup', ([], {'name': '"""s3env"""', 'version': '"""0.0.4"""', 'author': '"""<NAME>"""', 'description': '"""Manipulate a key/value JSON object file in an S3 bucket through the CLI"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/cameronmaske/s3env"""', 'py_modules': ... |
"""Unit tests for the testplan.testing.multitest.result module."""
import collections
import mock
import pytest
from testplan.testing.multitest import result as result_mod
from testplan.testing.multitest.suite import testcase, testsuite
from testplan.testing.multitest import MultiTest
from testplan.common.utils impor... | [
"testplan.testing.multitest.result.DictNamespace",
"testplan.testing.multitest.result.FixNamespace",
"testplan.common.utils.testing.FixMessage",
"mock.MagicMock",
"collections.deque"
] | [((1615, 1631), 'mock.MagicMock', 'mock.MagicMock', ([], {}), '()\n', (1629, 1631), False, 'import mock\n'), ((1658, 1677), 'collections.deque', 'collections.deque', ([], {}), '()\n', (1675, 1677), False, 'import collections\n'), ((1689, 1726), 'testplan.testing.multitest.result.DictNamespace', 'result_mod.DictNamespac... |
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
# This module gets that daya from SoaringSpot and prepaeres the infor for the REAL TIME SCORING
#
# Author: <NAME> - May 2021
#
#import sys
import json
import urllib.request
import urllib.error
import urllib.parse
import hmac
import hashlib
import base64
import os
import socke... | [
"ognddbfuncs.getognreg",
"json.load",
"ognddbfuncs.getognflarmid",
"os.getcwd",
"hmac.new",
"pycountry.countries.get",
"json.dumps",
"socket.gethostname",
"datetime.datetime.utcnow",
"base64.b64encode",
"simplehal.HalDocument.from_python",
"datetime.datetime.now",
"os.urandom"
] | [((1218, 1230), 'json.load', 'json.load', (['r'], {}), '(r)\n', (1227, 1230), False, 'import json\n'), ((3076, 3090), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3088, 3090), False, 'from datetime import datetime\n'), ((3136, 3156), 'socket.gethostname', 'socket.gethostname', ([], {}), '()\n', (3154, 31... |
#!/usr/bin/env python3
import json
from pathlib import PurePath, Path
import subprocess
import tempfile
import zipfile
wasm_pack = Path("~/.cargo/bin/wasm-pack").expanduser()
root_files = ["module.json", "README.md", "CHANGELOG.md", "LICENSE"]
wasm_files = ["gridless_pathfinding_bg.wasm", "gridless_pathfinding.js"]
... | [
"subprocess.run",
"json.load",
"tempfile.TemporaryDirectory",
"zipfile.ZipFile",
"pathlib.Path",
"pathlib.PurePath"
] | [((333, 349), 'pathlib.Path', 'Path', (['"""artifact"""'], {}), "('artifact')\n", (337, 349), False, 'from pathlib import PurePath, Path\n'), ((419, 431), 'pathlib.Path', 'Path', (['"""wasm"""'], {}), "('wasm')\n", (423, 431), False, 'from pathlib import PurePath, Path\n'), ((443, 452), 'pathlib.Path', 'Path', (['"""."... |
import functools
import inspect
import equinox
from typing import Callable, Iterable
def compose(workflow: Iterable[Callable], do_jit: bool=False) -> Callable:
def pipeline(*args, **kwargs): # *args are for grad, **kwargs are the rest
res = dict([])
for f in workflow:
sig = inspect.... | [
"inspect.Signature",
"inspect.signature",
"equinox.filter_jit"
] | [((1842, 1873), 'inspect.signature', 'inspect.signature', (['workflow[-1]'], {}), '(workflow[-1])\n', (1859, 1873), False, 'import inspect\n'), ((1939, 1993), 'inspect.Signature', 'inspect.Signature', (['workflow_pars'], {'return_annotation': 'an'}), '(workflow_pars, return_annotation=an)\n', (1956, 1993), False, 'impo... |
import requests
base_url = "https://stepic.org/media/attachments/course67/3.6.3/"
with open("solutions/week-3/dataset_3378_3.txt") as f:
first_url = f.readline().strip()
r = requests.get(first_url)
answer = r.text.strip()
count = 1
while not answer.startswith("We"):
r = requests.get(f"{base_url}{answer}")
... | [
"requests.get"
] | [((181, 204), 'requests.get', 'requests.get', (['first_url'], {}), '(first_url)\n', (193, 204), False, 'import requests\n'), ((283, 318), 'requests.get', 'requests.get', (['f"""{base_url}{answer}"""'], {}), "(f'{base_url}{answer}')\n", (295, 318), False, 'import requests\n')] |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import subprocess
import sys
from contextlib import contextmanager
from signal import Signals
from subprocess import Popen as _Popen
from typi... | [
"subprocess.Popen"
] | [((1873, 1896), 'subprocess.Popen', '_Popen', (['*args'], {}), '(*args, **kwargs)\n', (1879, 1896), True, 'from subprocess import Popen as _Popen\n')] |
# Twitter Parser
# Parses Data and uploads to MongoDB
import twitter_access
import mongo_access
from tweepy.streaming import StreamListener
from tweepy import OAuthHandler
from tweepy import Stream
import json
import re
import tweepy
import time
from datetime import datetime
from dateutil.parser import parse
from py... | [
"pymongo.MongoClient",
"dateutil.parser.parse",
"json.loads",
"time.time",
"pandas.read_excel",
"vaderSentiment.vaderSentiment.SentimentIntensityAnalyzer",
"tweepy.Stream",
"tweepy.OAuthHandler",
"re.sub"
] | [((497, 526), 'pymongo.MongoClient', 'MongoClient', (['mongo_access.URL'], {}), '(mongo_access.URL)\n', (508, 526), False, 'from pymongo import MongoClient\n'), ((2883, 2950), 'tweepy.OAuthHandler', 'OAuthHandler', (['twitter_access.API_KEY', 'twitter_access.API_SECRET_KEY'], {}), '(twitter_access.API_KEY, twitter_acce... |
# Imports the Google Cloud client library
from google.cloud import language
from google.cloud.language import enums
from google.cloud.language import types
# Instantiates a client
client = language.LanguageServiceClient()
ENTITY_TYPE_TO_IGNORE = [8, 9, 10, 11, 12]
# The text to analyze
text = "Aside from course work,... | [
"google.cloud.language.LanguageServiceClient",
"google.cloud.language.types.Document"
] | [((190, 222), 'google.cloud.language.LanguageServiceClient', 'language.LanguageServiceClient', ([], {}), '()\n', (220, 222), False, 'from google.cloud import language\n'), ((1282, 1347), 'google.cloud.language.types.Document', 'types.Document', ([], {'content': 'text', 'type': 'enums.Document.Type.PLAIN_TEXT'}), '(cont... |
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions
from selenium.common.exceptions import NoSuchElementException
import time, math
class PageGetSet:
def __init__(self):
... | [
"selenium.webdriver.support.ui.WebDriverWait",
"time.sleep",
"selenium.webdriver.support.expected_conditions.visibility_of_element_located",
"selenium.webdriver.Firefox"
] | [((1176, 1195), 'selenium.webdriver.Firefox', 'webdriver.Firefox', ([], {}), '()\n', (1193, 1195), False, 'from selenium import webdriver\n'), ((2213, 2231), 'time.sleep', 'time.sleep', (['length'], {}), '(length)\n', (2223, 2231), False, 'import time, math\n'), ((1765, 1827), 'selenium.webdriver.support.expected_condi... |
from unicodedata import name
from accounts import views as account_views
from django.urls import path, reverse
from .views import (AboutPageView, AuctionCreateView, AuctionDetailView, AuctionListView, BidCreateView, BidDetailView,
DashboardPageView, DatasourceView, HomePageView, StripeConnectionVi... | [
"accounts.views.MyCompanyDetailView.as_view",
"django.urls.path",
"accounts.views.AccountDetailView.as_view",
"accounts.views.CompanyUpdateView.as_view",
"accounts.views.CompanyCreateView.as_view"
] | [((1608, 1673), 'django.urls.path', 'path', (['"""dashboard/connect/"""', 'account_views.connect'], {'name': '"""connect"""'}), "('dashboard/connect/', account_views.connect, name='connect')\n", (1612, 1673), False, 'from django.urls import path, reverse\n'), ((1327, 1370), 'accounts.views.MyCompanyDetailView.as_view',... |
"""A population model that creates samples with more and more variants. Suitable for the aligner paper experiments
^ = intersection
E = subset
vx ^ v0 = v0
vx ^ v1 = v0
...
vx ^ vn = v0
v0 E v1
v1 E v2
v2 E v3
...
v(n-1) E vn
This plugin does not honor the site frequency spectrum model and ignores the original 'p' v... | [
"numpy.random.RandomState"
] | [((2112, 2143), 'numpy.random.RandomState', 'np.random.RandomState', (['rng_seed'], {}), '(rng_seed)\n', (2133, 2143), True, 'import numpy as np\n')] |
#!/usr/bin/env python
"""Test that GoSubDag contains ancestors from only the user-specified relationships"""
# tests/test_gosubdag_relationships_i126.py
# goatools/gosubdag/gosubdag.py
# goatools/gosubdag/godag_rcnt.py
# goatools/gosubdag/godag_rcnt_init.py
# goatools/godag/go_tasks.py
# goatools/obo_parser.py
from __... | [
"goatools.test_data.wr_subobo.WrSubObo.prt_goterms",
"goatools.gosubdag.gosubdag.GoSubDag",
"os.path.join",
"goatools.base.get_godag"
] | [((1116, 1168), 'os.path.join', 'join', (['REPO', '"""tests/data/i126/viral_gene_silence.obo"""'], {}), "(REPO, 'tests/data/i126/viral_gene_silence.obo')\n", (1120, 1168), False, 'from os.path import join\n'), ((1203, 1239), 'goatools.base.get_godag', 'get_godag', (['fin_obo'], {'loading_bar': 'None'}), '(fin_obo, load... |
from .wizards import Wizard
from .data import Dataset, DatasetInfo, AutomaticAnnotator
from .simulation import Renderer, DatasetRenderer, RobotLookupCreator
from .prediction import Predictor, LiveCamera
from .paths import Paths
from .prediction.analysis import Grapher
from .prediction.synthetic import SyntheticPredicto... | [
"logging.basicConfig"
] | [((420, 459), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (439, 459), False, 'import logging\n')] |
"""
Functions to rotate a point by a known euler pole.
"""
import numpy as np
from . import fault_vector_functions
def point_rotation_by_Euler_Pole(Point, Euler_Pole):
"""
Compute the velocity of rotation of a point about an Euler pole on a spherical earth.
This function is useful for computing the veloc... | [
"numpy.deg2rad",
"numpy.cross",
"numpy.sin",
"numpy.cos",
"numpy.dot",
"numpy.sqrt"
] | [((1109, 1133), 'numpy.cross', 'np.cross', (['omega', 'R_point'], {}), '(omega, R_point)\n', (1117, 1133), True, 'import numpy as np\n'), ((2334, 2349), 'numpy.deg2rad', 'np.deg2rad', (['lon'], {}), '(lon)\n', (2344, 2349), True, 'import numpy as np\n'), ((2469, 2511), 'numpy.sqrt', 'np.sqrt', (['(R_fixed * R_fixed - X... |
# Variables
base_list = 'List_1' # this is the base list, each item in this list is checked for a match in the other
list_2 = 'List_2' # List_2 is the name of the list in the excel file
xlfile = 'DATA_IN.xlsx'
# Importing Libs
import pandas as pd
import numpy as np
# Smart Stuff
df_0 = pd.read_excel(xlfile, dtype=str... | [
"pandas.read_excel",
"pandas.DataFrame"
] | [((289, 321), 'pandas.read_excel', 'pd.read_excel', (['xlfile'], {'dtype': 'str'}), '(xlfile, dtype=str)\n', (302, 321), True, 'import pandas as pd\n'), ((426, 440), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (438, 440), True, 'import pandas as pd\n')] |
""" Common functions and parameters amongst the experiments. """
from edo.distributions import Uniform
from sklearn.preprocessing import MinMaxScaler
def scale_dataframe(individual):
""" Scale the individual's dataframe to the unit square for calculating
fitness. """
original = individual.dataframe.copy... | [
"sklearn.preprocessing.MinMaxScaler"
] | [((339, 353), 'sklearn.preprocessing.MinMaxScaler', 'MinMaxScaler', ([], {}), '()\n', (351, 353), False, 'from sklearn.preprocessing import MinMaxScaler\n')] |
import numpy as np
import random
import os, sys
from scipy import ndimage
import healpy as hp
from astropy.io import fits
import matplotlib.pyplot as plt
from scipy.signal import savgol_filter
from astropy.io import fits
from importlib import reload
from pycs.misc.cosmostat_init import *
from pycs.misc.mr_prog import... | [
"healpy.write_map",
"healpy.alm2map",
"healpy.mollview",
"numpy.copy",
"healpy.map2alm",
"numpy.deg2rad",
"healpy.ud_grade",
"healpy.nside2npix",
"numpy.where",
"healpy.npix2nside",
"healpy.map2alm_spin",
"healpy.alm2map_spin",
"healpy.smoothing",
"healpy.read_map",
"numpy.sqrt"
] | [((634, 699), 'numpy.where', 'np.where', (['(bincount > 0.5)', '(bincount_weighted / bincount)', 'hp.UNSEEN'], {}), '(bincount > 0.5, bincount_weighted / bincount, hp.UNSEEN)\n', (642, 699), True, 'import numpy as np\n'), ((938, 953), 'healpy.read_map', 'hp.read_map', (['FN'], {}), '(FN)\n', (949, 953), True, 'import h... |
"""Contract test cases for cases for all organization catalogs."""
import json
import pytest
import requests
from tests import responses
@pytest.mark.contract
@pytest.mark.docker
def test_all_catalogs(docker_service: str) -> None:
"""Should return the all_catalogs response."""
url = f"{docker_service}/organ... | [
"json.loads",
"requests.get"
] | [((352, 369), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (364, 369), False, 'import requests\n'), ((701, 718), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (713, 718), False, 'import requests\n'), ((1119, 1136), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (1131, 1136), False, '... |
"""
Builds a NEXUS file form a long-table format CSV.
"""
import csv
from pathlib import Path
from collections import defaultdict
BASE = Path(__file__).parents[1] / "data"
with open(BASE / "ielex.csv", encoding="utf-8") as h:
data = list(csv.DictReader(h))
taxa = sorted(set([row["LANGUAGE"] for row in data]))
... | [
"collections.defaultdict",
"csv.DictReader",
"pathlib.Path"
] | [((328, 345), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (339, 345), False, 'from collections import defaultdict\n'), ((357, 373), 'collections.defaultdict', 'defaultdict', (['set'], {}), '(set)\n', (368, 373), False, 'from collections import defaultdict\n'), ((246, 263), 'csv.DictReader', 'c... |
from graia.application.message.chain import MessageChain
from graia.application.message.elements.internal import Plain
from graia.application.message.elements.internal import At
from SAGIRIBOT.basics.aio_mysql_excute import execute_sql
async def get_rank(group_id: int, memberList: list) -> list:
sql = "select * ... | [
"SAGIRIBOT.basics.aio_mysql_excute.execute_sql",
"graia.application.message.elements.internal.Plain"
] | [((402, 418), 'SAGIRIBOT.basics.aio_mysql_excute.execute_sql', 'execute_sql', (['sql'], {}), '(sql)\n', (413, 418), False, 'from SAGIRIBOT.basics.aio_mysql_excute import execute_sql\n'), ((953, 969), 'graia.application.message.elements.internal.Plain', 'Plain', ([], {'text': 'text'}), '(text=text)\n', (958, 969), False... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup
import re
import os
import sys
name = "django-db-queue-exports"
package = "django_dbq_exports"
description = "An extension to django-db-queue for monitoring long running jobs"
url = "https://www.dabapps.com/"
project_urls = {"Source": "https:... | [
"os.walk",
"re.search",
"os.path.join"
] | [((736, 806), 're.search', 're.search', (['"""^__version__ = [\'"]([^\'"]+)[\'"]"""', 'init_py', 're.MULTILINE'], {}), '(\'^__version__ = [\\\'"]([^\\\'"]+)[\\\'"]\', init_py, re.MULTILINE)\n', (745, 806), False, 'import re\n'), ((994, 1010), 'os.walk', 'os.walk', (['package'], {}), '(package)\n', (1001, 1010), False, ... |
import mobula.layers as L
import numpy as np
def test_sigmoid():
X = ((np.arange(10000) - 5000) / 1000.0).reshape((-1, 1, 1, 1))
data = L.Data(X, "data")
data.reshape()
l = L.Sigmoid(data)
l.reshape()
assert l.Y.shape == X.shape
l.forward()
l.dY = np.random.random(l.Y.shape) * 10
l.... | [
"mobula.layers.PReLU",
"mobula.layers.Tanh",
"numpy.allclose",
"mobula.layers.ReLU",
"numpy.zeros",
"numpy.square",
"numpy.random.random",
"numpy.arange",
"numpy.exp",
"mobula.layers.Data",
"mobula.layers.SELU",
"mobula.layers.Sigmoid"
] | [((145, 162), 'mobula.layers.Data', 'L.Data', (['X', '"""data"""'], {}), "(X, 'data')\n", (151, 162), True, 'import mobula.layers as L\n'), ((190, 205), 'mobula.layers.Sigmoid', 'L.Sigmoid', (['data'], {}), '(data)\n', (199, 205), True, 'import mobula.layers as L\n'), ((342, 352), 'numpy.exp', 'np.exp', (['(-X)'], {}),... |
# Copyright 2019 <NAME>
#
# 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... | [
"elasticsearch.Elasticsearch",
"rhoci.database.Database.find_one",
"rhoci.database.Database.find"
] | [((1728, 1783), 'elasticsearch.Elasticsearch', 'Elasticsearch', (["app.config['custom']['elk']['es']['url']"], {}), "(app.config['custom']['elk']['es']['url'])\n", (1741, 1783), False, 'from elasticsearch import Elasticsearch\n'), ((3374, 3419), 'rhoci.database.Database.find', 'Database.find', ([], {'collection': '"""D... |
from prometheus_client.core import GaugeMetricFamily
def make_metrics(queue):
list_metrics = []
# Total items in Queue
metric = GaugeMetricFamily(
'jenkins_queue_total',
'Total items in Queue',
labels=None
)
metric.add_metric(
labels=[],
value=queue.get_to... | [
"prometheus_client.core.GaugeMetricFamily"
] | [((144, 221), 'prometheus_client.core.GaugeMetricFamily', 'GaugeMetricFamily', (['"""jenkins_queue_total"""', '"""Total items in Queue"""'], {'labels': 'None'}), "('jenkins_queue_total', 'Total items in Queue', labels=None)\n", (161, 221), False, 'from prometheus_client.core import GaugeMetricFamily\n'), ((420, 548), '... |
from datetime import datetime
from typing import List
from sqlalchemy import insert, func, select, distinct
from src import db
from src.database.models import Artifact, LockedArtifact, ArtifactLabelRelation, FlaggedArtifact, LabelingData
from src.helper.tools_common import string_none_or_empty, who_is_signed_in
def... | [
"sqlalchemy.insert",
"src.database.models.LockedArtifact.query.all",
"src.database.models.LockedArtifact",
"src.database.models.LockedArtifact.query.filter_by",
"src.db.session.execute",
"sqlalchemy.distinct",
"sqlalchemy.select",
"datetime.datetime.utcnow",
"src.helper.tools_common.who_is_signed_in... | [((999, 1018), 'src.db.session.commit', 'db.session.commit', ([], {}), '()\n', (1016, 1018), False, 'from src import db\n'), ((1769, 1788), 'src.db.session.commit', 'db.session.commit', ([], {}), '()\n', (1786, 1788), False, 'from src import db\n'), ((2105, 2131), 'src.database.models.LockedArtifact.query.all', 'Locked... |
from demo.exceptions import AuthException
def token_auth(fn):
def wrapper(*args, **kwargs):
from flask import request
if request.headers.get("token", None) != "123":
raise AuthException("Fail to get access")
return fn(*args, **kwargs)
return wrapper
| [
"demo.exceptions.AuthException",
"flask.request.headers.get"
] | [((144, 178), 'flask.request.headers.get', 'request.headers.get', (['"""token"""', 'None'], {}), "('token', None)\n", (163, 178), False, 'from flask import request\n'), ((207, 242), 'demo.exceptions.AuthException', 'AuthException', (['"""Fail to get access"""'], {}), "('Fail to get access')\n", (220, 242), False, 'from... |
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import scipy as sci
import pandas as pd
import numbers
import csv
import sys
filepath = sys.argv[1]
filename = filepath[filepath.rfind('/')+1:]
print(filepath)
data = pd.read_csv(filepath)
print("Adding year column")
data['year'] = data.apply... | [
"pandas.read_csv"
] | [((244, 265), 'pandas.read_csv', 'pd.read_csv', (['filepath'], {}), '(filepath)\n', (255, 265), True, 'import pandas as pd\n'), ((1192, 1237), 'pandas.read_csv', 'pd.read_csv', (['"""categorized_ucc_dictionary.csv"""'], {}), "('categorized_ucc_dictionary.csv')\n", (1203, 1237), True, 'import pandas as pd\n')] |
import arcpy
from arcpy import env
from arcpy.sa import *
import file_functions
from file_functions import *
import create_centerline
import create_station_lines
from create_station_lines import create_station_lines_function
import os
from os import listdir
from os.path import isfile, join
import xlrd
import shutil
fro... | [
"os.remove",
"create_centerline.make_centerline",
"arcpy.MultipartToSinglepart_management",
"arcpy.SaveToLayerFile_management",
"shutil.rmtree",
"arcpy.MakeRasterLayer_management",
"arcpy.JoinField_management",
"os.path.join",
"arcpy.Intersect_analysis",
"arcpy.ExtractValuesToTable_ga",
"arcpy.C... | [((10192, 10212), 'os.path.dirname', 'os.path.dirname', (['dem'], {}), '(dem)\n', (10207, 10212), False, 'import os\n'), ((1074, 1097), 'os.path.exists', 'os.path.exists', (['laspath'], {}), '(laspath)\n', (1088, 1097), False, 'import os\n'), ((1107, 1127), 'os.makedirs', 'os.makedirs', (['laspath'], {}), '(laspath)\n'... |
from model_new.config import Config
from model_new.keras_model import KerasModel
from model_new.utils import load_json
config = Config()
model = KerasModel(config)
train_set = load_json('dataset/train.json')
# dev_set = load_json('dataset/dev.json')
# sub_set = dev_set[:config.batch_size * 50]
model.train(train_set,... | [
"model_new.utils.load_json",
"model_new.keras_model.KerasModel",
"model_new.config.Config"
] | [((129, 137), 'model_new.config.Config', 'Config', ([], {}), '()\n', (135, 137), False, 'from model_new.config import Config\n'), ((146, 164), 'model_new.keras_model.KerasModel', 'KerasModel', (['config'], {}), '(config)\n', (156, 164), False, 'from model_new.keras_model import KerasModel\n'), ((178, 209), 'model_new.u... |
from django.conf.urls import patterns, url
from Standings import views
urlpatterns = patterns(
'',
# ex: /standings/
url(r'^$', views.standings_index, name='index'),
) | [
"django.conf.urls.url"
] | [((131, 177), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.standings_index'], {'name': '"""index"""'}), "('^$', views.standings_index, name='index')\n", (134, 177), False, 'from django.conf.urls import patterns, url\n')] |
#!/usr/bin/python3
# This script runs whenever a user tries to commit something in this repo.
# It checks the commit for any text that resembled an encoded JSON web token,
# and asks the user to verify that they want to commit a JWT if it finds any.
import sys
import subprocess
import re
import base64
import binascii
... | [
"subprocess.check_output",
"re.findall",
"base64.urlsafe_b64decode",
"re.compile"
] | [((790, 830), 're.compile', 're.compile', (['"""JWT|iat|name|sub|alg|exp|k"""'], {}), "('JWT|iat|name|sub|alg|exp|k')\n", (800, 830), False, 'import re\n'), ((987, 1026), 're.findall', 're.findall', (['"""[A-Za-z0-9_=-]{20,}"""', 'line'], {}), "('[A-Za-z0-9_=-]{20,}', line)\n", (997, 1026), False, 'import re\n'), ((194... |
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not... | [
"custos.clients.super_tenant_management_client.SuperTenantManagementClient",
"custos.clients.tenant_management_client.TenantManagementClient",
"logging.StreamHandler",
"custos.clients.utils.utilities.get_token",
"custos.clients.identity_management_client.IdentityManagementClient",
"custos.transport.settin... | [((1170, 1197), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1187, 1197), False, 'import logging\n'), ((1289, 1312), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (1310, 1312), False, 'import logging\n'), ((1364, 1392), 'custos.transport.settings.CustosServerClien... |
# uncompyle6 version 2.13.2
# Python bytecode 3.5 (3351)
# Decompiled from: Python 3.5.3 (default, Jan 19 2017, 14:11:04)
# [GCC 6.3.0 20170118]
# Embedded file name: db\tables\licenses.py
from sqlalchemy import *
from sqlalchemy.orm import mapper
from db.tables import metadata
LicensesTable = Table('licenses', metada... | [
"sqlalchemy.orm.mapper"
] | [((632, 665), 'sqlalchemy.orm.mapper', 'mapper', (['LicenseRow', 'LicensesTable'], {}), '(LicenseRow, LicensesTable)\n', (638, 665), False, 'from sqlalchemy.orm import mapper\n')] |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
Author: enen92
License: I don't care version 3.0
"""
import xbmc,xbmcgui,xbmcaddon,os
addon_id = 'script.retrogames'
selfAddon = xbmcaddon.Addon(id=addon_id)
datapath = xbmc.translatePath(selfAddon.getAddonInfo('profile')).decode('utf-8')
addonfolder = xbmc.trans... | [
"xbmcgui.Dialog",
"os.path.join",
"xbmcaddon.Addon"
] | [((186, 214), 'xbmcaddon.Addon', 'xbmcaddon.Addon', ([], {'id': 'addon_id'}), '(id=addon_id)\n', (201, 214), False, 'import xbmc, xbmcgui, xbmcaddon, os\n'), ((389, 434), 'os.path.join', 'os.path.join', (['addonfolder', '"""resources"""', '"""img"""'], {}), "(addonfolder, 'resources', 'img')\n", (401, 434), False, 'imp... |
"""Test Palmetto."""
import pytest
from palmettopy.palmetto import Palmetto
from palmettopy.exceptions import CoherenceTypeNotAvailable, EndpointDown, WrongContentType
@pytest.fixture
def words():
"""Load test data fixture."""
words = ["cake", "apple", "banana", "cherry", "chocolate"]
return words
@py... | [
"pytest.raises",
"palmettopy.palmetto.Palmetto"
] | [((759, 769), 'palmettopy.palmetto.Palmetto', 'Palmetto', ([], {}), '()\n', (767, 769), False, 'from palmettopy.palmetto import Palmetto\n'), ((921, 931), 'palmettopy.palmetto.Palmetto', 'Palmetto', ([], {}), '()\n', (929, 931), False, 'from palmettopy.palmetto import Palmetto\n'), ((1076, 1119), 'palmettopy.palmetto.P... |
import model3 as M
import numpy as np
import tensorflow as tf
params = np.load('lstmpm_d1.npy').item()
params2 = np.load('lstmpm_d2.npy').item()
def get_conv(name):
res = []
# print(params[name])
res.append(params[name]['weights'])
res.append(params[name]['bias'])
# print(res[0].shape)
return res
def get_c... | [
"model3.Saver",
"numpy.load",
"model3.AvgPool",
"model3.MaxPool",
"tensorflow.pad",
"numpy.transpose",
"tensorflow.concat",
"numpy.ones",
"tensorflow.Variable",
"tensorflow.tanh",
"tensorflow.sigmoid"
] | [((7984, 8013), 'numpy.transpose', 'np.transpose', (['x', '[0, 3, 1, 2]'], {}), '(x, [0, 3, 1, 2])\n', (7996, 8013), True, 'import numpy as np\n'), ((8365, 8394), 'numpy.transpose', 'np.transpose', (['x', '[0, 3, 1, 2]'], {}), '(x, [0, 3, 1, 2])\n', (8377, 8394), True, 'import numpy as np\n'), ((8500, 8513), 'model3.Sa... |
from django.urls import path, re_path
from . import views
# 这是应用Book中的url具体配置，请求到这里才能调用该应用的视图，上一级首先是调用BookManager的url，如果没有匹配admin
# 那么进入应用的匹配Book.urls，之后才会进入这里应用的url
urlpatterns = [
# http://127.0.0.1:8000/admin/ 匹配
# 正则匹配，对请求地址进行正则匹配，如果路径中包含admin，就把后台站点中的url信息包含到这个项目中，指明下一集路径如何匹配
# 如果匹配成功，那么直接调用... | [
"django.urls.re_path",
"django.urls.path"
] | [((403, 444), 'django.urls.path', 'path', (['"""stockplot/"""', 'views.showlinediagram'], {}), "('stockplot/', views.showlinediagram)\n", (407, 444), False, 'from django.urls import path, re_path\n'), ((451, 494), 'django.urls.path', 'path', (['"""index3"""', 'views.index3'], {'name': '"""index3"""'}), "('index3', view... |
from __future__ import unicode_literals
from __future__ import print_function
from __future__ import division
from __future__ import absolute_import
from future import standard_library
standard_library.install_aliases()
from builtins import *
class OJAIList(list):
def __init__(self):
super(OJAIList, self)._... | [
"mapr.ojai.ojai.OJAIDocument.OJAIDocument",
"future.standard_library.install_aliases",
"mapr.ojai.ojai.OJAITagsBuilder.OJAITagsBuilder"
] | [((185, 219), 'future.standard_library.install_aliases', 'standard_library.install_aliases', ([], {}), '()\n', (217, 219), False, 'from future import standard_library\n'), ((521, 538), 'mapr.ojai.ojai.OJAITagsBuilder.OJAITagsBuilder', 'OJAITagsBuilder', ([], {}), '()\n', (536, 538), False, 'from mapr.ojai.ojai.OJAITags... |
import os
from copy import copy
from typing import Any, List, Tuple
from nubia import context, eventbus
from nubia.internal import cmdloader
from nubia.internal.cmdbase import AutoCommand
from pygments.token import Name, Token
from rich import box, inspect
from rich.align import Align
from rich.console import Console
... | [
"copy.copy",
"nubia.internal.cmdloader.load_commands",
"sortedcontainers.SortedSet",
"nubia.internal.cmdbase.AutoCommand",
"rich.console.Console",
"rich.align.Align.center"
] | [((718, 729), 'sortedcontainers.SortedSet', 'SortedSet', ([], {}), '()\n', (727, 729), False, 'from sortedcontainers import SortedSet\n'), ((1816, 1857), 'nubia.internal.cmdloader.load_commands', 'cmdloader.load_commands', (['COMMAND_PACKAGES'], {}), '(COMMAND_PACKAGES)\n', (1839, 1857), False, 'from nubia.internal imp... |
# -*- coding: utf-8 -*-
from pims import ImageReader
from load_data.ILoadSupervised import ILoadSupervised
from os.path import join, exists
import csv
class LoadPokemon(ILoadSupervised):
def __init__(self, path="train_data/Folder_Videojuegos/pokemon-images-and-types"):
self.path = path
self.classe... | [
"pims.ImageReader",
"csv.DictReader",
"os.path.join",
"os.path.exists"
] | [((526, 549), 'csv.DictReader', 'csv.DictReader', (['csv_obj'], {}), '(csv_obj)\n', (540, 549), False, 'import csv\n'), ((452, 482), 'os.path.join', 'join', (['self.path', '"""pokemon.csv"""'], {}), "(self.path, 'pokemon.csv')\n", (456, 482), False, 'from os.path import join, exists\n'), ((613, 660), 'os.path.join', 'j... |
import discord
from discord.ext import commands
import random
import asyncio
class GameManager():
def __init__(self):
self.setup()
def setup(self):
print("GameManager: Loaded")
class GameManagerCog(commands.Cog):
def __init__(self, client):
self.client = clie... | [
"discord.utils.get",
"discord.ext.commands.has_role",
"discord.ext.commands.command",
"discord.PermissionOverwrite"
] | [((895, 1316), 'discord.ext.commands.command', 'commands.command', ([], {'aliases': "['Creategame', 'CreateGame', 'cg', 'Cg', 'cG', 'CG', 'gamecreate',\n 'Gamecreate', 'GameCreate', 'gc', 'Gc', 'gC', 'GC']", 'brief': '"""Makes the necessary channels and roles for a game."""', 'description': '"""/creategame [arg1] [a... |
# Copyright 2016 Isotoma 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 License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing... | [
"touchdown.core.utils.force_bytes",
"datetime.datetime.now"
] | [((1300, 1323), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (1321, 1323), False, 'import datetime\n'), ((1441, 1463), 'touchdown.core.utils.force_bytes', 'force_bytes', (['user_data'], {}), '(user_data)\n', (1452, 1463), False, 'from touchdown.core.utils import force_bytes, force_str\n')] |
import sys
import click
from .function import LambdaPoolFunction
from . import utils
from tabulate import tabulate
from lambdapool import exceptions
@click.group()
def cli():
pass
@cli.command()
@click.option('--requirements', '-r', type=click.Path(exists=True), help="Specifies the dependencies to be installed ... | [
"click.argument",
"click.option",
"click.echo",
"tabulate.tabulate",
"click.Path",
"click.group",
"sys.exit"
] | [((153, 166), 'click.group', 'click.group', ([], {}), '()\n', (164, 166), False, 'import click\n'), ((347, 449), 'click.option', 'click.option', (['"""--memory"""'], {'type': 'click.INT', 'help': '"""Sets the memory size of the function environment"""'}), "('--memory', type=click.INT, help=\n 'Sets the memory size o... |
import time
import random
def print_pause(message_to_print):
print(message_to_print)
time.sleep(2)
def intro(item, option):
print_pause("You find yourself standing in an open field, filled "
"with grass and yellow wildflowers.\n")
print_pause("Rumor has it that a " + option + " is some... | [
"random.choice",
"time.sleep"
] | [((94, 107), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (104, 107), False, 'import time\n'), ((3986, 4049), 'random.choice', 'random.choice', (["['pirate', 'fairy', 'dragon', 'gorgon', 'troll']"], {}), "(['pirate', 'fairy', 'dragon', 'gorgon', 'troll'])\n", (3999, 4049), False, 'import random\n')] |
from builtins import str
from django.test import TestCase
from measure_mate.tests.factories import TemplateFactory, AttributeFactory, RatingFactory
class RatingTestCases(TestCase):
def test_creation_of_rating(self):
template = TemplateFactory()
attribute = AttributeFactory(template=template)
... | [
"builtins.str",
"measure_mate.tests.factories.TemplateFactory",
"measure_mate.tests.factories.AttributeFactory",
"measure_mate.tests.factories.RatingFactory"
] | [((242, 259), 'measure_mate.tests.factories.TemplateFactory', 'TemplateFactory', ([], {}), '()\n', (257, 259), False, 'from measure_mate.tests.factories import TemplateFactory, AttributeFactory, RatingFactory\n'), ((280, 315), 'measure_mate.tests.factories.AttributeFactory', 'AttributeFactory', ([], {'template': 'templ... |
"""
File: mirror_lake.py
----------------------------------
This file reads in mt-rainier.jpg and
makes a new image that creates a mirror
lake vibe by placing an inverse image of
mt-rainier.jpg below the original one.
"""
from simpleimage import SimpleImage
def reflect(filename):
"""
:param filename: str, the... | [
"simpleimage.SimpleImage",
"simpleimage.SimpleImage.blank"
] | [((409, 430), 'simpleimage.SimpleImage', 'SimpleImage', (['filename'], {}), '(filename)\n', (420, 430), False, 'from simpleimage import SimpleImage\n'), ((447, 491), 'simpleimage.SimpleImage.blank', 'SimpleImage.blank', (['img.width', '(img.height * 2)'], {}), '(img.width, img.height * 2)\n', (464, 491), False, 'from s... |
"""
Tests the subsets_exp module.
"""
import mock
import unittest
from .context import subsets_exp
from .context import config
from .context import runner
from .context import test_utils as tu
class Subsets_ExperimentTestCase(unittest.TestCase):
def setUp(self):
config_obj = tu.sample_config()
moc... | [
"unittest.main",
"mock.call",
"unittest.TestLoader",
"mock.Mock"
] | [((3303, 3318), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3316, 3318), False, 'import unittest\n'), ((335, 359), 'mock.Mock', 'mock.Mock', (['runner.Runner'], {}), '(runner.Runner)\n', (344, 359), False, 'import mock\n'), ((1426, 1437), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (1435, 1437), False, 'import... |
from timberscale import Timber
import csv
import math
##### REPORT DATA MODULE
class Report(object):
LOG_RANGE_LIST = [["40+ ft", range(41, 121)], ["31-40 ft", range(31, 41)], ["21-30 ft", range(21, 31)],
["11-20 ft", range(11, 21)], ["1-10 ft", range(1, 11)]]
def __init__(self, CSV, St... | [
"csv.reader",
"timberscale.Timber",
"math.sqrt"
] | [((937, 958), 'csv.reader', 'csv.reader', (['tree_data'], {}), '(tree_data)\n', (947, 958), False, 'import csv\n'), ((3322, 3343), 'csv.reader', 'csv.reader', (['tree_data'], {}), '(tree_data)\n', (3332, 3343), False, 'import csv\n'), ((5691, 5744), 'math.sqrt', 'math.sqrt', (['(master[key][1] / master[key][0] / 0.0054... |
# -*- coding: UTF-8 -*-
import ply.yacc
from collections import OrderedDict
from .lexer import tokens, lex
# a:4:{s:4:"date";s:10:"2019-12-29";s:10:"type_fonds";s:11:"arko_seriel";s:4:"ref1";i:12;s:4:"ref2";i:4669;}
from .models import Object
start = 'expression'
def p_expression(p):
"""expression : atom
... | [
"collections.OrderedDict"
] | [((1191, 1204), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1202, 1204), False, 'from collections import OrderedDict\n')] |
import base64
import json
import typing
import marshmallow
from boto3.dynamodb.conditions import Key
from drf_yasg2.utils import swagger_auto_schema
from flag_engine.api.schemas import APITraitSchema
from flag_engine.identities.builders import (
build_identity_dict,
build_identity_model,
)
from rest_framework ... | [
"projects.exceptions.DynamoNotEnabledError",
"base64.b64decode",
"environments.identities.models.Identity.dynamo_wrapper.get_all_items",
"rest_framework.response.Response",
"environments.models.Environment.objects.get",
"rest_framework.exceptions.NotFound",
"edge_api.identities.serializers.EdgeIdentityF... | [((1215, 1231), 'flag_engine.api.schemas.APITraitSchema', 'APITraitSchema', ([], {}), '()\n', (1229, 1231), False, 'from flag_engine.api.schemas import APITraitSchema\n'), ((4174, 4234), 'rest_framework.decorators.action', 'action', ([], {'detail': '(True)', 'methods': "['get']", 'url_path': '"""list-traits"""'}), "(de... |
import torch
from collections import defaultdict
from uninas.data.abstract import AbstractDataSet
from uninas.models.networks.abstract import AbstractNetwork
from uninas.training.result import ResultValue
from uninas.utils.args import ArgsInterface, Namespace, Argument
class AbstractMetric(ArgsInterface):
"""
... | [
"collections.defaultdict",
"torch.argmax",
"uninas.utils.args.Argument",
"torch.no_grad"
] | [((7330, 7347), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (7341, 7347), False, 'from collections import defaultdict\n'), ((2332, 2361), 'torch.argmax', 'torch.argmax', (['targets'], {'dim': '(-1)'}), '(targets, dim=-1)\n', (2344, 2361), False, 'import torch\n'), ((6432, 6447), 'torch.no_grad... |
import subprocess
path_oommf = 'C:/Users/jmank/Desktop/oommf12b4_20200930_86_x64/oommf/oommf.tcl'
mif_file = 'C:/Users/jmank/Desktop/oommf12b4_20200930_86_x64/oommf/Skyrmion/skyrmionDome2.mif'
length = 2
param_string = ' boxsi '#-parameters "integer_length % s" ' % length
threads_string = ' -threads 28 '
oommf_comma... | [
"subprocess.call"
] | [((391, 433), 'subprocess.call', 'subprocess.call', (['oommf_command'], {'shell': '(True)'}), '(oommf_command, shell=True)\n', (406, 433), False, 'import subprocess\n')] |
from __future__ import annotations
from abc import abstractclassmethod, abstractmethod, abstractproperty
from typing import (
TYPE_CHECKING,
Any,
Generator,
Generic,
Optional,
Type,
TypeVar,
Union,
)
import numpy as np
from pandas import DataFrame
from tanuki.data_store.data_type impo... | [
"typing.TypeVar"
] | [((567, 600), 'typing.TypeVar', 'TypeVar', (['"""B"""'], {'bound': '"""DataBackend"""'}), "('B', bound='DataBackend')\n", (574, 600), False, 'from typing import TYPE_CHECKING, Any, Generator, Generic, Optional, Type, TypeVar, Union\n')] |
SERVER_HOST = '127.0.0.1'
SERVER_PORT = 1335
MAX_GET_REQUESTS = 10
import re, socket
import random
import string
MSG_AUTH_RE = re.compile('''^AUTH +(.+) +(.+)''')
MSG_GET_RE = re.compile('''^GET +(.+) +(.+)''')
MSG_RVK_RE = re.compile('''^RVK +(.+)''')
def serve(srv):
while 1:
print('[S] Waiting for new... | [
"socket.socket",
"random.choice",
"re.compile"
] | [((129, 160), 're.compile', 're.compile', (['"""^AUTH +(.+) +(.+)"""'], {}), "('^AUTH +(.+) +(.+)')\n", (139, 160), False, 'import re, socket\n'), ((178, 208), 're.compile', 're.compile', (['"""^GET +(.+) +(.+)"""'], {}), "('^GET +(.+) +(.+)')\n", (188, 208), False, 'import re, socket\n'), ((226, 250), 're.compile', 'r... |
#!/usr/bin/python3
import json
state_file_path = "resources/state.json"
version = 0
class StateVersionException(Exception):
pass
def _get_state():
with open(state_file_path, 'r') as state_file:
data = json.load(state_file)
if data['version'] == 0:
data.pop('version', None)
... | [
"json.dump",
"json.load"
] | [((222, 243), 'json.load', 'json.load', (['state_file'], {}), '(state_file)\n', (231, 243), False, 'import json\n'), ((582, 633), 'json.dump', 'json.dump', (['dc', 'state_file'], {'sort_keys': '(True)', 'indent': '(4)'}), '(dc, state_file, sort_keys=True, indent=4)\n', (591, 633), False, 'import json\n')] |
from rain_alert.utils import RECEIVERS_FILE_PATH
import unittest
from .context import utils
import os
class TestGetReceivers(unittest.TestCase):
def test_no_file(self):
# set the path of the receivers to this folder because in tests folder
# we dont have the receivers file
utils.RECEIVE... | [
"unittest.main",
"os.path.split"
] | [((504, 519), 'unittest.main', 'unittest.main', ([], {}), '()\n', (517, 519), False, 'import unittest\n'), ((335, 375), 'os.path.split', 'os.path.split', (['utils.RECEIVERS_FILE_PATH'], {}), '(utils.RECEIVERS_FILE_PATH)\n', (348, 375), False, 'import os\n')] |
# Generated by Django 3.2.7 on 2021-10-18 12:21
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),
('perfil', '0001_initial')... | [
"django.db.models.CharField",
"django.db.models.OneToOneField",
"django.db.migrations.swappable_dependency"
] | [((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'), ((459, 515), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)', '... |
import gpflow
import matplotlib.pyplot as plt
import numpy as np
from robustgp import ConditionalVariance
X = np.random.rand(150, 1)
Y = 0.8 * np.cos(10 * X) + 1.2 * np.sin(8 * X + 0.3) + np.cos(17 * X) * 1.2 + np.random.randn(*X.shape) * 0.1
gpr = gpflow.models.GPR((X, Y), gpflow.kernels.SquaredExponential())
opt = ... | [
"robustgp.ConditionalVariance",
"gpflow.kernels.SquaredExponential",
"matplotlib.pyplot.show",
"numpy.random.randn",
"numpy.argmax",
"gpflow.optimizers.Scipy",
"gpflow.utilities.read_values",
"numpy.sin",
"numpy.linspace",
"numpy.cos",
"numpy.random.rand",
"matplotlib.pyplot.subplots"
] | [((111, 133), 'numpy.random.rand', 'np.random.rand', (['(150)', '(1)'], {}), '(150, 1)\n', (125, 133), True, 'import numpy as np\n'), ((320, 345), 'gpflow.optimizers.Scipy', 'gpflow.optimizers.Scipy', ([], {}), '()\n', (343, 345), False, 'import gpflow\n'), ((446, 481), 'gpflow.kernels.SquaredExponential', 'gpflow.kern... |
import sys
import time
from src.github import Github
from src.gitlab import Gitlab
def exit(message):
print(message)
sys.exit()
if __name__ == "__main__":
# Get all gitlab repositories
gitlab = Gitlab()
gitlab_repos = gitlab.repositories()
if gitlab_repos == None:
exit('Not abl... | [
"time.sleep",
"src.github.Github",
"sys.exit",
"src.gitlab.Gitlab"
] | [((126, 136), 'sys.exit', 'sys.exit', ([], {}), '()\n', (134, 136), False, 'import sys\n'), ((216, 224), 'src.gitlab.Gitlab', 'Gitlab', ([], {}), '()\n', (222, 224), False, 'from src.gitlab import Gitlab\n'), ((575, 583), 'src.github.Github', 'Github', ([], {}), '()\n', (581, 583), False, 'from src.github import Github... |
# -*- coding: utf-8 -*-
from flask import make_response, request, jsonify
from flask_login import login_required
import json
from werkzeug.utils import secure_filename
import os
from app.models.fragment import Fragment
from app.models.branch import Branch
from app.models.tag import Tag
from app.api import api
from app... | [
"app.api.api.route",
"app.models.tag.Tag.add",
"json.dumps",
"werkzeug.utils.secure_filename",
"app.models.branch.Branch.add",
"flask.jsonify",
"app.whoosh.search_helper.search",
"os.path.join"
] | [((498, 538), 'app.api.api.route', 'api.route', (['"""/add_tag/"""'], {'methods': "['POST']"}), "('/add_tag/', methods=['POST'])\n", (507, 538), False, 'from app.api import api\n'), ((1013, 1056), 'app.api.api.route', 'api.route', (['"""/add_branch/"""'], {'methods': "['POST']"}), "('/add_branch/', methods=['POST'])\n"... |
from env.evrp import EVRPEnv
from utils.config import read_config
import numpy as np
from env.worker import VectorizedEVRP
from utils.plot import convert_plt_to_numpy, convert_plt_to_tf, plot_tours
from utils import try_import_tensorflow
tf = try_import_tensorflow()
if __name__ == "__main__":
config = rea... | [
"utils.config.read_config",
"env.evrp.EVRPEnv",
"utils.plot.plot_tours",
"utils.try_import_tensorflow"
] | [((249, 272), 'utils.try_import_tensorflow', 'try_import_tensorflow', ([], {}), '()\n', (270, 272), False, 'from utils import try_import_tensorflow\n'), ((317, 343), 'utils.config.read_config', 'read_config', (['"""config.json"""'], {}), "('config.json')\n", (328, 343), False, 'from utils.config import read_config\n'),... |
# -*- coding: utf-8 -*- #
# Copyright 2019 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless requir... | [
"googlecloudsdk.calliope.base.ASYNC_FLAG.AddToParser",
"googlecloudsdk.calliope.arg_parsers.ArgDict"
] | [((3367, 3402), 'googlecloudsdk.calliope.base.ASYNC_FLAG.AddToParser', 'base.ASYNC_FLAG.AddToParser', (['parser'], {}), '(parser)\n', (3394, 3402), False, 'from googlecloudsdk.calliope import base\n'), ((2955, 3011), 'googlecloudsdk.calliope.arg_parsers.ArgDict', 'arg_parsers.ArgDict', ([], {'spec': "{'network': str}",... |
from flask import jsonify
from pyawsstarter import Logger
from wordservice import create_app
# Call the Application Factory function to construct a Flask application instance
# using the standard configuration defined in /instance/flask.cfg
application = create_app('flask.cfg')
@application.errorhandler(Exception)
... | [
"pyawsstarter.Logger.get_logger",
"wordservice.create_app"
] | [((257, 280), 'wordservice.create_app', 'create_app', (['"""flask.cfg"""'], {}), "('flask.cfg')\n", (267, 280), False, 'from wordservice import create_app\n'), ((565, 597), 'pyawsstarter.Logger.get_logger', 'Logger.get_logger', (['"""wordservice"""'], {}), "('wordservice')\n", (582, 597), False, 'from pyawsstarter impo... |
from django.conf.urls import url
from django.contrib import admin
import views
admin.autodiscover()
urlpatterns = [
url(r'^pass_forget/$', views.pass_forget, name='pass_forget'),
# url(r'^pass_rec/$', views.pass_rec, name='pass_rec'),
]
| [
"django.contrib.admin.autodiscover",
"django.conf.urls.url"
] | [((81, 101), 'django.contrib.admin.autodiscover', 'admin.autodiscover', ([], {}), '()\n', (99, 101), False, 'from django.contrib import admin\n'), ((123, 183), 'django.conf.urls.url', 'url', (['"""^pass_forget/$"""', 'views.pass_forget'], {'name': '"""pass_forget"""'}), "('^pass_forget/$', views.pass_forget, name='pass... |
from django.db import models
from .utils import upload_to_file, generate_random_string
from .validators import validate_file
class CompanyManager(models.Manager):
def get_or_none(self, **kwargs):
try:
return self.get(**kwargs)
except Company.DoesNotExist:
return None
cl... | [
"django.db.models.FileField",
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.EmailField",
"django.db.models.IntegerField",
"django.db.models.DateTimeField"
] | [((392, 455), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(60)', 'default': '"""default"""', 'unique': '(True)'}), "(max_length=60, default='default', unique=True)\n", (408, 455), False, 'from django.db import models\n'), ((474, 513), 'django.db.models.TextField', 'models.TextField', ([], {'b... |
# Copyright 2020-present Kensho Technologies, LLC.
import logging
import sys
import click
import gpg
from ..signing import (
DAYS_WARNING_FOR_KEY_EXPIRATION,
add_trusted_keys_to_gpg_home_dir,
get_days_until_expiry,
)
from ..utils import get_temporary_directory
logger = logging.getLogger(__name__)
logger... | [
"click.argument",
"logging.getLogger",
"click.command",
"gpg.Context",
"sys.exit"
] | [((286, 313), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (303, 313), False, 'import logging\n'), ((1637, 1652), 'click.command', 'click.command', ([], {}), '()\n', (1650, 1652), False, 'import click\n'), ((1654, 1707), 'click.argument', 'click.argument', (['"""days_before_warning"""']... |
from os import remove
from os.path import isdir, join
from pathlib import Path
from gdown import download
from zipfile import ZipFile
def download_ffhq(path):
path = join(path, 'ffhq')
if not isdir(path):
Path(path).mkdir(parents=True, exist_ok=True)
path_zip = join(path, 'ffhq.zip')
do... | [
"os.remove",
"zipfile.ZipFile",
"os.path.isdir",
"gdown.download",
"pathlib.Path",
"os.path.join"
] | [((171, 189), 'os.path.join', 'join', (['path', '"""ffhq"""'], {}), "(path, 'ffhq')\n", (175, 189), False, 'from os.path import isdir, join\n'), ((201, 212), 'os.path.isdir', 'isdir', (['path'], {}), '(path)\n', (206, 212), False, 'from os.path import isdir, join\n'), ((287, 309), 'os.path.join', 'join', (['path', '"""... |
import pdb
import time
import lib.tf_silent
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from matplotlib.colors import Normalize
from matplotlib.gridspec import GridSpec
import os
import pickle
import argparse
from lib.pinn import PINN
from lib.network import Ne... | [
"matplotlib.pyplot.title",
"pickle.dump",
"numpy.abs",
"argparse.ArgumentParser",
"numpy.floor",
"os.path.isfile",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.contourf",
"matplotlib.pyplot.contour",
"pickle.load",
"numpy.round",
"matplotlib.pyplot.tight_layout",
"numpy.meshgrid",
"matpl... | [((395, 420), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (418, 420), False, 'import argparse\n'), ((1189, 1204), 'tensorflow.constant', 'tf.constant', (['xy'], {}), '(xy)\n', (1200, 1204), True, 'import tensorflow as tf\n'), ((2285, 2302), 'matplotlib.pyplot.subplot', 'plt.subplot', (['grid... |
"""The command line application for running the advent of code solutions."""
import argparse
import importlib
import pathlib
from typing import cast
from aoc2021.lib import ModSolution
def main() -> int:
"""Run the main CLI entry point."""
parser = argparse.ArgumentParser(
description="Run the advent... | [
"pathlib.Path",
"argparse.ArgumentParser",
"importlib.import_module"
] | [((260, 339), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Run the advent of code puzzle solutions."""'}), "(description='Run the advent of code puzzle solutions.')\n", (283, 339), False, 'import argparse\n'), ((646, 687), 'pathlib.Path', 'pathlib.Path', (['f"""input/{args.day:02d}.txt... |
import csv
import logging
import random
from argparse import ArgumentParser
from irc import IRC
from irc.messages import IRCMessage
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
positives = [
"(˶‾᷄ ⁻̫ ‾᷅˵)",
"(っˆڡˆς)",
"♥‿♥",
"(づ｡◕‿‿◕｡)づ",
"٩( ๑╹ ꇴ╹)۶",
"ᕕ( ᐛ )ᕗ",
"... | [
"argparse.ArgumentParser",
"logging.basicConfig",
"random.choice",
"irc.IRC",
"vaderSentiment.vaderSentiment.SentimentIntensityAnalyzer"
] | [((604, 730), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""[%(asctime)s] [%(levelname)-5s] %(message)s"""', 'level': 'logging.INFO', 'datefmt': '"""%Y-%m-%d %H:%M:%S"""'}), "(format='[%(asctime)s] [%(levelname)-5s] %(message)s',\n level=logging.INFO, datefmt='%Y-%m-%d %H:%M:%S')\n", (623, 730), ... |
import gzip
import pandas as pd
import numpy as np
import io
import os
import re
import torch
import torch.utils.data as data_utils
import subprocess
import zipfile
import zlib
from Bio import AlignIO
from Bio.SeqIO.FastaIO import FastaIterator, as_fasta
from Bio.Align.Applications import MuscleCommandline
class Ind... | [
"torch.from_numpy",
"io.StringIO",
"zipfile.ZipFile",
"numpy.random.seed",
"torch.utils.data.DataLoader",
"io.BytesIO",
"pandas.read_csv",
"Bio.SeqIO.FastaIO.FastaIterator",
"torch.load",
"numpy.floor",
"gzip.open",
"pandas.isnull",
"Bio.Align.Applications.MuscleCommandline",
"torch.save",... | [((2335, 2379), 'pandas.read_csv', 'pd.read_csv', (['input[1]'], {'index_col': '(0)', 'header': '(0)'}), '(input[1], index_col=0, header=0)\n', (2346, 2379), True, 'import pandas as pd\n'), ((2393, 2414), 'pandas.read_csv', 'pd.read_csv', (['input[0]'], {}), '(input[0])\n', (2404, 2414), True, 'import pandas as pd\n'),... |
"""construct landmark models """
import json
def read_json(fname):
with open(fname) as fid:
data = json.load(fid)
return data
def write_json(model, fname):
with open(fname, "w") as fid:
json.dump(model, fid)
index = dict(
jaw=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 1... | [
"json.dump",
"json.load"
] | [((113, 127), 'json.load', 'json.load', (['fid'], {}), '(fid)\n', (122, 127), False, 'import json\n'), ((218, 239), 'json.dump', 'json.dump', (['model', 'fid'], {}), '(model, fid)\n', (227, 239), False, 'import json\n')] |
from django.db import models
import datetime
from easy_thumbnails.files import get_thumbnailer
from filer.fields.image import FilerImageField
import shortuuid
class Calendar(models.Model):
name = models.CharField(max_length=250)
uuid = models.CharField(max_length=22)
YEAR_CHOICES = [(r, r) for r in r... | [
"django.db.models.URLField",
"filer.fields.image.FilerImageField",
"django.db.models.CharField",
"shortuuid.uuid",
"django.db.models.ForeignKey",
"easy_thumbnails.files.get_thumbnailer",
"datetime.date.today",
"datetime.datetime.now"
] | [((207, 239), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(250)'}), '(max_length=250)\n', (223, 239), False, 'from django.db import models\n'), ((251, 282), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(22)'}), '(max_length=22)\n', (267, 282), False, 'from django.db ... |
from flask import Blueprint
ctr = Blueprint('ctr', __name__)
from . import views
| [
"flask.Blueprint"
] | [((35, 61), 'flask.Blueprint', 'Blueprint', (['"""ctr"""', '__name__'], {}), "('ctr', __name__)\n", (44, 61), False, 'from flask import Blueprint\n')] |
import tkinter as tk
from megawidget.tree import Hook
class TreeHook(Hook):
def __init__(self, parent_view, nodebar_builder, host):
self._parent_view = parent_view
self._nodebar_builder = nodebar_builder
self._host = host
self._stringvar_expander = tk.StringVar()
self._stri... | [
"tkinter.StringVar",
"tkinter.Entry",
"tkinter.Button",
"tkinter.Frame"
] | [((287, 301), 'tkinter.StringVar', 'tk.StringVar', ([], {}), '()\n', (299, 301), True, 'import tkinter as tk\n'), ((334, 348), 'tkinter.StringVar', 'tk.StringVar', ([], {}), '()\n', (346, 348), True, 'import tkinter as tk\n'), ((2019, 2123), 'tkinter.Button', 'tk.Button', (['frame'], {'name': '"""treeExpanderButton"""'... |
#!/usr/bin/python
# This file is licensed under MIT license.
# See the LICENSE file in the project root for more information.
import unittest
import rostest
import rosunit
import numpy as np
from numpy.testing import assert_almost_equal
from std_msgs.msg import Header
from geometry_msgs.msg import PoseStamped, Pose,... | [
"geometry_msgs.msg.PoseStamped",
"car_core.common.msgs_helpers.path_poses_to_array",
"car_core.common.msgs_helpers.array_to_point",
"rosunit.unitrun",
"car_core.common.msgs_helpers.array_to_path_poses",
"car_core.common.geom_helpers.get_closest_path_point",
"car_core.common.msgs_helpers.point_to_array",... | [((3932, 3997), 'rosunit.unitrun', 'rosunit.unitrun', (['"""car_core"""', '"""test_msgs_helpers"""', 'TestMsgsHelpers'], {}), "('car_core', 'test_msgs_helpers', TestMsgsHelpers)\n", (3947, 3997), False, 'import rosunit\n'), ((4002, 4067), 'rosunit.unitrun', 'rosunit.unitrun', (['"""car_core"""', '"""test_geom_helpers""... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
from PyQt5.QtGui import QPixmap, QPainter, QFont
from PyQt5.QtWidgets import QApplication, QLabel
from PyQt5.QtCore import Qt, QRect
app = QApplication([])
text = "Hello World!"
pixmap = QPixmap(180, 130)
pixmap.fill(Qt.white)
painter = QPai... | [
"PyQt5.QtGui.QPainter",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtCore.QRect",
"PyQt5.QtGui.QFont",
"PyQt5.QtGui.QPixmap",
"PyQt5.QtWidgets.QApplication"
] | [((215, 231), 'PyQt5.QtWidgets.QApplication', 'QApplication', (['[]'], {}), '([])\n', (227, 231), False, 'from PyQt5.QtWidgets import QApplication, QLabel\n'), ((265, 282), 'PyQt5.QtGui.QPixmap', 'QPixmap', (['(180)', '(130)'], {}), '(180, 130)\n', (272, 282), False, 'from PyQt5.QtGui import QPixmap, QPainter, QFont\n'... |
from django.dispatch import Signal
# Arguments: "msg"
email_sent = Signal()
| [
"django.dispatch.Signal"
] | [((68, 76), 'django.dispatch.Signal', 'Signal', ([], {}), '()\n', (74, 76), False, 'from django.dispatch import Signal\n')] |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
import numpy as np
from typing import Union
from sklearn.manifold import TSNE
def tsne(
embedding: np.ndarray,
num_components: int = 2,
perplexity: float = 30.0,
early_exaggeration: float = 12.0,
learning... | [
"sklearn.manifold.TSNE"
] | [((6728, 7078), 'sklearn.manifold.TSNE', 'TSNE', ([], {'n_components': 'num_components', 'perplexity': 'perplexity', 'early_exaggeration': 'early_exaggeration', 'learning_rate': 'learning_rate', 'n_iter': 'num_iterations', 'n_iter_without_progress': 'num_iterations_without_progress', 'min_grad_norm': 'min_grad_norm', '... |
from django import forms
import voxel_globe.meta.models as models
class TiePointForm(forms.Form):
image_set = forms.ModelChoiceField(label="Image Set",
queryset=models.ImageSet.objects.all().order_by('name'))
class PointCloudForm(forms.Form):
point_cloud = forms.ModelChoiceField(label="Point Cloud",
... | [
"voxel_globe.meta.models.CameraSet.objects.all",
"voxel_globe.meta.models.Image.objects.all",
"voxel_globe.meta.models.ImageSet.objects.all",
"voxel_globe.meta.models.PointCloud.objects.all"
] | [((171, 200), 'voxel_globe.meta.models.ImageSet.objects.all', 'models.ImageSet.objects.all', ([], {}), '()\n', (198, 200), True, 'import voxel_globe.meta.models as models\n'), ((330, 361), 'voxel_globe.meta.models.PointCloud.objects.all', 'models.PointCloud.objects.all', ([], {}), '()\n', (359, 361), True, 'import voxe... |
import cv2
import numpy as np
imagen = cv2.imread('imagen.jpg')
imagen = cv2.cvtColor(imagen,cv2.COLOR_BGR2RGB)
print(imagen.shape)
print(imagen[0][0][0])
imagen = cv2.resize(imagen,(256, 256))
imagen = cv2.imread('imagen.jpg')
imagen = cv2.cvtColor(imagen,cv2.COLOR_BGR2GRAY)
print(imagen.shape)
print(imagen[0][0])
... | [
"cv2.cvtColor",
"cv2.imwrite",
"numpy.zeros",
"cv2.imread",
"cv2.resize"
] | [((40, 64), 'cv2.imread', 'cv2.imread', (['"""imagen.jpg"""'], {}), "('imagen.jpg')\n", (50, 64), False, 'import cv2\n'), ((74, 113), 'cv2.cvtColor', 'cv2.cvtColor', (['imagen', 'cv2.COLOR_BGR2RGB'], {}), '(imagen, cv2.COLOR_BGR2RGB)\n', (86, 113), False, 'import cv2\n'), ((165, 195), 'cv2.resize', 'cv2.resize', (['ima... |
# --------------------------------------------------------
# Faster R-CNN
# Copyright (c) 2015 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by <NAME> and <NAME>
# --------------------------------------------------------
# --------------------------------------------------------
# Reorg... | [
"torch.FloatTensor",
"torch.cat",
"torch.nonzero",
"torch.max",
"torch.arange",
"numpy.random.permutation",
"numpy.random.rand",
"numpy.round",
"torch.from_numpy"
] | [((1065, 1114), 'torch.FloatTensor', 'torch.FloatTensor', (['cfg.TRAIN.BBOX_NORMALIZE_MEANS'], {}), '(cfg.TRAIN.BBOX_NORMALIZE_MEANS)\n', (1082, 1114), False, 'import torch\n'), ((1150, 1198), 'torch.FloatTensor', 'torch.FloatTensor', (['cfg.TRAIN.BBOX_NORMALIZE_STDS'], {}), '(cfg.TRAIN.BBOX_NORMALIZE_STDS)\n', (1167, ... |
# -*- coding: utf-8 -*-
"""Model.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1QPnK5YOh8kRYPOOue6txwrgUqwKOMS0I
"""
# # Use seaborn for pairplot
# !pip install -q seaborn
# !pip install tensorflow==2.0.0
# # Use some functions from tensorflow_... | [
"pandas.DataFrame",
"matplotlib.rc",
"warnings.filterwarnings",
"pandas.read_csv",
"datetime.strptime",
"tensorflow.keras.layers.Dense",
"pandas.isnull",
"sklearn.preprocessing.LabelEncoder",
"matplotlib.pyplot.style.use",
"numpy.int64",
"tensorflow.keras.optimizers.RMSprop"
] | [((1373, 1405), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""fivethirtyeight"""'], {}), "('fivethirtyeight')\n", (1386, 1405), True, 'import matplotlib.pyplot as plt\n'), ((1406, 1455), 'matplotlib.rc', 'mpl.rc', (['"""patch"""'], {'edgecolor': '"""dimgray"""', 'linewidth': '(1)'}), "('patch', edgecolor='dimgr... |
from datetime import datetime
from utils.api import API
from time import sleep
from config import *
import random
def load_file(file):
try:
l = []
with open(file, 'r') as f:
for line in f:
l.append(line.rstrip())
return l
except FileNotFoundErr... | [
"utils.api.API",
"datetime.datetime.now",
"random.randint",
"time.sleep"
] | [((440, 517), 'utils.api.API', 'API', (['REDDIT_CLIENT_ID', 'REDDIT_CLIENT_SECRET', 'REDDIT_USERNAME', 'REDDIT_PASSWORD'], {}), '(REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET, REDDIT_USERNAME, REDDIT_PASSWORD)\n', (443, 517), False, 'from utils.api import API\n'), ((782, 790), 'time.sleep', 'sleep', (['(1)'], {}), '(1)\n', (... |
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
from scrapy.loader.processors import TakeFirst, Join, MapCompose
from datetime import datetime, timedelta
def comments_strip(string,loader_context):... | [
"scrapy.loader.processors.Join",
"scrapy.Field",
"json.loads",
"datetime.datetime.fromtimestamp"
] | [((3018, 3037), 'json.loads', 'json.loads', (['date[0]'], {}), '(date[0])\n', (3028, 3037), False, 'import json\n'), ((3681, 3709), 'json.loads', 'json.loads', (['post_id[::-1][0]'], {}), '(post_id[::-1][0])\n', (3691, 3709), False, 'import json\n'), ((3825, 3839), 'scrapy.Field', 'scrapy.Field', ([], {}), '()\n', (383... |
#!/usr/bin/env python3
import os, sys, subprocess, socket
#import cgroups
def start_mjpg_streamer():
print("Starting up mjpg_streamer.")
# TODO: Add notification if either mjpg-streamer or
# cvfilter_py.so aren't installed
# TODO: Detect any error if process exits,
# such as the uvcvid... | [
"line_follower.mjs_filter",
"os.path.realpath",
"socket.socket",
"car_control.car_control"
] | [((1140, 1168), 'line_follower.mjs_filter', 'line_follower.mjs_filter', (['dc'], {}), '(dc)\n', (1164, 1168), False, 'import line_follower\n'), ((1402, 1427), 'car_control.car_control', 'car_control.car_control', ([], {}), '()\n', (1425, 1427), False, 'import car_control\n'), ((1549, 1597), 'socket.socket', 'socket.soc... |
import os
import json
from flask import Flask
from tqdm import tqdm
from ..validator.schema_validator import Validator
from ..utils.paths import get_path
app = Flask(__name__)
# Function to accept user-generated feedstock
# Args:
# path: Path to the feedstock
# remove_old: Should fully accepted feedstock be rem... | [
"os.remove",
"json.loads",
"os.path.basename",
"flask.Flask",
"os.path.join",
"os.listdir"
] | [((163, 178), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (168, 178), False, 'from flask import Flask\n'), ((1036, 1051), 'os.remove', 'os.remove', (['path'], {}), '(path)\n', (1045, 1051), False, 'import os\n'), ((1664, 1680), 'os.listdir', 'os.listdir', (['path'], {}), '(path)\n', (1674, 1680), False,... |
import os
os.environ['MANTLE'] = 'lattice'
from magma import *
from mantle import And, XOr
from simulator import testvectors
main = DefineCircuit('main', "a", In(Bit), "b", In(Bit), "c", In(Bit), "d", Out(Bit), 'CLK', In(Bit))
t = And(2)(main.a,main.b)
d = XOr(2)(t,main.c)
wire(d,main.d)
EndCircuit()
print(testvecto... | [
"simulator.testvectors",
"mantle.XOr",
"mantle.And"
] | [((233, 239), 'mantle.And', 'And', (['(2)'], {}), '(2)\n', (236, 239), False, 'from mantle import And, XOr\n'), ((259, 265), 'mantle.XOr', 'XOr', (['(2)'], {}), '(2)\n', (262, 265), False, 'from mantle import And, XOr\n'), ((311, 328), 'simulator.testvectors', 'testvectors', (['main'], {}), '(main)\n', (322, 328), Fals... |
from __future__ import absolute_import
# --------------------------------------------------------
# Spatial Attention Network withFeature Mimicking
# Copyright (c) 2018 University of Illinois
# Licensed under The MIT License [see LICENSE for details]
# --------------------------------------------------------
# --------... | [
"numpy.amax",
"numpy.argsort",
"numpy.zeros"
] | [((1534, 1559), 'numpy.amax', 'np.amax', (['cls_prob'], {'axis': '(1)'}), '(cls_prob, axis=1)\n', (1541, 1559), True, 'import numpy as np\n'), ((1775, 1826), 'numpy.zeros', 'np.zeros', (['(proposals.shape[0], 1)'], {'dtype': 'np.float32'}), '((proposals.shape[0], 1), dtype=np.float32)\n', (1783, 1826), True, 'import nu... |