code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# -*- coding: utf-8 -*-
# Scrapy settings for soccer_spider project
#
# For simplicity, this file contains only the most important settings by
# default. All the other settings are documented here:
#
# http://doc.scrapy.org/en/latest/topics/settings.html
#
import os
import sys
import django
def setup_django_env... | [
"django.setup",
"os.path.join"
] | [((439, 453), 'django.setup', 'django.setup', ([], {}), '()\n', (451, 453), False, 'import django\n'), ((356, 374), 'os.path.join', 'os.path.join', (['path'], {}), '(path)\n', (368, 374), False, 'import os\n')] |
#!/usr/bin/python
from __future__ import print_function
import argparse
import hashlib
import json
import logging
import os
import pipes
import sys
READ_SIZE = 1024 * 4
if not sys.version_info > (3, 0):
if not hasattr(sys, 'setdefaultencoding'):
reload(sys)
sys.setdefaultencoding('utf8')
class Erro... | [
"sys.setdefaultencoding",
"logging.debug",
"json.JSONEncoder.default",
"sys.exit",
"os.path.islink",
"hashlib.sha1",
"logging.info",
"logging.error",
"os.walk",
"os.path.exists",
"argparse.ArgumentParser",
"json.dumps",
"os.path.isdir",
"os.unlink",
"logging.critical",
"pipes.quote",
... | [((277, 307), 'sys.setdefaultencoding', 'sys.setdefaultencoding', (['"""utf8"""'], {}), "('utf8')\n", (299, 307), False, 'import sys\n'), ((3170, 3203), 'logging.debug', 'logging.debug', (['"""walking %s"""', 'root'], {}), "('walking %s', root)\n", (3183, 3203), False, 'import logging\n'), ((3246, 3259), 'os.walk', 'os... |
import sqlite3
try:
banco = sqlite3.connect('primeiro_banco.db')
cursor = banco.cursor()
#cursor.execute("CREATE TABLE pessoas(nome text, idade integer, email text)")
#cursor.execute("INSERT INTO pessoas VALUES('Maria', 40, '<EMAIL>')")
#cursor.close()
cursor.execute("DELETE FROM pessoas WHERE ... | [
"sqlite3.connect"
] | [((33, 69), 'sqlite3.connect', 'sqlite3.connect', (['"""primeiro_banco.db"""'], {}), "('primeiro_banco.db')\n", (48, 69), False, 'import sqlite3\n')] |
""" Module for Airtunnel's metadata sensors. """
from datetime import timedelta, datetime
from typing import Optional, Iterable
from airflow.operators.sensors import BaseSensorOperator
from airflow.utils.decorators import apply_defaults
import airtunnel.operators
from airtunnel import BaseDataAsset
from airtunnel.me... | [
"airtunnel.metadata.adapter.get_configured_meta_adapter",
"datetime.timedelta",
"datetime.datetime.now"
] | [((1903, 1932), 'airtunnel.metadata.adapter.get_configured_meta_adapter', 'get_configured_meta_adapter', ([], {}), '()\n', (1930, 1932), False, 'from airtunnel.metadata.adapter import get_configured_meta_adapter\n'), ((4068, 4097), 'airtunnel.metadata.adapter.get_configured_meta_adapter', 'get_configured_meta_adapter',... |
import os
import sys
from setuptools import setup
with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as readme:
long_description = readme.read()
install_requires = ['nuitka>=0.6<0.7', ]
PY2 = sys.version_info[0] == 2
if PY2:
install_requires.append('pathlib2')
setup(
name='nuitka_setuptoo... | [
"os.path.dirname",
"setuptools.setup"
] | [((288, 719), 'setuptools.setup', 'setup', ([], {'name': '"""nuitka_setuptools2"""', 'version': '"""3.0.0"""', 'py_modules': "['nuitka_setuptools']", 'description': '"""Extension to setuptools to run your package through nuitka to produce compiled, faster, obfuscated binary modules."""', 'long_description': 'long_descr... |
from zisan.Seg.Interface import ImgSeg, markTools
import os
import numpy as np
import cv2
from PIL import Image
current_path = os.path.dirname(__file__)
lines=[[(281,120),(267,341)],[(279,157),(208,171)],[(309,170),(308,250)],[(275,233),(370,341)]]
model=ImgSeg(current_path+'/Jintu_SEG_Interactive.pth')
img=Image.op... | [
"os.path.dirname",
"zisan.Seg.Interface.markTools",
"PIL.Image.open",
"zisan.Seg.Interface.ImgSeg"
] | [((128, 153), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (143, 153), False, 'import os\n'), ((257, 308), 'zisan.Seg.Interface.ImgSeg', 'ImgSeg', (["(current_path + '/Jintu_SEG_Interactive.pth')"], {}), "(current_path + '/Jintu_SEG_Interactive.pth')\n", (263, 308), False, 'from zisan.Seg.I... |
from numpy import genfromtxt
import numpy as np
import matplotlib.pyplot as plt
import sys
filepath = 'dummy.csv'
if len(sys.argv) >= 2:
filepath = sys.argv[1]
print(filepath)
log_data = genfromtxt(filepath,
delimiter=',',
skip_header=1,
... | [
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.array",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.step",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.show"
] | [((2442, 2486), 'matplotlib.pyplot.subplots_adjust', 'plt.subplots_adjust', ([], {'wspace': 'None', 'hspace': '(0.5)'}), '(wspace=None, hspace=0.5)\n', (2461, 2486), True, 'import matplotlib.pyplot as plt\n'), ((2488, 2508), 'matplotlib.pyplot.subplot', 'plt.subplot', (['(2)', '(2)', '(1)'], {}), '(2, 2, 1)\n', (2499, ... |
from rest_framework import serializers
from .models import Country, Region, Currency, Continent
from logging import getLogger
# LOGGING
# ---------------------------------------------------------------------------------------------------------------------#
logger = getLogger('django')
# SERIALIZERS
# --------------... | [
"logging.getLogger",
"rest_framework.serializers.StringRelatedField"
] | [((268, 287), 'logging.getLogger', 'getLogger', (['"""django"""'], {}), "('django')\n", (277, 287), False, 'from logging import getLogger\n'), ((640, 698), 'rest_framework.serializers.StringRelatedField', 'serializers.StringRelatedField', ([], {'many': '(True)', 'read_only': '(False)'}), '(many=True, read_only=False)\n... |
import uuid
import os
def unique_upload(instance, filename):
ext = filename.split('.').pop()
return "{}.{}".format(uuid.uuid4(), ext)
| [
"uuid.uuid4"
] | [((124, 136), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (134, 136), False, 'import uuid\n')] |
import argparse
from pathlib import Path
import shutil
from sphfile import SPHFile
parser = argparse.ArgumentParser()
parser.add_argument("src_dir")
parser.add_argument("dest_dir")
args = parser.parse_args()
src = Path(args.src_dir)
dest = Path(args.dest_dir)
for file_sph in (src / "sph").iterdir():
file_stm =... | [
"argparse.ArgumentParser",
"pathlib.Path"
] | [((94, 119), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (117, 119), False, 'import argparse\n'), ((217, 235), 'pathlib.Path', 'Path', (['args.src_dir'], {}), '(args.src_dir)\n', (221, 235), False, 'from pathlib import Path\n'), ((243, 262), 'pathlib.Path', 'Path', (['args.dest_dir'], {}), '... |
import tensorflow as tf
class InfNet(tf.keras.Model):
def __init__(self, hiddim):
super(InfNet, self).__init__()
self.infer = tf.keras.Sequential([
tf.keras.layers.Conv3D(hiddim, 3, 1, "same"),
tf.keras.layers.Activation("elu"),
tf.keras.layers... | [
"tensorflow.keras.layers.Conv3D",
"tensorflow.expand_dims",
"tensorflow.keras.layers.Activation"
] | [((528, 548), 'tensorflow.expand_dims', 'tf.expand_dims', (['x', '(0)'], {}), '(x, 0)\n', (542, 548), True, 'import tensorflow as tf\n'), ((180, 224), 'tensorflow.keras.layers.Conv3D', 'tf.keras.layers.Conv3D', (['hiddim', '(3)', '(1)', '"""same"""'], {}), "(hiddim, 3, 1, 'same')\n", (202, 224), True, 'import tensorflo... |
#!/usr/bin/env python3
# This is run by the "run-tests" script.
import unittest
import signal
import socket
class TestTimeout(unittest.TestCase):
def test_timeout(self):
port = 12346
s = socket.socket()
s.connect(("0.0.0.0", port))
# Assumes the server has --timeout 1
signal... | [
"unittest.main",
"signal.alarm",
"socket.socket"
] | [((518, 533), 'unittest.main', 'unittest.main', ([], {}), '()\n', (531, 533), False, 'import unittest\n'), ((208, 223), 'socket.socket', 'socket.socket', ([], {}), '()\n', (221, 223), False, 'import socket\n'), ((314, 329), 'signal.alarm', 'signal.alarm', (['(3)'], {}), '(3)\n', (326, 329), False, 'import signal\n'), (... |
import os
import random
import re
import sys
DAMPING = 0.85
SAMPLES = 10000
def main():
if len(sys.argv) != 2:
sys.exit("Usage: python pagerank.py corpus")
corpus = crawl(sys.argv[1])
ranks = sample_pagerank(corpus, DAMPING, SAMPLES)
print(f"PageRank Results from Sampling (n = {SAMPLES})")
... | [
"os.listdir",
"os.path.join",
"random.random",
"sys.exit",
"re.findall"
] | [((897, 918), 'os.listdir', 'os.listdir', (['directory'], {}), '(directory)\n', (907, 918), False, 'import os\n'), ((4439, 4454), 'random.random', 'random.random', ([], {}), '()\n', (4452, 4454), False, 'import random\n'), ((126, 170), 'sys.exit', 'sys.exit', (['"""Usage: python pagerank.py corpus"""'], {}), "('Usage: ... |
from snovault import (
upgrade_step,
)
@upgrade_step('workflow_run_awsem', '1', '2')
@upgrade_step('workflow_run_sbg', '1', '2')
@upgrade_step('workflow_run', '1', '2')
def workflow_run_1_2(value, system):
'''Change input_files.format_if_extra to FileFormat'''
formats = system['registry']['collections']['... | [
"snovault.upgrade_step"
] | [((46, 90), 'snovault.upgrade_step', 'upgrade_step', (['"""workflow_run_awsem"""', '"""1"""', '"""2"""'], {}), "('workflow_run_awsem', '1', '2')\n", (58, 90), False, 'from snovault import upgrade_step\n'), ((92, 134), 'snovault.upgrade_step', 'upgrade_step', (['"""workflow_run_sbg"""', '"""1"""', '"""2"""'], {}), "('wo... |
# -*- coding: utf-8 -*-
# Define here the models for your spider middleware
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/spider-middleware.html
from scrapy import signals
from scrapy.exceptions import IgnoreRequest
from urllib.parse import parse_qsl,urlencode,urlsplit,urluns... | [
"urllib.parse.urlsplit",
"urllib.parse.urlunsplit",
"io.BytesIO",
"urllib.parse.parse_qsl",
"pyocr.libtesseract.image_to_string"
] | [((851, 867), 'io.BytesIO', 'BytesIO', (['captcha'], {}), '(captcha)\n', (858, 867), False, 'from io import BytesIO\n'), ((1191, 1230), 'urllib.parse.parse_qsl', 'parse_qsl', (['body'], {'keep_blank_values': '(True)'}), '(body, keep_blank_values=True)\n', (1200, 1230), False, 'from urllib.parse import parse_qsl, urlenc... |
import unittest
from io import StringIO
from book_parser import parse, Styles, ParagraphState, BulletedState, \
ParsingState, DiagramState, MetadataState
class BookParserTest(unittest.TestCase):
def test_paragraph(self):
source = """\
This is a one-line paragraph.
"""
expected_tree = [Paragra... | [
"book_parser.DiagramState",
"book_parser.ParsingState",
"book_parser.parse",
"book_parser.MetadataState",
"book_parser.BulletedState",
"io.StringIO",
"book_parser.ParagraphState"
] | [((4623, 4636), 'book_parser.parse', 'parse', (['source'], {}), '(source)\n', (4628, 4636), False, 'from book_parser import parse, Styles, ParagraphState, BulletedState, ParsingState, DiagramState, MetadataState\n'), ((4653, 4663), 'io.StringIO', 'StringIO', ([], {}), '()\n', (4661, 4663), False, 'from io import String... |
from setuptools import setup
from os.path import join, dirname, abspath
def requirements():
basedir = abspath(dirname(__file__))
with open(join(basedir, 'requirements.txt')) as f:
return f.read().splitlines()
setup(
name='mazure',
version='1.0.0',
py_modules=['mazure'],
include_pack... | [
"os.path.dirname",
"os.path.join"
] | [((117, 134), 'os.path.dirname', 'dirname', (['__file__'], {}), '(__file__)\n', (124, 134), False, 'from os.path import join, dirname, abspath\n'), ((150, 183), 'os.path.join', 'join', (['basedir', '"""requirements.txt"""'], {}), "(basedir, 'requirements.txt')\n", (154, 183), False, 'from os.path import join, dirname, ... |
# Actual movies.py from codecademy
import pandas as pd
from random import shuffle, seed
import numpy as np
seed(100)
df = pd.read_csv("movies.csv")
df = df.dropna()
good_movies = df.loc[df['imdb_score'] >= 7]
bad_movies = df.loc[df['imdb_score'] < 7]
def min_max_normalize(lst):
minimum = min(lst)
maximum = max(ls... | [
"numpy.array",
"random.shuffle",
"random.seed",
"pandas.read_csv"
] | [((108, 117), 'random.seed', 'seed', (['(100)'], {}), '(100)\n', (112, 117), False, 'from random import shuffle, seed\n'), ((124, 149), 'pandas.read_csv', 'pd.read_csv', (['"""movies.csv"""'], {}), "('movies.csv')\n", (135, 149), True, 'import pandas as pd\n'), ((1145, 1161), 'random.shuffle', 'shuffle', (['dataset'], ... |
import os
import re
import hashlib
import subprocess
from filecmp import cmp
from rdkit.Chem import AllChem
from minedatabase import pickaxe
from minedatabase.databases import MINE
data_dir = os.path.dirname(__file__)+'/data'
def purge(directory, pattern):
for f in os.listdir(directory):
if re.search(pa... | [
"os.path.exists",
"os.listdir",
"os.path.join",
"os.chdir",
"os.path.dirname",
"minedatabase.databases.MINE",
"os.remove",
"subprocess.call",
"minedatabase.pickaxe.Pickaxe",
"filecmp.cmp",
"re.search"
] | [((387, 404), 'minedatabase.pickaxe.Pickaxe', 'pickaxe.Pickaxe', ([], {}), '()\n', (402, 404), False, 'from minedatabase import pickaxe\n'), ((194, 219), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (209, 219), False, 'import os\n'), ((274, 295), 'os.listdir', 'os.listdir', (['directory'], ... |
import datetime as dt
import pytz
from django.conf import settings
from .helpers import bytes2human
from rest_framework.serializers import (
ModelSerializer,
ReadOnlyField,
SerializerMethodField,
)
from .models import Agent, Client, OffsiteJob, BackupJob
class BackupScheduleSerializer(ModelSerializer)... | [
"pytz.timezone",
"datetime.datetime.strftime",
"rest_framework.serializers.SerializerMethodField",
"rest_framework.serializers.ReadOnlyField"
] | [((584, 622), 'rest_framework.serializers.ReadOnlyField', 'ReadOnlyField', ([], {'source': '"""agent.hostname"""'}), "(source='agent.hostname')\n", (597, 622), False, 'from rest_framework.serializers import ModelSerializer, ReadOnlyField, SerializerMethodField\n'), ((636, 677), 'rest_framework.serializers.ReadOnlyField... |
'''aurora -- a simple, rest easy blog
The idea for this software was taken directly from toto:
https://github.com/cloudhead/toto
I loved the idea of a Git powered blog, but being the Python guy that
I am (now) it didn't seem right to be running something in Ruby. Also,
much harder and slower for me to work with.... | [
"flask.render_template",
"markdown.markdown",
"PyRSS2Gen.Guid",
"flask.Flask",
"datetime.datetime.utcnow",
"datetime.datetime.strptime",
"os.environ.get",
"flask.redirect",
"time.time"
] | [((870, 885), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (875, 885), False, 'from flask import Flask, render_template, redirect, Markup, make_response, escape\n'), ((1041, 1070), 'flask.render_template', 'render_template', (['tmpl'], {}), '(tmpl, **args)\n', (1056, 1070), False, 'from flask import Flas... |
import os
import time
import logging
import unittest
import binascii
import contextlib
import dissect.formats.mbr as mbr
import dissect.formats.fat32 as fat32
TEST_IMAGE_PATH = "test.dd"
KILOBYTE = 1024
MEGABYTE = 1024 * KILOBYTE
GIGABYTE = 1024 * MEGABYTE
TERABYTE = 1024 * GIGABYTE
TEST_IMAGE_SIZE = 40 * MEGABYTE
T... | [
"logging.basicConfig",
"dissect.formats.fat32.FAT32",
"dissect.formats.mbr.MBR",
"dissect.formats.fat32.FAT32LogicalFileSystem",
"dissect.formats.fat32.DIRECTORY_DATA.compute83Hash",
"unittest.main",
"os.remove"
] | [((2106, 2123), 'dissect.formats.fat32.FAT32', 'fat32.FAT32', (['(True)'], {}), '(True)\n', (2117, 2123), True, 'import dissect.formats.fat32 as fat32\n'), ((1027, 1040), 'dissect.formats.mbr.MBR', 'mbr.MBR', (['path'], {}), '(path)\n', (1034, 1040), True, 'import dissect.formats.mbr as mbr\n'), ((6820, 6846), 'os.remo... |
# Need fastentrypoints to monkey patch setuptools for faster console_scripts
# noinspection PyUnresolvedReferences
import fastentrypoints
from setuptools import setup, find_packages
import versioneer
setup(name='firex_blaze',
version=versioneer.get_version(),
cmdclass=versioneer.get_cmdclass(),
descr... | [
"versioneer.get_cmdclass",
"setuptools.find_packages",
"versioneer.get_version"
] | [((241, 265), 'versioneer.get_version', 'versioneer.get_version', ([], {}), '()\n', (263, 265), False, 'import versioneer\n'), ((282, 307), 'versioneer.get_cmdclass', 'versioneer.get_cmdclass', ([], {}), '()\n', (305, 307), False, 'import versioneer\n'), ((536, 551), 'setuptools.find_packages', 'find_packages', ([], {}... |
#!/usr/bin/env python3
import zlib
import json
import random
import requests
import string
import sys
eval_config = {
"Counsumers": [],
"Routes": [
{
"id": str(random.randint(100000000000000000, 1000000000000000000)),
"create_time": 1640674554,
"update_time": 164067... | [
"requests.post",
"json.dumps",
"requests.get",
"random.choices",
"zlib.crc32",
"random.randint"
] | [((1236, 1286), 'requests.get', 'requests.get', (["(url + '/apisix/admin/migrate/export')"], {}), "(url + '/apisix/admin/migrate/export')\n", (1248, 1286), False, 'import requests\n'), ((1474, 1538), 'requests.post', 'requests.post', (["(url + '/apisix/admin/migrate/import')"], {'files': 'files'}), "(url + '/apisix/adm... |
# Generated by Django 2.2.6 on 2020-02-01 13:34
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('dashboard', '0015_auto_20200201_1633'),
]
operations = [
migrations.AlterField(
model_name='bus_station',
name='stat... | [
"django.db.models.IntegerField"
] | [((347, 401), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'primary_key': '(True)', 'serialize': '(False)'}), '(primary_key=True, serialize=False)\n', (366, 401), False, 'from django.db import migrations, models\n'), ((532, 553), 'django.db.models.IntegerField', 'models.IntegerField', ([], {}), '()\n',... |
from argparse import ArgumentParser
from matplotlib import pyplot as plt
from greengraph import Greengraph
from map import Map
def process():
parser = ArgumentParser(description = "Create a graph showing number of green pixels between two locations on a satellite image")
parser.add_argument('--origin', h... | [
"argparse.ArgumentParser",
"matplotlib.pyplot.close",
"greengraph.Greengraph",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show"
] | [((157, 285), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Create a graph showing number of green pixels between two locations on a satellite image"""'}), "(description=\n 'Create a graph showing number of green pixels between two locations on a satellite image'\n )\n", (171, 285), False,... |
#!/usr/bin/env python3
from automata.fa.dfa import DFA
import sys
input = sys.argv[1]
if not input.isnumeric:
print("ๅผๆฐใซใฏๆฐๅคใๆๅฎใใฆใใ ใใ")
sys.exit(1)
modulo = DFA(
states = {'q0', 'q1', 'q2'},
input_symbols = {'0', '1'},
transitions = {
'q0': {'0': 'q0', '1': 'q1'},
'q1': {'0': 'q2... | [
"automata.fa.dfa.DFA",
"sys.exit"
] | [((169, 378), 'automata.fa.dfa.DFA', 'DFA', ([], {'states': "{'q0', 'q1', 'q2'}", 'input_symbols': "{'0', '1'}", 'transitions': "{'q0': {'0': 'q0', '1': 'q1'}, 'q1': {'0': 'q2', '1': 'q0'}, 'q2': {'0':\n 'q1', '1': 'q2'}}", 'initial_state': '"""q0"""', 'final_states': "{'q0'}"}), "(states={'q0', 'q1', 'q2'}, input_s... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from collections import namedtuple
from subprocess import run
from time import sleep
Data = namedtuple('Data', ['username', 'password'])
def main() -> None:
active_window = run(args=['xdotool', 'getactivewindow'],
capture_output=True, encodin... | [
"subprocess.run",
"collections.namedtuple",
"time.sleep"
] | [((140, 184), 'collections.namedtuple', 'namedtuple', (['"""Data"""', "['username', 'password']"], {}), "('Data', ['username', 'password'])\n", (150, 184), False, 'from collections import namedtuple\n'), ((2261, 2272), 'time.sleep', 'sleep', (['(0.05)'], {}), '(0.05)\n', (2266, 2272), False, 'from time import sleep\n')... |
import logging
from typing import Union
import boto3 # type: ignore
from collections import namedtuple
from aws_network_tap.models.sap_filter import SapFilter
from aws_network_tap.models.ec2_api_client import ENI_Tag, VENDOR, Ec2ApiClient
from aws_network_tap.models.aws_tag import AWSTag
MirrorSession = namedtuple("S... | [
"aws_network_tap.models.aws_tag.AWSTag.to_tags",
"collections.namedtuple",
"aws_network_tap.models.aws_tag.AWSTag.to_dict",
"logging.warning",
"aws_network_tap.models.sap_filter.SapFilter",
"logging.info"
] | [((307, 378), 'collections.namedtuple', 'namedtuple', (['"""SessionMirror"""', '"""id target_id filter_id interface_id tags"""'], {}), "('SessionMirror', 'id target_id filter_id interface_id tags')\n", (317, 378), False, 'from collections import namedtuple\n'), ((1788, 1813), 'aws_network_tap.models.aws_tag.AWSTag.to_d... |
import streamlit as st
import requests
# Set up some defaults
endpoint = 'http://0.0.0.0:45678/search'
top_k = 10 # Number of results to return
def get_data(query: str, endpoint: str, top_k: int) -> dict:
headers = {
"Content-Type": "application/json",
}
data = '{"top_k":' + str(top_k) + ',"mode"... | [
"streamlit.sidebar.title",
"streamlit.markdown",
"streamlit.sidebar.text_input",
"requests.post",
"streamlit.button",
"streamlit.json",
"streamlit.sidebar.selectbox",
"streamlit.sidebar.number_input",
"streamlit.text_input",
"streamlit.title"
] | [((570, 979), 'streamlit.markdown', 'st.markdown', (['f"""\n<style>\n .reportview-container .main .block-container{{\n max-width: {max_width}px;\n padding-top: {padding}rem;\n padding-right: {padding}rem;\n padding-left: {padding}rem;\n padding-bottom: {padding}rem;\n }}\n .r... |
import os
import json
import logging
import pkg_resources
import context
from flask import Blueprint, render_template, send_file, abort
pages_blueprint = Blueprint('pages_api', __name__)
logger = logging.getLogger(__name__)
@pages_blueprint.route("/")
def index():
return render_template("index.html")
@pages_b... | [
"logging.getLogger",
"flask.render_template",
"os.path.exists",
"context.security.authorization_required",
"os.getenv",
"os.path.normpath",
"os.sep.join",
"flask.abort",
"flask.send_file",
"flask.Blueprint"
] | [((157, 189), 'flask.Blueprint', 'Blueprint', (['"""pages_api"""', '__name__'], {}), "('pages_api', __name__)\n", (166, 189), False, 'from flask import Blueprint, render_template, send_file, abort\n'), ((200, 227), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (217, 227), False, 'import ... |
from Clause import Clause
class SAT(object):
def __init__(self, clause_list):
"""clause_list is a list of lists (or better, an iterable of
iterables), to represent a list or set of clauses."""
raw_clauses = {Clause(c) for c in clause_list}
# We do some initial sanity checking.
... | [
"Clause.Clause"
] | [((238, 247), 'Clause.Clause', 'Clause', (['c'], {}), '(c)\n', (244, 247), False, 'from Clause import Clause\n')] |
#
# Aggregation of changing ROS topic values over time. Supports the following use cases:
#
# 1) Latching infrequent values (with expiration)
# 2) Aggregating values over a moving window, with tolerance
#
import rospy
class LatchedValue:
def __init__(self, topic, max_age, value):
self.topic = topic
... | [
"numpy.sqrt",
"rospy.get_rostime",
"rospy.Time.now",
"numpy.sum",
"numpy.array",
"numpy.nonzero",
"numpy.zeros_like",
"rospy.loginfo",
"sklearn.cluster.DBSCAN"
] | [((1419, 1436), 'numpy.sum', 'np.sum', (['arr[:, 0]'], {}), '(arr[:, 0])\n', (1425, 1436), True, 'import numpy as np\n'), ((1449, 1466), 'numpy.sum', 'np.sum', (['arr[:, 1]'], {}), '(arr[:, 1])\n', (1455, 1466), True, 'import numpy as np\n'), ((404, 423), 'rospy.get_rostime', 'rospy.get_rostime', ([], {}), '()\n', (421... |
"""
A program to fetch various information related to url shotener bit.ly
associated with USA Gov and applying pandas operations on them
"""
import pandas as pd
import numpy as np
# Creating the dataframe of the json file containing all the url shortener hits
# pandas.read_json is convert json string to pandas o... | [
"pandas.read_json"
] | [((394, 432), 'pandas.read_json', 'pd.read_json', (['"""bitly.json"""'], {'lines': '(True)'}), "('bitly.json', lines=True)\n", (406, 432), True, 'import pandas as pd\n')] |
from AoCUtils import *
from intcode import *
from functools import partial
result = 0
partNumber = "2"
writeToLog = False
if writeToLog:
logFile = open("log" + partNumber + ".txt", "w")
else:
logFile = "stdout"
printLog = printLogFactory(logFile)
tape = readTape()
interpreter = Interpreter(tape)
def inpu... | [
"functools.partial"
] | [((526, 561), 'functools.partial', 'partial', (['inputCallback', 'interpreter'], {}), '(inputCallback, interpreter)\n', (533, 561), False, 'from functools import partial\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.6 on 2017-03-20 04:29
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('drf_fcm', '0003_auto_20170320_0421'),
]
operations = [
migrations.AlterFiel... | [
"django.db.models.CharField"
] | [((401, 469), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)', 'verbose_name': '"""GCM Registration id"""'}), "(max_length=255, verbose_name='GCM Registration id')\n", (417, 469), False, 'from django.db import migrations, models\n')] |
from flask import request, redirect, url_for, render_template, flash, g
from flask.ext.babel import lazy_gettext,gettext
from flask.ext.login import login_required
from app.utils import admin_required
from app.data.models.group import Group
from app.public.forms import EditGroupForm
from . import admin
@admin.route(... | [
"flask.render_template",
"flask.ext.babel.gettext",
"flask.url_for",
"app.data.models.group.Group.query.filter_by",
"app.data.DataTable",
"app.public.forms.EditGroupForm"
] | [((446, 611), 'app.data.DataTable', 'DataTable', ([], {'model': 'Group', 'columns': '[]', 'sortable': '[Group.nazev, Group.created_ts]', 'searchable': '[Group.nazev]', 'filterable': '[]', 'limits': '[25, 50, 100]', 'request': 'request'}), '(model=Group, columns=[], sortable=[Group.nazev, Group.created_ts],\n searcha... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.apps import AppConfig
from django.db.models.signals import pre_save
class SerializerConfig(AppConfig):
name = 'serializer'
def ready(self):
from serializer.models import Hero, Villain
from serializer.signals import up... | [
"django.db.models.signals.pre_save.connect"
] | [((366, 414), 'django.db.models.signals.pre_save.connect', 'pre_save.connect', (['update_hero_count'], {'sender': 'Hero'}), '(update_hero_count, sender=Hero)\n', (382, 414), False, 'from django.db.models.signals import pre_save\n'), ((423, 477), 'django.db.models.signals.pre_save.connect', 'pre_save.connect', (['update... |
#!/usr/bin/env python
'''
description: Configuration part of wrfpy
license: APACHE 2.0
author: <NAME>, NLeSC (<EMAIL>)
'''
import json
import os
from wrfpy import utils
import f90nml
import yaml
class config:
'''
description
'''
def __init__(self, wrfpy_config=False):
global logger
... | [
"wrfpy.utils.get_wrfpy_path",
"wrfpy.utils.check_file_exists",
"os.path.join",
"yaml.safe_load",
"os.path.isdir",
"f90nml.read",
"wrfpy.utils.return_validate",
"json.dump"
] | [((5144, 5197), 'os.path.isdir', 'os.path.isdir', (["self.config['filesystem']['wrfda_dir']"], {}), "(self.config['filesystem']['wrfda_dir'])\n", (5157, 5197), False, 'import os\n'), ((5781, 5832), 'os.path.isdir', 'os.path.isdir', (["self.config['filesystem']['upp_dir']"], {}), "(self.config['filesystem']['upp_dir'])\... |
# -----------------------------------------------------------------------------
# Copyright (c) <NAME> 2015, all rights reserved.
#
# Created: 2015-10-4
# Version: 0.1
# Purpose: Main Python3 code for running a wireless sensor network gateway node
# on a Raspberry Pi 2 with 4 cores
#
# TODO: Implementa... | [
"logging.basicConfig",
"logging.debug",
"argparse.ArgumentParser",
"pathlib.Path",
"datetime.datetime.utcnow",
"json.dump",
"logging.info",
"time.sleep",
"logging.INFO",
"mpi4py.MPI.Status",
"serial.Serial",
"guard.guard",
"numpy.frombuffer",
"xbee.ZigBee",
"worker.bee",
"numpy.set_pri... | [((911, 945), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'suppress': '(True)'}), '(suppress=True)\n', (930, 945), True, 'import numpy as np\n'), ((1728, 1740), 'mpi4py.MPI.Status', 'MPI.Status', ([], {}), '()\n', (1738, 1740), False, 'from mpi4py import MPI\n'), ((1862, 1887), 'argparse.ArgumentParser', 'ar... |
from django.contrib import admin
from .models import Game
class GameAdmin(admin.ModelAdmin):
list_display = ("round", "date", "players")
readonly_fields = ("cards",)
admin.site.register(Game, GameAdmin)
| [
"django.contrib.admin.site.register"
] | [((179, 215), 'django.contrib.admin.site.register', 'admin.site.register', (['Game', 'GameAdmin'], {}), '(Game, GameAdmin)\n', (198, 215), False, 'from django.contrib import admin\n')] |
# Generated by Django 3.0.4 on 2020-06-09 15:22
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('blog', '0003_auto_20200609_2049'),
]
operations = [
migrations.AddField(
model_name='comment',
name='commentimg',
... | [
"django.db.models.ImageField"
] | [((336, 423), 'django.db.models.ImageField', 'models.ImageField', ([], {'default': '""""""', 'upload_to': '"""comment_pics"""', 'verbose_name': '"""Post Image"""'}), "(default='', upload_to='comment_pics', verbose_name=\n 'Post Image')\n", (353, 423), False, 'from django.db import migrations, models\n')] |
from sigmoid import sigmoid
import numpy as np
def sigmoidGradient(z):
#SIGMOIDGRADIENT returns the gradient of the sigmoid function
#evaluated at z
# g = SIGMOIDGRADIENT(z) computes the gradient of the sigmoid function
# evaluated at z. This should work regardless if z is a matrix or a
# vector. In particular,... | [
"sigmoid.sigmoid",
"numpy.ones"
] | [((752, 762), 'sigmoid.sigmoid', 'sigmoid', (['z'], {}), '(z)\n', (759, 762), False, 'from sigmoid import sigmoid\n'), ((984, 994), 'sigmoid.sigmoid', 'sigmoid', (['z'], {}), '(z)\n', (991, 994), False, 'from sigmoid import sigmoid\n'), ((885, 895), 'sigmoid.sigmoid', 'sigmoid', (['z'], {}), '(z)\n', (892, 895), False,... |
class Gear(object):
def __init__(self, **kwargs):
try:
super().__init__()
self.name = kwargs["name"]; del kwargs["name"]
# self.concealability = kwargs["concealability"]; del kwargs["concealability"]
self.weight = kwargs["weight"]; del kwargs["weight"]
... | [
"json.load",
"pathlib.Path.cwd"
] | [((2748, 2768), 'json.load', 'json.load', (['json_file'], {}), '(json_file)\n', (2757, 2768), False, 'import json\n'), ((2628, 2646), 'pathlib.Path.cwd', 'pathlib.Path.cwd', ([], {}), '()\n', (2644, 2646), False, 'import pathlib\n')] |
from time import sleep
from tqdm import tqdm, trange
import time
from tqdm.auto import tqdm, trange
def test_tqdm():
for i in tqdm(range(10)):
# ้่ฆๅพช็ฏๆ่
ๅคๆฌกๆง่ก็ไปฃ็
print('\n the value of i is %d ---'%i) # ๆญฃๅธธ็ๆดๆฐๅผ๏ผi
print(range(i))
sleep(0.1)
# test_tqdm()
# tqdmๆพ็คบ่ฟๅบฆๆก่งฃ้๏ผๆณจๆๅๆฐไธไธๅฎ่ฆๆฏๆฐๅญ๏ผๅฏ่ฟญไปฃๅฏน... | [
"tqdm.auto.trange",
"time.sleep",
"tqdm.auto.tqdm"
] | [((506, 517), 'tqdm.auto.tqdm', 'tqdm', (['list_'], {}), '(list_)\n', (510, 517), False, 'from tqdm.auto import tqdm, trange\n'), ((790, 828), 'tqdm.auto.tqdm', 'tqdm', (['list_'], {'desc': '"""---"""', 'postfix': '"""***"""'}), "(list_, desc='---', postfix='***')\n", (794, 828), False, 'from tqdm.auto import tqdm, tra... |
# Copyright (c) 2020 The Khronos Group Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed ... | [
"os.path.exists",
"tarfile.open",
"os.listdir",
"os.makedirs",
"os.path.dirname"
] | [((701, 727), 'os.path.dirname', 'os.path.dirname', (['file_path'], {}), '(file_path)\n', (716, 727), False, 'import os\n'), ((802, 831), 'os.makedirs', 'os.makedirs', (['target_directory'], {}), '(target_directory)\n', (813, 831), False, 'import os\n'), ((842, 906), 'tarfile.open', 'tarfile.open', (['file_path', '"""w... |
from Classes.Logic.LogicLong import LogicLong
from Classes.Wrappers.PlayerDisplayData import PlayerDisplayData
class PlayerProfile:
def encode(calling_instance, fields, playerData):
calling_instance.encodeLogicLong(LogicLong(fields["PlayerID"][0], fields["PlayerID"][1]))
calling_instance.writeDataR... | [
"Classes.Logic.LogicLong.LogicLong",
"Classes.Wrappers.PlayerDisplayData.PlayerDisplayData.encode"
] | [((2533, 2587), 'Classes.Wrappers.PlayerDisplayData.PlayerDisplayData.encode', 'PlayerDisplayData.encode', (['calling_instance', 'playerData'], {}), '(calling_instance, playerData)\n', (2557, 2587), False, 'from Classes.Wrappers.PlayerDisplayData import PlayerDisplayData\n'), ((228, 283), 'Classes.Logic.LogicLong.Logic... |
import boto3
from os import walk
from datetime import datetime
client = boto3.client('s3')
# Create s3 bucket
now = datetime.now()
date_time = now.strftime("%m-%d-medium-datasets")
response = client.create_bucket(
Bucket=date_time
)
print(response)
#
s3 = boto3.resource('s3')
# Upload files to bucket
mypath =... | [
"datetime.datetime.now",
"boto3.resource",
"boto3.client",
"os.walk"
] | [((74, 92), 'boto3.client', 'boto3.client', (['"""s3"""'], {}), "('s3')\n", (86, 92), False, 'import boto3\n'), ((119, 133), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (131, 133), False, 'from datetime import datetime\n'), ((266, 286), 'boto3.resource', 'boto3.resource', (['"""s3"""'], {}), "('s3')\n", ... |
from minsait.ttaa.datio.common.naming.Field import Field
personal_id = Field("personal_id")
education_level_desc = Field("education_level_desc")
data_date = Field("data_date")
| [
"minsait.ttaa.datio.common.naming.Field.Field"
] | [((72, 92), 'minsait.ttaa.datio.common.naming.Field.Field', 'Field', (['"""personal_id"""'], {}), "('personal_id')\n", (77, 92), False, 'from minsait.ttaa.datio.common.naming.Field import Field\n'), ((116, 145), 'minsait.ttaa.datio.common.naming.Field.Field', 'Field', (['"""education_level_desc"""'], {}), "('education_... |
from pathlib import Path
from zipfile import ZipFile
import requests
class Client:
def __init__(self, url):
if url[-1] != '/':
url = url + '/'
self.base_url = url
def get_json(self, get, params={}):
params['format'] = 'json'
url = self.base_url + get
... | [
"zipfile.ZipFile",
"requests.get",
"pathlib.Path"
] | [((598, 614), 'pathlib.Path', 'Path', (['local_path'], {}), '(local_path)\n', (602, 614), False, 'from pathlib import Path\n'), ((743, 788), 'requests.get', 'requests.get', (['url'], {'params': 'params', 'stream': '(True)'}), '(url, params=params, stream=True)\n', (755, 788), False, 'import requests\n'), ((329, 361), '... |
from django.utils.translation import gettext_lazy as _
from ...utils.settings import get_setting
from ..admin import AdminMixinsMixin
from ..sections import FieldsetList, Sections
__all__ = [
"DefaultAdminMixin"
]
class DefaultAdminMixin(AdminMixinsMixin):
def get_section(self) -> Sections:
return S... | [
"django.utils.translation.gettext_lazy"
] | [((939, 988), 'django.utils.translation.gettext_lazy', '_', (['"""Advanced settings. Change them with caution!"""'], {}), "('Advanced settings. Change them with caution!')\n", (940, 988), True, 'from django.utils.translation import gettext_lazy as _\n'), ((1269, 1319), 'django.utils.translation.gettext_lazy', '_', (['"... |
# Author: <NAME>
# Version: 01/11/2022
#
# This file contains 4 programs: create, write to, append to, and delete a File
# Also demostrated is file handing in other directories
# To properly use this file, please comment out sections as needed
# create a file program
open("write_to_me/whoohoo.txt", "x")
#write to ... | [
"os.remove"
] | [((680, 716), 'os.remove', 'os.remove', (['"""write_to_me/whoohoo.txt"""'], {}), "('write_to_me/whoohoo.txt')\n", (689, 716), False, 'import os\n')] |
# Author: <NAME>, Fall 2018
# Author worked as a one-person team and wrote all code within here.
# 'OCRB' is the font for the mine and time counters.
# Code here is mostly untounced, but lightly refactored for readability. Comments also made to indicate future changes and review the code. They begin with "###". <-... | [
"sys.setrecursionlimit",
"tkinter.Entry",
"tkinter.Button",
"tkinter.Tk",
"tkinter.Label",
"tkinter.Frame"
] | [((15870, 15877), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (15875, 15877), True, 'import tkinter as tk\n'), ((16117, 16147), 'tkinter.Frame', 'tk.Frame', (['App'], {'relief': '"""groove"""'}), "(App, relief='groove')\n", (16125, 16147), True, 'import tkinter as tk\n'), ((16315, 16402), 'tkinter.Button', 'tk.Button', ([... |
from etherscan.blocks import Blocks
import json
with open('../../api_key.json', mode='r') as key_file:
key = json.loads(key_file.read())['key']
api = Blocks(api_key=key)
reward = api.get_block_reward(2165403)
print(reward)
| [
"etherscan.blocks.Blocks"
] | [((156, 175), 'etherscan.blocks.Blocks', 'Blocks', ([], {'api_key': 'key'}), '(api_key=key)\n', (162, 175), False, 'from etherscan.blocks import Blocks\n')] |
# -*- coding: utf-8 -*-
import dateparser
import scrapy.loader
from rannts_crawler import items
from . import base
class MeetupsSpider(base.Spider):
name = "meetups"
start_urls = [
"https://rannts.ru/meetups"
]
def parse(self, response):
for result in self.follow_urls(
... | [
"rannts_crawler.items.TalksItem",
"rannts_crawler.items.MeetupsItem",
"dateparser.parse"
] | [((2872, 2894), 'dateparser.parse', 'dateparser.parse', (['time'], {}), '(time)\n', (2888, 2894), False, 'import dateparser\n'), ((681, 700), 'rannts_crawler.items.MeetupsItem', 'items.MeetupsItem', ([], {}), '()\n', (698, 700), False, 'from rannts_crawler import items\n'), ((1592, 1609), 'rannts_crawler.items.TalksIte... |
from CPP_MetaMachineDefinition import *
from CodeGen import *
import re
class MachinePropertyFileWriter:
includes_static = ['#include <memory>', '#include <string>', '#include <sstream>',
'#include "CLMetaProperty.h"', '#include "CLBoundProperty.h"']
primTypes_static = ['unsigned int',... | [
"re.sub"
] | [((5138, 5179), 're.sub', 're.sub', (['"""const|[*+& ]"""', '""""""', 'prop.dataType'], {}), "('const|[*+& ]', '', prop.dataType)\n", (5144, 5179), False, 'import re\n'), ((6300, 6341), 're.sub', 're.sub', (['"""const|[*+& ]"""', '""""""', 'prop.dataType'], {}), "('const|[*+& ]', '', prop.dataType)\n", (6306, 6341), Fa... |
import z3
from real import *
import sys
def degree(poly):
for i in range(len(poly) - 1, -1, -1):
if poly[i] != 0:
return i
return 0
def match(a, b):
if len(a) < len(b):
return match(b, a)
for i in range(len(a) - len(b)):
b.append(0)
return len(a)
def poly_add(a, b):
n = match(a, b)
c ... | [
"z3.Real",
"sys.stdin.read"
] | [((982, 994), 'z3.Real', 'z3.Real', (['"""x"""'], {}), "('x')\n", (989, 994), False, 'import z3\n'), ((2155, 2171), 'sys.stdin.read', 'sys.stdin.read', ([], {}), '()\n', (2169, 2171), False, 'import sys\n')] |
from t2i.visualizer import *
from t2i.highlightBoxNLP import *
from flask import Flask
from flask_cors import CORS, cross_origin
from flask import request
from flask import make_response
from flask import jsonify
from flask import send_file
import sys
app = Flask("text2illustrate")
CORS(app, resources=r'/api/*')
# th... | [
"flask.jsonify",
"flask_cors.CORS",
"flask.Flask"
] | [((259, 283), 'flask.Flask', 'Flask', (['"""text2illustrate"""'], {}), "('text2illustrate')\n", (264, 283), False, 'from flask import Flask\n'), ((284, 313), 'flask_cors.CORS', 'CORS', (['app'], {'resources': '"""/api/*"""'}), "(app, resources='/api/*')\n", (288, 313), False, 'from flask_cors import CORS, cross_origin\... |
#!/usr/bin/python
from __future__ import division
import json
import math
import cPickle as pickle
from collections import Counter
import unicodedata
import sys
#output_filename = 'republicans.pickle'
output_filename = 'democrats.pickle'
#input_filename = './data/theblaze.json'
input_filename = './data/thedailybeast... | [
"collections.Counter",
"json.loads",
"math.log"
] | [((740, 754), 'collections.Counter', 'Counter', (['words'], {}), '(words)\n', (747, 754), False, 'from collections import Counter\n'), ((608, 624), 'json.loads', 'json.loads', (['line'], {}), '(line)\n', (618, 624), False, 'import json\n'), ((818, 847), 'math.log', 'math.log', (['(words[word] / total)'], {}), '(words[w... |
from marshmallow import Schema, fields
class HealthCheckSchema(Schema):
name = fields.String()
status = fields.String(attribute="status.name")
node = fields.String()
seconds_ago = fields.Integer()
timestamp = fields.Integer()
info = fields.String()
| [
"marshmallow.fields.Integer",
"marshmallow.fields.String"
] | [((85, 100), 'marshmallow.fields.String', 'fields.String', ([], {}), '()\n', (98, 100), False, 'from marshmallow import Schema, fields\n'), ((114, 152), 'marshmallow.fields.String', 'fields.String', ([], {'attribute': '"""status.name"""'}), "(attribute='status.name')\n", (127, 152), False, 'from marshmallow import Sche... |
import numpy as np
import mapping
# Ohmic spectral density parameters:
alpha = 1
s = 1
omega_c = 1
nof_coefficients = 5
# Discretization and chain mapping type:
disc_type = 'gk_quad'
mapping_type = 'lan_bath'
# Discretization accuracy parameter:
ncap = 1000000
# Domain of the spectral density. Must choose manual ... | [
"numpy.abs",
"numpy.exp",
"mapping.chain.get",
"mapping.convert_star_to_chain_lan",
"mapping.convert_chain_to_star"
] | [((472, 603), 'mapping.chain.get', 'mapping.chain.get', (['J', 'domain', 'nof_coefficients'], {'ncap': 'ncap', 'disc_type': 'disc_type', 'mapping_type': 'mapping_type', 'interval_type': '"""lin"""'}), "(J, domain, nof_coefficients, ncap=ncap, disc_type=\n disc_type, mapping_type=mapping_type, interval_type='lin')\n"... |
from enum import Enum, auto
class MCFragment:
def __init__(self):
self.section = None
class MCDataFragment(MCFragment):
def __init__(self):
super().__init__()
self.contents = bytearray()
self.fixups = []
class MCRelaxableFragment(MCFragment):
def __init__(self, inst):
... | [
"enum.auto"
] | [((1006, 1012), 'enum.auto', 'auto', ([], {}), '()\n', (1010, 1012), False, 'from enum import Enum, auto\n'), ((1026, 1032), 'enum.auto', 'auto', ([], {}), '()\n', (1030, 1032), False, 'from enum import Enum, auto\n'), ((1048, 1054), 'enum.auto', 'auto', ([], {}), '()\n', (1052, 1054), False, 'from enum import Enum, au... |
import itertools
import threading
from traceback import FrameSummary
from typing import Callable, Any, Optional, List
from rx.disposable import CompositeDisposable
from rxbp.acknowledgement.acksubject import AckSubject
from rxbp.acknowledgement.ack import Ack
from rxbp.acknowledgement.continueack import continue_ack
... | [
"itertools.chain",
"rxbp.utils.tooperatorexception.to_operator_exception",
"rxbp.states.rawstates.rawterminationstates.RawTerminationStates.LeftCompletedState",
"rxbp.states.rawstates.rawzipstates.RawZipStates.WaitOnLeft",
"rxbp.states.rawstates.rawzipstates.RawZipStates.ElementReceived",
"threading.RLock... | [((2205, 2222), 'threading.RLock', 'threading.RLock', ([], {}), '()\n', (2220, 2222), False, 'import threading\n'), ((2338, 2370), 'rxbp.states.rawstates.rawterminationstates.RawTerminationStates.InitState', 'RawTerminationStates.InitState', ([], {}), '()\n', (2368, 2370), False, 'from rxbp.states.rawstates.rawterminat... |
import pytest
from pgel_sat import gel
@pytest.fixture
def concept_with_arrows():
concept_a = gel.Concept('a')
concept_b = gel.Concept('b')
role = gel.Role('r')
arrow1 = gel.Arrow(concept_b, role)
concept_a.add_arrow(arrow1)
concept_c = gel.Concept('c')
arrow2 = gel.Arrow(concept_c, role)... | [
"pgel_sat.gel.Role",
"pgel_sat.gel.Concept",
"pgel_sat.gel.Arrow"
] | [((100, 116), 'pgel_sat.gel.Concept', 'gel.Concept', (['"""a"""'], {}), "('a')\n", (111, 116), False, 'from pgel_sat import gel\n'), ((133, 149), 'pgel_sat.gel.Concept', 'gel.Concept', (['"""b"""'], {}), "('b')\n", (144, 149), False, 'from pgel_sat import gel\n'), ((161, 174), 'pgel_sat.gel.Role', 'gel.Role', (['"""r""... |
import pandas as pd
from sklearn import linear_model
import os
from EnergyIntensityIndicators.pull_eia_api import GetEIAData
from EnergyIntensityIndicators.pull_bea_api import BEA_api
from EnergyIntensityIndicators.LMDI import CalculateLMDI
from EnergyIntensityIndicators.get_census_data import Asm
from EnergyIntensit... | [
"EnergyIntensityIndicators.pull_eia_api.GetEIAData",
"EnergyIntensityIndicators.Industry.manufacturing.Manufacturing",
"EnergyIntensityIndicators.Industry.nonmanufacuturing.NonManufacturing",
"os.getcwd"
] | [((3457, 3479), 'EnergyIntensityIndicators.pull_eia_api.GetEIAData', 'GetEIAData', (['"""industry"""'], {}), "('industry')\n", (3467, 3479), False, 'from EnergyIntensityIndicators.pull_eia_api import GetEIAData\n'), ((7530, 7541), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (7539, 7541), False, 'import os\n'), ((5264, ... |
import os
import threading
import Menu_Page_Router
from GPIO_Init import checkKeyInterrupt
from OP_1_Connection import autoMountUnmontThread
from file_util import createImportantFolders
__author__ = "<NAME> (<NAME>)"
__date__ = "2019-04-02"
workDir = os.path.dirname(os.path.realpath(__file__))
def start():
# c... | [
"file_util.createImportantFolders",
"os.path.realpath",
"threading.Thread",
"Menu_Page_Router.PageRouter",
"GPIO_Init.checkKeyInterrupt"
] | [((270, 296), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (286, 296), False, 'import os\n'), ((356, 380), 'file_util.createImportantFolders', 'createImportantFolders', ([], {}), '()\n', (378, 380), False, 'from file_util import createImportantFolders\n'), ((500, 529), 'Menu_Page_Router.P... |
import unittest
import json
from api import db
from api.models.models import Meal, User
from tests.main import MainTestCase
sample_admin = {'username': 'victorvenosa',
'email': '<EMAIL>',
'designation': 'caterer',
'password': '<PASSWORD>',
'confirm_passwo... | [
"unittest.main",
"json.dumps"
] | [((9488, 9503), 'unittest.main', 'unittest.main', ([], {}), '()\n', (9501, 9503), False, 'import unittest\n'), ((664, 688), 'json.dumps', 'json.dumps', (['sample_admin'], {}), '(sample_admin)\n', (674, 688), False, 'import json\n'), ((868, 929), 'json.dumps', 'json.dumps', (["{'title': 'Beef with chapati', 'price': '60... |
import torch
from fairseq.data import Dictionary
dictionary = Dictionary.load('data-bin/java-huge-bpe-2000-half/dict.txt')
bpe_cont = '@@'
bpe_toks = {
i
for i in range(len(dictionary))
if dictionary[i].endswith(bpe_cont)
}
saved_prediction = torch.load('prediction.pt', map_location=torch.device('cpu'))
... | [
"fairseq.data.Dictionary.load",
"torch.device"
] | [((63, 123), 'fairseq.data.Dictionary.load', 'Dictionary.load', (['"""data-bin/java-huge-bpe-2000-half/dict.txt"""'], {}), "('data-bin/java-huge-bpe-2000-half/dict.txt')\n", (78, 123), False, 'from fairseq.data import Dictionary\n'), ((298, 317), 'torch.device', 'torch.device', (['"""cpu"""'], {}), "('cpu')\n", (310, 3... |
"""
Includes Dijkstra's algorithm and two A* implementations.
"""
from __future__ import print_function,division
import heapq #for a fast priority queue implementation
def predecessor_traverse(p,s,g):
"""Used by dijkstra's algorithm to traverse a predecessor dictionary"""
L = []
v = g
while v is not... | [
"heapq.heappop",
"heapq.heappush",
"heapq.heapify"
] | [((1750, 1766), 'heapq.heappop', 'heapq.heappop', (['Q'], {}), '(Q)\n', (1763, 1766), False, 'import heapq\n'), ((4084, 4100), 'heapq.heappop', 'heapq.heappop', (['Q'], {}), '(Q)\n', (4097, 4100), False, 'import heapq\n'), ((6523, 6539), 'heapq.heappop', 'heapq.heappop', (['Q'], {}), '(Q)\n', (6536, 6539), False, 'impo... |
from dataset import Dataset
from util import Util
class Feature:
def __init__(self, use_features):
self.dataset = Dataset(use_features)
years = [y for y in range(2008, 2020)]
self.data = self.dataset.get_data(years, "tokyo")
def get_dataset(self):
return self.data.c... | [
"dataset.Dataset",
"util.Util.dump_feature"
] | [((134, 155), 'dataset.Dataset', 'Dataset', (['use_features'], {}), '(use_features)\n', (141, 155), False, 'from dataset import Dataset\n'), ((393, 433), 'util.Util.dump_feature', 'Util.dump_feature', (['feature', 'feature_name'], {}), '(feature, feature_name)\n', (410, 433), False, 'from util import Util\n')] |
import json_lines
import os
import re
# a list of lists
groundtruth = {}
prefix = 'http://www.isi.edu/gaia/entities/'
def has_gt(repo, graph):
gtid = repo
if graph:
gtid = gtid + repo + '-' + re.sub('[^0-9a-zA-Z]+', '-', graph)
file = 'gt/' + gtid + 'jl'
return os.path.isfile(file)
# return... | [
"os.path.isfile",
"re.sub",
"json_lines.reader"
] | [((289, 309), 'os.path.isfile', 'os.path.isfile', (['file'], {}), '(file)\n', (303, 309), False, 'import os\n'), ((211, 246), 're.sub', 're.sub', (['"""[^0-9a-zA-Z]+"""', '"""-"""', 'graph'], {}), "('[^0-9a-zA-Z]+', '-', graph)\n", (217, 246), False, 'import re\n'), ((468, 503), 're.sub', 're.sub', (['"""[^0-9a-zA-Z]+"... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Created by <EMAIL> at 2014-04-19
import os
import sys
import tempfile
import shutil
from BeautifulSoup import BeautifulStoneSoup
from rex import rex
from urlparse import urlparse
from argparse import ArgumentParser
from lib.http import download
from lib.progress import P... | [
"lib.progress.ProgressBar",
"argparse.ArgumentParser",
"lib.http.download",
"os.path.join",
"rex.rex",
"tempfile.gettempdir",
"lib.track.Track",
"os.path.expanduser",
"urlparse.urlparse"
] | [((391, 404), 'urlparse.urlparse', 'urlparse', (['url'], {}), '(url)\n', (399, 404), False, 'from urlparse import urlparse\n'), ((995, 1012), 'lib.http.download', 'download', (['xml_url'], {}), '(xml_url)\n', (1003, 1012), False, 'from lib.http import download\n'), ((1122, 1264), 'argparse.ArgumentParser', 'ArgumentPar... |
import os
from flask_restful import abort
UPLOAD_PREFIX = 'App/static/'
UPLOAD_DIR = 'uploads/'
def file_save(form):
# ่ทๅๆณจๅ็ๅพ็ๅฏน่ฑก
f_in = form.pic.data
# ่ทๅ่ฏฅๅฏน่ฑก็ๆไปถๅ
fname = f_in.filename
# ็ป่ฏฅๆไปถๅ
่ฃ
ๅฐไธไธชๅ
้
pic = os.path.join(UPLOAD_DIR,fname)
# ๆผๆฅ่ฏฅๆไปถ็็ปๅฏน่ทฏๅพ
file_path = os.path.join(U... | [
"os.path.exists",
"os.makedirs",
"os.path.join",
"os.path.dirname",
"flask_restful.abort"
] | [((240, 271), 'os.path.join', 'os.path.join', (['UPLOAD_DIR', 'fname'], {}), '(UPLOAD_DIR, fname)\n', (252, 271), False, 'import os\n'), ((306, 338), 'os.path.join', 'os.path.join', (['UPLOAD_PREFIX', 'pic'], {}), '(UPLOAD_PREFIX, pic)\n', (318, 338), False, 'import os\n'), ((367, 393), 'os.path.dirname', 'os.path.dirn... |
#!/usr/bin/env python3
# run: "python cveta.py" or "python3 cveta.py"
#
# requires:
# python3 --> python --version to check or use python3 if have both
# urllib for py3 -->pip3 install urllib
# beautifulsoup for py 3 -> sudo pip3 install --upgrade beautifulsoup4
#
# TO DO :analize pkg: option to enter a pckg name, outp... | [
"bs4.BeautifulSoup",
"requests.get",
"apt.Cache",
"argparse.ArgumentParser"
] | [((922, 947), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (945, 947), False, 'import argparse\n'), ((1440, 1451), 'apt.Cache', 'apt.Cache', ([], {}), '()\n', (1449, 1451), False, 'import apt\n'), ((2848, 2881), 'bs4.BeautifulSoup', 'BeautifulSoup', (['msg', '"""html.parser"""'], {}), "(msg, ... |
from django.shortcuts import render, redirect
from django.contrib import messages
from django.http import Http404
from .models import Image, Profile, Ratings
from .forms import NewPostForm
from django.contrib.auth.decorators import login_required
from rest_framework.response import Response
from rest_framework.views im... | [
"django.shortcuts.render",
"django.db.models.Avg",
"rest_framework.response.Response",
"django.shortcuts.redirect",
"django.contrib.messages.success"
] | [((725, 772), 'django.shortcuts.render', 'render', (['request', '"""wowawards/base.html"""', 'context'], {}), "(request, 'wowawards/base.html', context)\n", (731, 772), False, 'from django.shortcuts import render, redirect\n'), ((1058, 1105), 'django.shortcuts.render', 'render', (['request', '"""wowawards/base.html"""'... |
from Jumpscale import j
import psycopg2
from .PostgresqlClient import PostgresClient
# import calendar
# from htmllib import HTMLParser
# from formatter import AbstractFormatter, DumbWriter
# from io import StringIO
# import lib.html
JSConfigs = j.application.JSBaseConfigsClass
class PostgresqlFactory(JSConfigs):
... | [
"psycopg2.connect",
"Jumpscale.j.sal.process.execute",
"Jumpscale.j.builders.db.postgres.start",
"Jumpscale.j.clients.postgres.new",
"Jumpscale.j.exceptions.RuntimeError",
"Jumpscale.j.builders.db.postgres.stop"
] | [((1121, 1245), 'psycopg2.connect', 'psycopg2.connect', (['("dbname=\'%s\' user=\'%s\' host=\'%s\' password=\'%s\' port=\'%s\'" % (\'template1\',\n login, ipaddr, passwd, port))'], {}), '("dbname=\'%s\' user=\'%s\' host=\'%s\' password=\'%s\' port=\'%s\'" %\n (\'template1\', login, ipaddr, passwd, port))\n', (113... |
"""
Slack chat bot for secret santa
"""
from functools import lru_cache
from operator import attrgetter
from math import ceil
import tabulate
from jinja2 import Environment, FileSystemLoader, select_autoescape
from sqlalchemy import Table, Column, Integer, String, Boolean, DateTime, \
Sequence, ForeignKey
from... | [
"operator.attrgetter",
"tabulate.tabulate",
"database.db_session.commit",
"secretsanta.Person",
"jinja2.select_autoescape",
"database.db_session.add",
"jinja2.FileSystemLoader",
"secretsanta.SecretSanta"
] | [((532, 563), 'jinja2.FileSystemLoader', 'FileSystemLoader', (['"""./templates"""'], {}), "('./templates')\n", (548, 563), False, 'from jinja2 import Environment, FileSystemLoader, select_autoescape\n'), ((576, 603), 'jinja2.select_autoescape', 'select_autoescape', (["['html']"], {}), "(['html'])\n", (593, 603), False,... |
import os.path
from setuptools import setup
here = os.path.dirname(os.path.abspath(__file__))
with open(os.path.join(here, 'README.md')) as f:
long_description = f.read()
setup(
name='redbucket',
use_scm_version=True,
license="MIT License",
description="Python rate limiting library using Redis fo... | [
"setuptools.setup"
] | [((178, 1132), 'setuptools.setup', 'setup', ([], {'name': '"""redbucket"""', 'use_scm_version': '(True)', 'license': '"""MIT License"""', 'description': '"""Python rate limiting library using Redis for shared state."""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/nickgaya/r... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
InMemoryHandler: handler that's collects the data in memory
'''
import logging
logger = logging.getLogger(__name__)
from .base_handler import BaseHandler
class InMemoryHandler(BaseHandler):
'''
inmemory_handler_config = {
"name": "InMemoryHandler",
"args": {}
... | [
"logging.getLogger"
] | [((140, 167), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (157, 167), False, 'import logging\n')] |
import cv2 as cv
import numpy as np
import numpy as np
import math
import imutils
import os
beta = 0.75
class BodyPart():
def __init__(self, name='part'):
self.name = name
self.x = 0
self.y = 0
self.theta = 0
self.l = 0
self.w = 0
self.children = []
self.parent = None
... | [
"cv2.rectangle",
"numpy.sqrt",
"numpy.count_nonzero",
"numpy.array",
"cv2.CascadeClassifier",
"os.path.exists",
"os.listdir",
"numpy.where",
"cv2.line",
"numpy.exp",
"cv2.distanceTransform",
"numpy.arctan",
"numpy.random.normal",
"cv2.fillPoly",
"numpy.amax",
"cv2.polylines",
"numpy.... | [((2234, 2263), 'cv2.absdiff', 'cv.absdiff', (['frame', 'background'], {}), '(frame, background)\n', (2244, 2263), True, 'import cv2 as cv\n'), ((2797, 2843), 'cv2.distanceTransform', 'cv.distanceTransform', (['foreImage', 'cv.DIST_L2', '(5)'], {}), '(foreImage, cv.DIST_L2, 5)\n', (2817, 2843), True, 'import cv2 as cv\... |
from flask_table import Table, Col, LinkCol
from flask import Flask, Markup, request, url_for
import pandas as pd
import numpy as np
import plotly.express as px
import plotly.io as pio
app = Flask(__name__)
class SortableTable(Table):
id = Col('ID')
name = Col('Country Name')
continent = Col('Continent')... | [
"flask.request.args.get",
"flask.Flask",
"flask.url_for",
"flask_table.Col",
"plotly.express.data.gapminder"
] | [((192, 207), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (197, 207), False, 'from flask import Flask, Markup, request, url_for\n'), ((247, 256), 'flask_table.Col', 'Col', (['"""ID"""'], {}), "('ID')\n", (250, 256), False, 'from flask_table import Table, Col, LinkCol\n'), ((268, 287), 'flask_table.Col',... |
import json
import os
from django.conf import settings
from django.core.management import call_command
from django.db.models import base
from django.test import TestCase
from wagtail_wordpress_importer.management.commands import (
import_atlas_case_studies, import_blogs, import_categories,
import_documents, im... | [
"wagtail_wordpress_importer.management.commands.import_posts.Command",
"wagtail_wordpress_importer.management.commands.import_media.Command",
"wagtail_wordpress_importer.models.classification.ImportPublicationType.objects.count",
"wagtail_wordpress_importer.management.commands.import_documents.Command",
"wa... | [((1065, 1135), 'os.path.join', 'os.path.join', (['settings.BASE_DIR', '"""wagtail_wordpress_importer/fixtures"""'], {}), "(settings.BASE_DIR, 'wagtail_wordpress_importer/fixtures')\n", (1077, 1135), False, 'import os\n'), ((1231, 1259), 'django.core.management.call_command', 'call_command', (['"""get_fixtures"""'], {}... |
from django import forms
class TodoForm(forms.Form):
text = forms.CharField(
max_length=100,
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Enter Todo',
'aria-label': 'Todo',
'aria-describedby': 'add-btn'
})
) | [
"django.forms.TextInput"
] | [((121, 255), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'class': 'form-control', 'placeholder': 'Enter Todo', 'aria-label': 'Todo',\n 'aria-describedby': 'add-btn'}"}), "(attrs={'class': 'form-control', 'placeholder': 'Enter Todo',\n 'aria-label': 'Todo', 'aria-describedby': 'add-btn'})\n", (1... |
"""
Create charts for simulation CSVs
"""
import pathlib
import json
from libs.nodesreader import NodesReader
from libs.utils import ip2class
STATS = {"Simulation": "nodes.1",
"Total": 0,
"Classes": {
"127": 0,
"63": 0,
"31": 0,
"15": 0,
... | [
"libs.nodesreader.NodesReader",
"json.load",
"libs.utils.ip2class",
"json.dump"
] | [((385, 413), 'libs.nodesreader.NodesReader', 'NodesReader', (['"""NODES/nodes.1"""'], {}), "('NODES/nodes.1')\n", (396, 413), False, 'from libs.nodesreader import NodesReader\n'), ((928, 948), 'json.dump', 'json.dump', (['STATS', 'fp'], {}), '(STATS, fp)\n', (937, 948), False, 'import json\n'), ((1055, 1068), 'json.lo... |
from os import listdir,system
from time import time,sleep
from aj_progressB import Bar
class Procesar_Similares():
def __init__(self,files):
self.files=files
def buscar(self,percent_match,reprocesar=False):
if self.files:
cont = 0
files=list(map(lambda x:[x,True],self... | [
"os.system",
"os.listdir",
"time.time",
"time.sleep"
] | [((2998, 3004), 'time.time', 'time', ([], {}), '()\n', (3002, 3004), False, 'from time import time, sleep\n'), ((3059, 3068), 'os.listdir', 'listdir', ([], {}), '()\n', (3066, 3068), False, 'from os import listdir, system\n'), ((3207, 3229), 'os.listdir', 'listdir', (['"""Organizados"""'], {}), "('Organizados')\n", (32... |
"""Content views."""
# Django
from django.contrib.auth.mixins import LoginRequiredMixin
from django.shortcuts import redirect
from django.views.generic import DetailView, TemplateView
from django.urls import reverse_lazy
from django.conf import settings
from django.utils import timezone
from django.contrib.auth impor... | [
"django.shortcuts.render",
"jwt.decode",
"twilio.rest.Client",
"django.contrib.auth.login",
"django.utils.timezone.now",
"hacku.contents.models.Content.objects.all",
"datetime.timedelta",
"jwt.encode"
] | [((954, 1013), 'jwt.encode', 'jwt.encode', (['payload', 'settings.SECRET_KEY'], {'algorithm': '"""HS256"""'}), "(payload, settings.SECRET_KEY, algorithm='HS256')\n", (964, 1013), False, 'import jwt\n'), ((1244, 1265), 'hacku.contents.models.Content.objects.all', 'Content.objects.all', ([], {}), '()\n', (1263, 1265), Fa... |
import os.path as osp
import pandas as pd
from .bases import BaseImageDataset
class GroceriesDataset(BaseImageDataset):
dataset_dir = 'groceries_dataset'
def __init__(self, root, verbose=True, **kwargs):
super(GroceriesDataset, self).__init__()
self.dataset_dir = osp.join(root, self.dataset_... | [
"os.path.exists",
"os.path.join"
] | [((292, 324), 'os.path.join', 'osp.join', (['root', 'self.dataset_dir'], {}), '(root, self.dataset_dir)\n', (300, 324), True, 'import os.path as osp\n'), ((350, 385), 'os.path.join', 'osp.join', (['self.dataset_dir', '"""train"""'], {}), "(self.dataset_dir, 'train')\n", (358, 385), True, 'import os.path as osp\n'), ((4... |
#! /usr/bin/env python
import os
import pdb
import time
import yaml
import json
import random
import shutil
import argparse
import numpy as np
from collections import defaultdict
# torch
import torch
import torch.nn as nn
import torch.nn.functional as F
from utils import AverageMeter
from solvers import Solver
__all... | [
"numpy.mean",
"numpy.reshape",
"torch.nn.functional.cosine_similarity",
"os.path.join",
"torch.from_numpy",
"numpy.diag",
"numpy.isin",
"numpy.array",
"numpy.sum",
"torch.sum",
"numpy.concatenate",
"torch.nn.functional.relu",
"utils.AverageMeter",
"numpy.cumsum",
"time.time",
"numpy.ro... | [((611, 623), 'torch.nn.functional.relu', 'F.relu', (['dist'], {}), '(dist)\n', (617, 623), True, 'import torch.nn.functional as F\n'), ((750, 802), 'torch.nn.functional.cosine_similarity', 'F.cosine_similarity', (['x[:, None, :]', 'y[None, :, :]', '(2)'], {}), '(x[:, None, :], y[None, :, :], 2)\n', (769, 802), True, '... |
import torch
import os
import datetime
import pickle
import dill
import random
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import pandas as pd
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch import optim
from random import choices
from scipy.stats import e... | [
"torch.LongTensor",
"numpy.array",
"Networks.DecoderSumCover",
"pandas.read_pickle",
"Parameters.Params",
"os.path.exists",
"numpy.where",
"Networks.DecoderGRUCover",
"Evaluation.EvaluationUtil",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"Networks.Encoder",
"numpy.isnan",
"os.makedirs",
... | [((616, 624), 'Parameters.Params', 'Params', ([], {}), '()\n', (622, 624), False, 'from Parameters import Params\n'), ((1360, 1376), 'Evaluation.EvaluationUtil', 'EvaluationUtil', ([], {}), '()\n', (1374, 1376), False, 'from Evaluation import EvaluationUtil\n'), ((1578, 1614), 'numpy.zeros', 'np.zeros', (['(1, self.med... |
from __future__ import annotations
from typing import Iterator, TYPE_CHECKING
from mechanics.util.die import roll2Die
if TYPE_CHECKING:
from mechanics.playerManager import PlayerManager
from mechanics.player import Player
from mechanics.gameMap.gameMap import GameMap
class Game:
'''
Represents ... | [
"mechanics.util.die.roll2Die"
] | [((1996, 2006), 'mechanics.util.die.roll2Die', 'roll2Die', ([], {}), '()\n', (2004, 2006), False, 'from mechanics.util.die import roll2Die\n')] |
#!/usr/bin/env python
import os
import sys
pwd = os.path.dirname(__file__)
sys.path.insert(0, os.path.abspath(os.path.join(pwd, 'server')))
if __name__ == "__main__":
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "todomvc.settings")
from django.core.management import execute_from_command_line
execute_... | [
"os.environ.setdefault",
"os.path.dirname",
"os.path.join",
"django.core.management.execute_from_command_line"
] | [((50, 75), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (65, 75), False, 'import os\n'), ((173, 240), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""todomvc.settings"""'], {}), "('DJANGO_SETTINGS_MODULE', 'todomvc.settings')\n", (194, 240), False, '... |
'''
datecreated: 191026
objective: give good examples on how to use various tkinter modules.
notes:
* will be using object oriented implementation, best approach for tkinter
* will be using grid layout to build everything, simple and powerful
things to demonstrate:
* simple window - done
* hotkeys - done
* button - d... | [
"tkinter.IntVar",
"tkinter.Checkbutton",
"tkinter.Button",
"tkinter.font.Font",
"tkinter.Tk",
"tkinter.Label",
"tkinter.Frame"
] | [((674, 681), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (679, 681), True, 'import tkinter as tk\n'), ((835, 879), 'tkinter.font.Font', 'ft.Font', (['self.R'], {'family': '"""Helvetica"""', 'size': '(12)'}), "(self.R, family='Helvetica', size=12)\n", (842, 879), True, 'from tkinter import font as ft\n'), ((908, 924), 'tk... |
"MIME handling"
import base64
from io import BytesIO
import mimetypes
from email import encoders, charset
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
from email.mime.base import MIMEBase
from email.mime.audio import MIMEAudio
from email imp... | [
"logging.getLogger",
"email.mime.base.MIMEBase",
"random.Random",
"email.message_from_string",
"io.BytesIO",
"gzip.GzipFile",
"email.encoders.encode_base64",
"email.mime.multipart.MIMEMultipart",
"email.mime.audio.MIMEAudio",
"mimetypes.guess_type",
"email.mime.image.MIMEImage",
"email.message... | [((464, 491), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (481, 491), False, 'import logging\n'), ((629, 683), 'email.charset.add_charset', 'charset.add_charset', (['"""utf-8"""', 'charset.SHORTEST', '"""8bit"""'], {}), "('utf-8', charset.SHORTEST, '8bit')\n", (648, 683), False, 'from ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import codecs
import os
import re
import sys
try:
from setuptools import setup
except ImportError:
from distutils.core import setup
# Get the version
version_regex = r'__version__ = ["\']([^"\']*)["\']'
with open('fly/__init__.py', 'r') as f:
text = f.read()
... | [
"re.search",
"os.system",
"sys.exit",
"distutils.core.setup"
] | [((623, 789), 'distutils.core.setup', 'setup', ([], {'name': '"""fly"""', 'version': 'version', 'description': '"""Asynchronous Dataflow programming framework"""', 'author': '"""<NAME>"""', 'packages': 'packages', 'package_dir': "{'fly': 'fly'}"}), "(name='fly', version=version, description=\n 'Asynchronous Dataflow... |
from rest_framework import generics, status
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from fyle_rest_auth.models import AuthToken
from fyle_integrations_platform_connector import PlatformConnector
from apps.workspaces.models import FyleCredential
from apps.fy... | [
"apps.workspaces.models.FyleCredential",
"fyle_integrations_platform_connector.PlatformConnector",
"rest_framework.response.Response",
"apps.fyle.helpers.get_fyle_orgs",
"fyle_rest_auth.models.AuthToken.objects.get",
"apps.users.helpers.get_cluster_domain_and_refresh_token"
] | [((727, 777), 'apps.users.helpers.get_cluster_domain_and_refresh_token', 'get_cluster_domain_and_refresh_token', (['request.user'], {}), '(request.user)\n', (763, 777), False, 'from apps.users.helpers import get_cluster_domain_and_refresh_token\n'), ((806, 880), 'apps.workspaces.models.FyleCredential', 'FyleCredential'... |
"""
A script which times the training time of our graph2vec
reimplementations using both disk memory dataset loaders
and ram memory dataset loaders.
"""
import os
import time
import numpy as np
from geometric2dr.decomposition.weisfeiler_lehman_patterns import wl_corpus
from geometric2dr.embedding_methods.pvdbow_train... | [
"numpy.mean",
"geometric2dr.decomposition.shortest_path_patterns.sp_corpus",
"geometric2dr.decomposition.weisfeiler_lehman_patterns.wl_corpus",
"geometric2dr.embedding_methods.utils.get_files",
"geometric2dr.embedding_methods.skipgram_trainer.Trainer",
"geometric2dr.embedding_methods.pvdm_trainer.PVDM_Tra... | [((686, 740), 'geometric2dr.embedding_methods.utils.get_files', 'utils.get_files', (['corpus_data_dir', '""".gexf"""'], {'max_files': '(0)'}), "(corpus_data_dir, '.gexf', max_files=0)\n", (701, 740), True, 'import geometric2dr.embedding_methods.utils as utils\n'), ((741, 773), 'geometric2dr.decomposition.weisfeiler_leh... |
# -*- coding: utf8 -*-
# Copyright (c) 2017-2021 THL A29 Limited, a Tencent company. 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... | [
"tencentcloud.iotvideoindustry.v20201201.models.DeleteTimeTemplateResponse",
"tencentcloud.iotvideoindustry.v20201201.models.DescribeLiveRecordPlanIdsResponse",
"tencentcloud.iotvideoindustry.v20201201.models.DescribeMessageForwardResponse",
"tencentcloud.iotvideoindustry.v20201201.models.DescribeRecordStream... | [((1549, 1565), 'json.loads', 'json.loads', (['body'], {}), '(body)\n', (1559, 1565), False, 'import json\n'), ((2748, 2764), 'json.loads', 'json.loads', (['body'], {}), '(body)\n', (2758, 2764), False, 'import json\n'), ((3935, 3951), 'json.loads', 'json.loads', (['body'], {}), '(body)\n', (3945, 3951), False, 'import... |
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
from collections import deque
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
#list1 = [... | [
"collections.deque"
] | [((398, 405), 'collections.deque', 'deque', ([], {}), '()\n', (403, 405), False, 'from collections import deque\n')] |
import csv
import urllib2
import json
###########################################################################
## This searches crunchbase for "Stanford" and only returns people
###########################################################################
search = "http://api.crunchbase.com/v/1/search.js?query=stanf... | [
"urllib2.urlopen",
"csv.writer",
"urllib2.Request",
"json.load",
"csv.reader"
] | [((501, 521), 'urllib2.Request', 'urllib2.Request', (['url'], {}), '(url)\n', (516, 521), False, 'import urllib2\n'), ((530, 550), 'urllib2.urlopen', 'urllib2.urlopen', (['req'], {}), '(req)\n', (545, 550), False, 'import urllib2\n'), ((560, 572), 'json.load', 'json.load', (['j'], {}), '(j)\n', (569, 572), False, 'impo... |
import param
from eve.io.mongo.validation import Validator
from .types import COERCERS
SUPPORTED_SCHEMA_FIELDS = [
"type",
"schema",
"required",
"default",
"readonly",
"valueschema",
"keyschema",
"regex",
"minlength",
"maxlength",
"min",
"max",
"allowed",
"item... | [
"eve.io.mongo.validation.Validator"
] | [((1782, 1810), 'eve.io.mongo.validation.Validator', 'Validator', (["{'value': schema}"], {}), "({'value': schema})\n", (1791, 1810), False, 'from eve.io.mongo.validation import Validator\n')] |