Instruction stringlengths 362 7.83k | output_code stringlengths 1 945 |
|---|---|
Next line prediction: <|code_start|> context = indic.findall('Context')[0]
search = context.attrib['search']
content = indic.findall('Content')[0]
value = content.text
r['guids'][guid] = {'search': search, 'value': value}
r['totalguids'] += 1
return r
def getDataframeFromBatchid(batchid):
engine = create_engine(CERTITUDE_DATABASE, echo=False)
dbsession = sessionmaker(bind=engine)()
columns = ['HostId','HostnameIP' , 'Lookup:Success' , 'Lookup:IOCScanned' , 'Lookup:HashScanned', 'Lookup:Subnet' , 'Malware', 'Compromise']
coldata = []
batch = dbsession.query(Batch).filter_by(id=batchid).first()
if batch is None:
raise Exception('No batch found')
# Get all IOCs
cp = dbsession.query(ConfigurationProfile).filter_by(id=batch.configuration_profile_id).first()
if cp.ioc_list == '':
ioc_list = []
else:
ioc_list = [int(e) for e in cp.ioc_list.split(',')]
<|code_end|>
. Use current file imports:
(import pandas as pd
import io
import base64
import components.scanner.openioc.openiocparser as openiocparser
import xml.etree.ElementTree as ET
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from config import CERTITUDE_DATABASE, LISTEN_ADDRESS, LISTEN_PORT
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
from helpers.misc_models import ConfigurationProfile, XMLIOC, Batch
from bokeh.layouts import row, widgetbox, layout
from bokeh.models import Select, Slider, DataTable, TableColumn, ColumnDataSource
from bokeh.models import ColumnDataSource, BoxSelectTool, ResetTool, Div, HTMLTemplateFormatter
from bokeh.plotting import curdoc, figure)
and context including class names, function names, or small code snippets from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# LISTEN_ADDRESS = '127.0.0.1'
#
# LISTEN_PORT = 5000
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
. Output only the next line. | iocs = dbsession.query(XMLIOC).filter(XMLIOC.id.in_(ioc_list)).all() |
Here is a snippet: <|code_start|> batch_id = 1
def getInfosFromXML(content):
c = base64.b64decode(content)
r = {'guids': {}, 'totalguids': 0}
xml = ET.fromstring(c)
openiocparser.removeNS(xml)
for indic in xml.iter('IndicatorItem'):
guid = indic.attrib['id']
context = indic.findall('Context')[0]
search = context.attrib['search']
content = indic.findall('Content')[0]
value = content.text
r['guids'][guid] = {'search': search, 'value': value}
r['totalguids'] += 1
return r
def getDataframeFromBatchid(batchid):
engine = create_engine(CERTITUDE_DATABASE, echo=False)
dbsession = sessionmaker(bind=engine)()
columns = ['HostId','HostnameIP' , 'Lookup:Success' , 'Lookup:IOCScanned' , 'Lookup:HashScanned', 'Lookup:Subnet' , 'Malware', 'Compromise']
coldata = []
<|code_end|>
. Write the next line using the current file imports:
import pandas as pd
import io
import base64
import components.scanner.openioc.openiocparser as openiocparser
import xml.etree.ElementTree as ET
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from config import CERTITUDE_DATABASE, LISTEN_ADDRESS, LISTEN_PORT
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
from helpers.misc_models import ConfigurationProfile, XMLIOC, Batch
from bokeh.layouts import row, widgetbox, layout
from bokeh.models import Select, Slider, DataTable, TableColumn, ColumnDataSource
from bokeh.models import ColumnDataSource, BoxSelectTool, ResetTool, Div, HTMLTemplateFormatter
from bokeh.plotting import curdoc, figure
and context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# LISTEN_ADDRESS = '127.0.0.1'
#
# LISTEN_PORT = 5000
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
, which may include functions, classes, or code. Output only the next line. | batch = dbsession.query(Batch).filter_by(id=batchid).first() |
Based on the snippet: <|code_start|>
Contact: cert@wavestone.com
Contributors: @iansus, @nervous, @fschwebel
CERTitude is under licence GPL-2.0:
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
'''
if __name__ == "__main__" and __package__ is None:
raise Exception('Error: you have to launch this script from main.py')
# SYS MODULES
# USER MODULES
loggingscan = logging.getLogger('hashscanner.' + threadname)
<|code_end|>
, predict the immediate next line with the help of imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (classes, functions, sometimes code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | engine = create_engine(CERTITUDE_DATABASE, echo=False) |
Based on the snippet: <|code_start|> testdir = os.path.join(IOC_COMPONENT_ROOT, IOC_CONFIDENTIAL_DIRECTORY)
if not os.path.isdir(testdir):
loggingscan.info('Creating confidential directory %s' % testdir)
os.makedirs(testdir)
# Let the scan begin
if cp.id in tree_by_cp.keys():
scanResults = scanTarget(targetObject, tree_by_cp[cp.id], cp.host_confidential)
else:
loggingscan.warning('No IOC to scan (profile=%s)' % cp.name)
scanResults = {}
if scanResults is not None:
analyzeResults(scanResults, task)
else:
rollbackTask(task)
# Update taskQueue size
taskScanListSize = taskScanList.count()
if halt:
# Stop signal encountered
break
if halt:
loggingscan.info('Stopping Hash scanner : ' + threadname)
break
<|code_end|>
, predict the immediate next line with the help of imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (classes, functions, sometimes code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | loggingscan.debug('(Hash scanner sleeping for ' + str(SLEEP) + ' seconds...)' \ |
Given the code snippet: <|code_start|> task = None
batchquery = None
# Batch filtering
if batch is not None:
loggingscan.info('Filtering for batch "%s"' % batch)
batchquery = session.query(Batch).filter( Batch.name == batch).first()
if batchquery is None:
loggingscan.error('Unknown batch "%s" ...' % batch)
halt = True
# LAUNCH
# Main loop
while not halt:
try:
# Get targets to be scanned
# and that are not currently being scanned
# or that don't have any retry left
taskQueue = session.query(Task).filter_by(hashscanned=False, reserved_ioc=False, reserved_hash=False).filter(Task.retries_left_hash > 0)
# Batch filtering
if batchquery is not None:
taskQueue = taskQueue.filter_by(batch_id = batchquery.id)
taskQueueSize = taskQueue.count()
# Compute the time after which targets are still recovering from last scan
# Gets target which last retry is NULL or before that time
<|code_end|>
, generate the next line using the imports in this file:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (functions, classes, or occasionally code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | retryLimit = datetime.datetime.now() - datetime.timedelta(0, MIN_RESCAN_INTERVAL) |
Next line prediction: <|code_start|>
try:
# Drop files
for local, remote in dropList:
if remoteSystem.fileExists(remote):
remoteSystem.deleteFile(remote)
remoteSystem.dropFile(local, remote)
# Start commands
for command in StartCommandList:
remoteSystem.execute(command, True)
# Confidential
hostConfidentialLocalName = os.path.join(IOC_CONFIDENTIAL_DIRECTORY, HANDLER_NAME)
localFullname = os.path.join(IOC_COMPONENT_ROOT, hostConfidentialLocalName)
if hostConfidential:
os.makedirs(os.path.join(IOC_COMPONENT_ROOT, hostConfidentialLocalName))
# TMP query file
if not os.path.isdir(IOC_TEMP_DIR):
os.makedirs(IOC_TEMP_DIR)
TEMP_FILE = os.path.join(IOC_TEMP_DIR, '%s.tmp' % threadname)
# <analysis>
result = {}
rawResults = {}
initFilesPresent = []
<|code_end|>
. Use current file imports:
(import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection)
and context including class names, function names, or small code snippets from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | if IOC_MODE == 'flat': |
Given the following code snippet before the placeholder: <|code_start|> if remoteSystem.fileExists(remote):
remoteSystem.deleteFile(remote)
remoteSystem.dropFile(local, remote)
# Start commands
for command in StartCommandList:
remoteSystem.execute(command, True)
# Confidential
hostConfidentialLocalName = os.path.join(IOC_CONFIDENTIAL_DIRECTORY, HANDLER_NAME)
localFullname = os.path.join(IOC_COMPONENT_ROOT, hostConfidentialLocalName)
if hostConfidential:
os.makedirs(os.path.join(IOC_COMPONENT_ROOT, hostConfidentialLocalName))
# TMP query file
if not os.path.isdir(IOC_TEMP_DIR):
os.makedirs(IOC_TEMP_DIR)
TEMP_FILE = os.path.join(IOC_TEMP_DIR, '%s.tmp' % threadname)
# <analysis>
result = {}
rawResults = {}
initFilesPresent = []
if IOC_MODE == 'flat':
iocDict = iocDict_from_trees(IOCObjects)
for category, ioc_list in iocDict.items():
<|code_end|>
, predict the next line using imports from the current file:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context including class names, function names, and sometimes code from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | evlt = scan_modules.flatEvaluatorList[category](loggingscan, None, remoteSystem, IOC_KEEPFILES, |
Continue the code snippet: <|code_start|> # Init PsExec tunnel to target
try:
remoteSystem = remotecmd.RemoteCmd(threadname,
targetObject['ip'],
targetObject['login'],
targetObject['password'],
domain = targetObject['domain'],
rootDir = IOC_COMPONENT_ROOT
)
loggingscan.info('Handler %s has been succesfully created' % HANDLER_NAME)
remoteSystem.setup()
# too bad, error in connection
except Exception, e:
loggingscan.error(HANDLER_NAME+' startup error: '+str(e).encode(sys.stdout.encoding))
return None
try:
# Drop files
for local, remote in dropList:
if remoteSystem.fileExists(remote):
remoteSystem.deleteFile(remote)
remoteSystem.dropFile(local, remote)
# Start commands
for command in StartCommandList:
remoteSystem.execute(command, True)
# Confidential
<|code_end|>
. Use current file imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (classes, functions, or code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | hostConfidentialLocalName = os.path.join(IOC_CONFIDENTIAL_DIRECTORY, HANDLER_NAME) |
Predict the next line after this snippet: <|code_start|>
# IOC Tree evaluation
for uid, ioc in leaves.items():
# Do we know how to search for that ?
if ioc.document in scan_modules.flatEvaluatorList.keys():
# Getting the dictionary for that category, or creating it
if not ioc.document in iocDictionary.keys():
iocDictionary[ioc.document] = []
ioc.db_ioc_id = ioc_id
iocDictionary[ioc.document].append(ioc)
return iocDictionary
# Scans the target defined by taregtObject
# IOCObjects represents the set of IOC trees to be searche on the workstation
# HostConfidential is a boolean that triggers data retrieval or remote database querying
#
def scanTarget(targetObject, IOCObjects, hostConfidential):
HANDLER_NAME = '%s@%s' % (targetObject['login'], targetObject['ip'])
# Init PsExec tunnel to target
try:
remoteSystem = remotecmd.RemoteCmd(threadname,
targetObject['ip'],
targetObject['login'],
targetObject['password'],
domain = targetObject['domain'],
<|code_end|>
using the current file's imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and any relevant context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | rootDir = IOC_COMPONENT_ROOT |
Predict the next line for this snippet: <|code_start|> domain = targetObject['domain'],
rootDir = IOC_COMPONENT_ROOT
)
loggingscan.info('Handler %s has been succesfully created' % HANDLER_NAME)
remoteSystem.setup()
# too bad, error in connection
except Exception, e:
loggingscan.error(HANDLER_NAME+' startup error: '+str(e).encode(sys.stdout.encoding))
return None
try:
# Drop files
for local, remote in dropList:
if remoteSystem.fileExists(remote):
remoteSystem.deleteFile(remote)
remoteSystem.dropFile(local, remote)
# Start commands
for command in StartCommandList:
remoteSystem.execute(command, True)
# Confidential
hostConfidentialLocalName = os.path.join(IOC_CONFIDENTIAL_DIRECTORY, HANDLER_NAME)
localFullname = os.path.join(IOC_COMPONENT_ROOT, hostConfidentialLocalName)
if hostConfidential:
os.makedirs(os.path.join(IOC_COMPONENT_ROOT, hostConfidentialLocalName))
# TMP query file
<|code_end|>
with the help of current file imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
, which may contain function names, class names, or code. Output only the next line. | if not os.path.isdir(IOC_TEMP_DIR): |
Predict the next line after this snippet: <|code_start|>
loggingscan.info('End hash analysis for host %s' % task.ip)
def rollbackTask(task):
session.rollback()
if task is not None:
task.reserved_hash = False
task.retries_left_hash = max(0,task.retries_left_hash - 1)
task.last_retry_hash = datetime.datetime.now()
session.commit()
# MAIN function launched by the scheduler
# "batch" is used to scan only targets for a specific batch
def startScanner(hWaitStop=None, batch=None):
loggingscan.info('Starting a hash scanner instance : ' + threadname)
print ''
print '\tPlease log in to launch scan'
print ''
username = raw_input('Username: ')
password = getpass.getpass('Password: ')
print ''
# Get user
u = session.query(User).filter_by(username = username).first()
# No user or bad password
<|code_end|>
using the current file's imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and any relevant context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | if not u or hashPassword(password) != u.password: |
Next line prediction: <|code_start|> print ''
print '\tPlease log in to launch scan'
print ''
username = raw_input('Username: ')
password = getpass.getpass('Password: ')
print ''
# Get user
u = session.query(User).filter_by(username = username).first()
# No user or bad password
if not u or hashPassword(password) != u.password:
loggingscan.critical('Username or password incorrect, stopping the initialization, press a key...')
raw_input()
return
# Get KEY and decrypt MASTER_KEY
keyFromPassword = crypto.keyFromText(password, base64.b64decode(u.b64_kdf_salt))
MASTER_KEY = crypto.decrypt(u.encrypted_master_key, keyFromPassword)
masterKeyChecksum = session.query(GlobalConfig).filter_by(key = 'master_key_checksum').first()
# No checksum in config ???
if not masterKeyChecksum:
loggingscan.critical('Database is broken, please create a new one, stopping the initialization...')
del MASTER_KEY
raw_input()
return
# Someone has been playing with the database !
<|code_end|>
. Use current file imports:
(import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection)
and context including class names, function names, or small code snippets from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | if checksum(MASTER_KEY)!=masterKeyChecksum.value: |
Continue the code snippet: <|code_start|> CERTitude: the seeker of IOC
Copyright (c) 2016 CERT-W
Contact: cert@wavestone.com
Contributors: @iansus, @nervous, @fschwebel
CERTitude is under licence GPL-2.0:
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
'''
if __name__ == "__main__" and __package__ is None:
raise Exception('Error: you have to launch this script from main.py')
# SYS MODULES
# USER MODULES
<|code_end|>
. Use current file imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (classes, functions, or code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | loggingscan = logging.getLogger('hashscanner.' + threadname) |
Here is a snippet: <|code_start|> loggingscan.critical('Username or password incorrect, stopping the initialization, press a key...')
raw_input()
return
# Get KEY and decrypt MASTER_KEY
keyFromPassword = crypto.keyFromText(password, base64.b64decode(u.b64_kdf_salt))
MASTER_KEY = crypto.decrypt(u.encrypted_master_key, keyFromPassword)
masterKeyChecksum = session.query(GlobalConfig).filter_by(key = 'master_key_checksum').first()
# No checksum in config ???
if not masterKeyChecksum:
loggingscan.critical('Database is broken, please create a new one, stopping the initialization...')
del MASTER_KEY
raw_input()
return
# Someone has been playing with the database !
if checksum(MASTER_KEY)!=masterKeyChecksum.value:
loggingscan.critical('MASTER_KEY may have been altered, stopping the initialization...')
del MASTER_KEY
raw_input()
return
loggingscan.info('Login successful !')
# INITIALIZATION
# TODO : initialise all IOCs in DB, then link them to CP
allXmlIocs = session.query(XMLIOC).order_by(XMLIOC.name.asc())
<|code_end|>
. Write the next line using the current file imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
, which may include functions, classes, or code. Output only the next line. | allConfigurationProfiles = session.query(ConfigurationProfile).order_by(ConfigurationProfile.name.asc()) |
Based on the snippet: <|code_start|> taskScanList = taskQueue.filter(or_(Task.last_retry_hash <= retryLimit, Task.last_retry_hash == None))
taskScanListSize = taskScanList.count()
# Reads this list
while taskScanListSize > 0:
# Max priority
maxPriority = taskScanList.order_by(Task.priority_hash.desc()).first().priority_hash
maxPriorityTasks = taskScanList.filter(Task.priority_hash==maxPriority)
nbre_maxPriorityTasks = maxPriorityTasks.count()
if CERTITUDE_DATABASE.startswith('sqlite'):
task = maxPriorityTasks.order_by(func.random()).first()
else:
task = maxPriorityTasks.order_by(func.newid()).first()
# Mutex on the task
task.reserved_hash = True
task.date_debut = datetime.datetime.now()
session.commit()
loggingscan.debug('===============================================================================')
loggingscan.debug('Wake up, there is work to do !')
loggingscan.info('taskQueue size : ' + str(taskQueueSize) + ', including ' + str(taskScanListSize) + ' to scan, including ' + str(nbre_maxPriorityTasks) + ' at top priority (' + str(maxPriority) + ')')
loggingscan.debug(' --------------------------------')
loggingscan.info(' Starting Hash scan')
loggingscan.info(' Target : ' + str(task.ip))
loggingscan.debug(' --------------------------------')
# Recover Windows Credential and Configuration Profile from Batch
batch = session.query(Batch).filter_by(id = task.batch_id).first()
<|code_end|>
, predict the immediate next line with the help of imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (classes, functions, sometimes code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | wc = session.query(WindowsCredential).filter_by(id = batch.windows_credential_id).first() |
Predict the next line after this snippet: <|code_start|> if not u or hashPassword(password) != u.password:
loggingscan.critical('Username or password incorrect, stopping the initialization, press a key...')
raw_input()
return
# Get KEY and decrypt MASTER_KEY
keyFromPassword = crypto.keyFromText(password, base64.b64decode(u.b64_kdf_salt))
MASTER_KEY = crypto.decrypt(u.encrypted_master_key, keyFromPassword)
masterKeyChecksum = session.query(GlobalConfig).filter_by(key = 'master_key_checksum').first()
# No checksum in config ???
if not masterKeyChecksum:
loggingscan.critical('Database is broken, please create a new one, stopping the initialization...')
del MASTER_KEY
raw_input()
return
# Someone has been playing with the database !
if checksum(MASTER_KEY)!=masterKeyChecksum.value:
loggingscan.critical('MASTER_KEY may have been altered, stopping the initialization...')
del MASTER_KEY
raw_input()
return
loggingscan.info('Login successful !')
# INITIALIZATION
# TODO : initialise all IOCs in DB, then link them to CP
<|code_end|>
using the current file's imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and any relevant context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | allXmlIocs = session.query(XMLIOC).order_by(XMLIOC.name.asc()) |
Next line prediction: <|code_start|> # Retrieves evaluators for current mode
FLAT_MODE = (IOC_MODE == 'flat')
allowedElements = {}
evaluatorList = scan_modules.flatEvaluatorList if FLAT_MODE else scan_modules.logicEvaluatorList
for name, classname in evaluatorList.items():
allowedElements[name] = classname.evalList
# Parse XML Ioc into IOC trees according to what we can do
for xmlioc in allXmlIocs:
content = base64.b64decode(xmlioc.xml_content)
oip = openiocparser.OpenIOCParser(content, allowedElements, FLAT_MODE, fromString=True)
oip.parse()
iocTree = oip.getTree()
# Trees may be stripped from non valid elements
if iocTree is not None:
treeByIoc[xmlioc.id] = {'name':xmlioc.name, 'tree':iocTree}
# Each configuration profile has a set of trees
tree_by_cp = {cpid: {i:treeByIoc[i] for i in ioclist} for (cpid, ioclist) in iocByConfigurationProfile.items()}
halt = False
task = None
batchquery = None
# Batch filtering
if batch is not None:
loggingscan.info('Filtering for batch "%s"' % batch)
<|code_end|>
. Use current file imports:
(import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection)
and context including class names, function names, or small code snippets from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | batchquery = session.query(Batch).filter( Batch.name == batch).first() |
Next line prediction: <|code_start|> task.last_retry_hash = datetime.datetime.now()
session.commit()
# MAIN function launched by the scheduler
# "batch" is used to scan only targets for a specific batch
def startScanner(hWaitStop=None, batch=None):
loggingscan.info('Starting a hash scanner instance : ' + threadname)
print ''
print '\tPlease log in to launch scan'
print ''
username = raw_input('Username: ')
password = getpass.getpass('Password: ')
print ''
# Get user
u = session.query(User).filter_by(username = username).first()
# No user or bad password
if not u or hashPassword(password) != u.password:
loggingscan.critical('Username or password incorrect, stopping the initialization, press a key...')
raw_input()
return
# Get KEY and decrypt MASTER_KEY
keyFromPassword = crypto.keyFromText(password, base64.b64decode(u.b64_kdf_salt))
MASTER_KEY = crypto.decrypt(u.encrypted_master_key, keyFromPassword)
<|code_end|>
. Use current file imports:
(import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection)
and context including class names, function names, or small code snippets from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | masterKeyChecksum = session.query(GlobalConfig).filter_by(key = 'master_key_checksum').first() |
Predict the next line for this snippet: <|code_start|> session.add(id)
session.commit()
loggingscan.info('End hash analysis for host %s' % task.ip)
def rollbackTask(task):
session.rollback()
if task is not None:
task.reserved_hash = False
task.retries_left_hash = max(0,task.retries_left_hash - 1)
task.last_retry_hash = datetime.datetime.now()
session.commit()
# MAIN function launched by the scheduler
# "batch" is used to scan only targets for a specific batch
def startScanner(hWaitStop=None, batch=None):
loggingscan.info('Starting a hash scanner instance : ' + threadname)
print ''
print '\tPlease log in to launch scan'
print ''
username = raw_input('Username: ')
password = getpass.getpass('Password: ')
print ''
# Get user
<|code_end|>
with the help of current file imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
, which may contain function names, class names, or code. Output only the next line. | u = session.query(User).filter_by(username = username).first() |
Here is a snippet: <|code_start|>
# Uses scan results to build the "Result" row in the database
# If analysis has failed for some reason, decrements priority and retries count
#
def analyzeResults(scanResults, task):
loggingscan.info('Begin hash analysis for host %s' % task.ip)
smbreachable = True
# Scan not completed
if scanResults is None :
task.retries_left_hash -= 1
# Still got some retries left
if task.retries_left_hash > 0:
task.hashscanned = False
task.last_retry_hash = datetime.datetime.now()
task.priority_hash -= 1
else:
task.hashscanned = True
smbreachable = False
else:
task.hashscanned = True
task.reserved_hash = False
session.commit()
<|code_end|>
. Write the next line using the current file imports:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
, which may include functions, classes, or code. Output only the next line. | r = session.query(Result).filter_by(tache_id = task.id).first() |
Given the code snippet: <|code_start|> task.hashscanned = True
smbreachable = False
else:
task.hashscanned = True
task.reserved_hash = False
session.commit()
r = session.query(Result).filter_by(tache_id = task.id).first()
# No result for now
if r is None:
r = Result(
smbreachable = smbreachable,
tache_id=task.id,
)
else:
r.smbreachable = smbreachable
session.add(r)
session.commit()
# If scan has been completed, add the detections to the database
if smbreachable:
for ioc_id, dic in scanResults.items():
if dic['res']!='True':
continue
<|code_end|>
, generate the next line using the imports in this file:
import base64
import datetime
import getpass
import json
import logging
import os
import re
import subprocess
import sys
import socket
import time
import traceback
import uuid
import helpers.crypto as crypto
import helpers.hashscan_modules as scan_modules
import openioc.openiocparser as openiocparser
import openioc.ioc as ioc
import remotecmd
import shutil
from lxml import objectify
from optparse import OptionParser
from sqlalchemy import create_engine, or_, func
from sqlalchemy.orm import sessionmaker
from threading import Lock
from config import CERTITUDE_DATABASE, SLEEP, MIN_RESCAN_INTERVAL
from config import IOC_MODE, IOC_KEEPFILES
from config import IOC_CONFIDENTIAL_DIRECTORY, IOC_COMPONENT_ROOT, IOC_TEMP_DIR
from helpers.helpers import hashPassword, checksum, threadname
from helpers.misc_models import ConfigurationProfile, WindowsCredential, XMLIOC, Batch, GlobalConfig, User
from helpers.queue_models import Task
from helpers.results_models import Result, IOCDetection
and context (functions, classes, or occasionally code) from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
#
# SLEEP = 5 # second interval between database poll
#
# MIN_RESCAN_INTERVAL = 300 # min second interval between two consecutive scans on same IP address
#
# Path: config.py
# IOC_MODE = 'flat' # flat | logic ## DO NOT USE "logic" for now !!!
#
# IOC_KEEPFILES = False # True | False
#
# Path: config.py
# IOC_CONFIDENTIAL_DIRECTORY = 'DR_PLUS'
#
# IOC_COMPONENT_ROOT = os.path.join('components','scanner')
#
# IOC_TEMP_DIR = os.path.join('components','scanner','tmp')
#
# Path: helpers/helpers.py
# def hashPassword(password):
# def checksum(data):
# def verifyPassword(p):
# MIN = False
# MAJ = False
# NUM = False
# SPEC = False
# MIN = True
# MAJ = True
# NUM = True
# SPEC = True
#
# Path: helpers/misc_models.py
# class ConfigurationProfile(Base):
# __tablename__ = 'configuration_profiles'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# host_confidential = Column(Boolean, default=False)
# ioc_list = Column(String)
# yara_list = Column(String)
#
# class WindowsCredential(Base):
# __tablename__ = 'windows_crendentials'
#
# id = Column(Integer, primary_key=True)
# domain = Column(String)
# login = Column(String)
# encrypted_password = Column(String)
#
# class XMLIOC(Base):
# __tablename__ = 'xmliocs'
#
# id = Column(Integer, primary_key=True)
# name = Column(String)
# date_added = Column(DateTime, default=datetime.now)
# xml_content = Column(String)
#
# class Batch(Base):
# __tablename__ = 'batches'
#
# id = Column(Integer, primary_key = True)
# name = Column(String)
# configuration_profile_id = Column(Integer)
# windows_credential_id = Column(Integer)
#
# class GlobalConfig(Base):
# __tablename__ = 'global_config'
#
# id = Column(Integer, primary_key=True)
# key = Column(String)
# value = Column(String)
#
# class User(Base):
# __tablename__ = 'users'
#
# id = Column(Integer, primary_key=True)
# username = Column(String)
# password = Column(String)
# email = Column(String)
# active = Column(Boolean)
# encrypted_master_key = Column(String)
# b64_kdf_salt = Column(String)
#
# Path: helpers/results_models.py
# class Result(Base):
# __tablename__ = 'resultats'
#
# id = Column(Integer, primary_key=True)
# tache_id = Column(Integer, ForeignKey('queue.id'))
# finished = Column(DateTime, default=datetime.now)
#
# up = Column(Boolean)
# blocked = Column(Boolean)
# ip = Column(String)
# hostname = Column(String)
# smbreachable = Column(Boolean)
#
# class IOCDetection(Base):
# __tablename__ = 'iocdetections'
#
# id = Column(Integer, primary_key=True)
# result_id = Column(Integer, ForeignKey('resultats.id'))
# resultat = relationship(Result,
# backref='iocdetections',)
# xmlioc_id = Column(Integer)
# indicator_id = Column(String) # Length should be 62
# indicator_data = Column(String)
. Output only the next line. | id = IOCDetection(result_id = r.id, indicator_id = ioc_id, indicator_data = json.dumps(dic['data']), xmlioc_id = dic['iocid']) |
Predict the next line after this snippet: <|code_start|>#!/usr/bin/env python
# -*- coding: UTF-8 -*-
'''
CERTitude: the seeker of IOC
Copyright (c) 2016 CERT-W
Contact: cert@wavestone.com
Contributors: @iansus, @nervous, @fschwebel
CERTitude is under licence GPL-2.0:
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
'''
# CERTitude core
<|code_end|>
using the current file's imports:
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from config import CERTITUDE_DATABASE
from results_models import Result, IOCDetection
from queue_models import Task
from misc_models import User, GlobalConfig, XMLIOC, ConfigurationProfile, WindowsCredential
from yara_models import YaraRule, YaraDetection
from helpers import hashPassword, checksum, verifyPassword
import crypto
import getpass
import base64
and any relevant context from other files:
# Path: config.py
# CERTITUDE_DATABASE = "sqlite:///data.db"
. Output only the next line. | engine = create_engine(CERTITUDE_DATABASE, echo=False) |
Given the following code snippet before the placeholder: <|code_start|> ):
self.is_async = is_async
self.operation = operation
class OperationState(Enum):
IN_PROGRESS = "in progress"
SUCCEEDED = "succeeded"
FAILED = "failed"
class LastOperation:
def __init__(self,
state: OperationState,
description: str = None
):
self.state = state
self.description = description
class Service:
def __init__(self,
id: str,
name: str,
description: str,
bindable: bool,
plans: List[ServicePlan],
tags: List[str] = None,
requires: List[str] = None,
metadata: ServiceMetadata = None,
<|code_end|>
, predict the next line using imports from the current file:
from enum import Enum
from typing import List, Optional, Union
from openbrokerapi.catalog import (
ServiceDashboardClient,
ServiceMetadata,
ServicePlan,
)
from openbrokerapi.settings import DISABLE_SPACE_ORG_GUID_CHECK
and context including class names, function names, and sometimes code from other files:
# Path: openbrokerapi/catalog.py
# class ServiceDashboardClient:
# def __init__(self,
# redirect_uri: str,
# id: str = None,
# secret: str = None,
# **kwargs
# ):
# self.id = id
# self.secret = secret
# self.redirect_uri = redirect_uri
#
# self.__dict__.update(kwargs)
#
# class ServiceMetadata:
# def __init__(self,
# displayName: str,
# imageUrl: str,
# longDescription: str,
# providerDisplayName: str,
# documentationUrl: str,
# supportUrl: str,
# shareable: Optional[bool] = None,
# **kwargs
# ):
# self.displayName = displayName
# self.imageUrl = imageUrl
# self.longDescription = longDescription
# self.providerDisplayName = providerDisplayName
# self.documentationUrl = documentationUrl
# self.supportUrl = supportUrl
# self.shareable = shareable
#
# self.__dict__.update(kwargs)
#
# class ServicePlan:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# metadata: ServicePlanMetadata = None,
# free: bool = None,
# bindable: bool = None,
# schemas: Schemas = None,
# **kwargs):
# self.id = id
# self.name = name
# self.description = description
# self.metadata = metadata
# self.free = free
# self.bindable = bindable
# self.schemas = schemas
#
# self.__dict__.update(kwargs)
#
# Path: openbrokerapi/settings.py
# DISABLE_SPACE_ORG_GUID_CHECK = getenv('DISABLE_SPACE_ORG_GUID_CHECK', '').lower() == 'true'
. Output only the next line. | dashboard_client: ServiceDashboardClient = None, |
Predict the next line for this snippet: <|code_start|> operation: str = None
):
self.is_async = is_async
self.operation = operation
class OperationState(Enum):
IN_PROGRESS = "in progress"
SUCCEEDED = "succeeded"
FAILED = "failed"
class LastOperation:
def __init__(self,
state: OperationState,
description: str = None
):
self.state = state
self.description = description
class Service:
def __init__(self,
id: str,
name: str,
description: str,
bindable: bool,
plans: List[ServicePlan],
tags: List[str] = None,
requires: List[str] = None,
<|code_end|>
with the help of current file imports:
from enum import Enum
from typing import List, Optional, Union
from openbrokerapi.catalog import (
ServiceDashboardClient,
ServiceMetadata,
ServicePlan,
)
from openbrokerapi.settings import DISABLE_SPACE_ORG_GUID_CHECK
and context from other files:
# Path: openbrokerapi/catalog.py
# class ServiceDashboardClient:
# def __init__(self,
# redirect_uri: str,
# id: str = None,
# secret: str = None,
# **kwargs
# ):
# self.id = id
# self.secret = secret
# self.redirect_uri = redirect_uri
#
# self.__dict__.update(kwargs)
#
# class ServiceMetadata:
# def __init__(self,
# displayName: str,
# imageUrl: str,
# longDescription: str,
# providerDisplayName: str,
# documentationUrl: str,
# supportUrl: str,
# shareable: Optional[bool] = None,
# **kwargs
# ):
# self.displayName = displayName
# self.imageUrl = imageUrl
# self.longDescription = longDescription
# self.providerDisplayName = providerDisplayName
# self.documentationUrl = documentationUrl
# self.supportUrl = supportUrl
# self.shareable = shareable
#
# self.__dict__.update(kwargs)
#
# class ServicePlan:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# metadata: ServicePlanMetadata = None,
# free: bool = None,
# bindable: bool = None,
# schemas: Schemas = None,
# **kwargs):
# self.id = id
# self.name = name
# self.description = description
# self.metadata = metadata
# self.free = free
# self.bindable = bindable
# self.schemas = schemas
#
# self.__dict__.update(kwargs)
#
# Path: openbrokerapi/settings.py
# DISABLE_SPACE_ORG_GUID_CHECK = getenv('DISABLE_SPACE_ORG_GUID_CHECK', '').lower() == 'true'
, which may contain function names, class names, or code. Output only the next line. | metadata: ServiceMetadata = None, |
Given the code snippet: <|code_start|>class UnbindSpec:
def __init__(self,
is_async: bool,
operation: str = None
):
self.is_async = is_async
self.operation = operation
class OperationState(Enum):
IN_PROGRESS = "in progress"
SUCCEEDED = "succeeded"
FAILED = "failed"
class LastOperation:
def __init__(self,
state: OperationState,
description: str = None
):
self.state = state
self.description = description
class Service:
def __init__(self,
id: str,
name: str,
description: str,
bindable: bool,
<|code_end|>
, generate the next line using the imports in this file:
from enum import Enum
from typing import List, Optional, Union
from openbrokerapi.catalog import (
ServiceDashboardClient,
ServiceMetadata,
ServicePlan,
)
from openbrokerapi.settings import DISABLE_SPACE_ORG_GUID_CHECK
and context (functions, classes, or occasionally code) from other files:
# Path: openbrokerapi/catalog.py
# class ServiceDashboardClient:
# def __init__(self,
# redirect_uri: str,
# id: str = None,
# secret: str = None,
# **kwargs
# ):
# self.id = id
# self.secret = secret
# self.redirect_uri = redirect_uri
#
# self.__dict__.update(kwargs)
#
# class ServiceMetadata:
# def __init__(self,
# displayName: str,
# imageUrl: str,
# longDescription: str,
# providerDisplayName: str,
# documentationUrl: str,
# supportUrl: str,
# shareable: Optional[bool] = None,
# **kwargs
# ):
# self.displayName = displayName
# self.imageUrl = imageUrl
# self.longDescription = longDescription
# self.providerDisplayName = providerDisplayName
# self.documentationUrl = documentationUrl
# self.supportUrl = supportUrl
# self.shareable = shareable
#
# self.__dict__.update(kwargs)
#
# class ServicePlan:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# metadata: ServicePlanMetadata = None,
# free: bool = None,
# bindable: bool = None,
# schemas: Schemas = None,
# **kwargs):
# self.id = id
# self.name = name
# self.description = description
# self.metadata = metadata
# self.free = free
# self.bindable = bindable
# self.schemas = schemas
#
# self.__dict__.update(kwargs)
#
# Path: openbrokerapi/settings.py
# DISABLE_SPACE_ORG_GUID_CHECK = getenv('DISABLE_SPACE_ORG_GUID_CHECK', '').lower() == 'true'
. Output only the next line. | plans: List[ServicePlan], |
Given the code snippet: <|code_start|>
class ProvisionDetails:
def __init__(self,
service_id: str,
plan_id: str,
organization_guid: str = None,
space_guid: str = None,
parameters: dict = None,
context: dict = None,
**kwargs):
self.service_id = service_id
self.plan_id = plan_id
self.organization_guid = organization_guid
self.space_guid = space_guid
self.parameters = parameters
self.context = context
# Usage context information
if isinstance(context, dict) and 'organization_guid' in context:
if organization_guid is not None and context['organization_guid'] != organization_guid:
raise TypeError('organization_guid does not match with context.organization_guid')
self.organization_guid = context['organization_guid']
if isinstance(context, dict) and 'space_guid' in context:
if space_guid is not None and context['space_guid'] != space_guid:
raise TypeError('space_guid does not match with context.space_guid')
self.space_guid = context['space_guid']
<|code_end|>
, generate the next line using the imports in this file:
from enum import Enum
from typing import List, Optional, Union
from openbrokerapi.catalog import (
ServiceDashboardClient,
ServiceMetadata,
ServicePlan,
)
from openbrokerapi.settings import DISABLE_SPACE_ORG_GUID_CHECK
and context (functions, classes, or occasionally code) from other files:
# Path: openbrokerapi/catalog.py
# class ServiceDashboardClient:
# def __init__(self,
# redirect_uri: str,
# id: str = None,
# secret: str = None,
# **kwargs
# ):
# self.id = id
# self.secret = secret
# self.redirect_uri = redirect_uri
#
# self.__dict__.update(kwargs)
#
# class ServiceMetadata:
# def __init__(self,
# displayName: str,
# imageUrl: str,
# longDescription: str,
# providerDisplayName: str,
# documentationUrl: str,
# supportUrl: str,
# shareable: Optional[bool] = None,
# **kwargs
# ):
# self.displayName = displayName
# self.imageUrl = imageUrl
# self.longDescription = longDescription
# self.providerDisplayName = providerDisplayName
# self.documentationUrl = documentationUrl
# self.supportUrl = supportUrl
# self.shareable = shareable
#
# self.__dict__.update(kwargs)
#
# class ServicePlan:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# metadata: ServicePlanMetadata = None,
# free: bool = None,
# bindable: bool = None,
# schemas: Schemas = None,
# **kwargs):
# self.id = id
# self.name = name
# self.description = description
# self.metadata = metadata
# self.free = free
# self.bindable = bindable
# self.schemas = schemas
#
# self.__dict__.update(kwargs)
#
# Path: openbrokerapi/settings.py
# DISABLE_SPACE_ORG_GUID_CHECK = getenv('DISABLE_SPACE_ORG_GUID_CHECK', '').lower() == 'true'
. Output only the next line. | if DISABLE_SPACE_ORG_GUID_CHECK: |
Continue the code snippet: <|code_start|>
logger = logging.getLogger(__name__)
def print_request():
logger.debug("--- Request Start -------------------")
logger.debug("--- Header")
for k, v in request.headers:
logger.debug("%s:%s", k, v)
logger.debug("--- Body")
logger.debug(request.data)
logger.debug("--- Request End ---------------------")
def check_originating_identity():
"""
Check and decode the "X-Broker-API-Originating-Identity" header
https://github.com/openservicebrokerapi/servicebroker/blob/v2.13/spec.md#originating-identity
"""
if "X-Broker-API-Originating-Identity" in request.headers:
try:
platform, value = request.headers["X-Broker-API-Originating-Identity"].split(None, 1)
request.originating_identity = {
'platform': platform,
'value': json.loads(base64.standard_b64decode(value))
}
except ValueError as e:
<|code_end|>
. Use current file imports:
import base64
import functools
import logging
from http import HTTPStatus
from openbrokerapi.helper import to_json_response, version_tuple
from openbrokerapi.response import ErrorResponse
from openbrokerapi.settings import MIN_VERSION
from flask import request
from flask import request, json
from flask import request
from flask import request
from flask import request
and context (classes, functions, or code) from other files:
# Path: openbrokerapi/helper.py
# def to_json_response(obj):
# """ Following https://stackoverflow.com/a/1118038 """
# from flask import jsonify
# return jsonify(_to_dict(obj))
#
# def version_tuple(v):
# return tuple(map(int, (v.split("."))))
#
# Path: openbrokerapi/response.py
# class ErrorResponse:
# def __init__(self,
# error: str = None,
# description: str = None):
# self.error = error
# self.description = description
#
# Path: openbrokerapi/settings.py
# MIN_VERSION = version_tuple(MIN_VERSION_STR)
. Output only the next line. | return to_json_response(ErrorResponse( |
Given the following code snippet before the placeholder: <|code_start|> @functools.wraps(f)
def wrapped(*args, **kwargs):
if request.get_json(silent=True) is None:
er = ErrorResponse(description='Improper Content-Type header. Expecting "application/json"')
return to_json_response(er), HTTPStatus.BAD_REQUEST
else:
return f(*args, **kwargs)
return wrapped
def get_auth_filter(broker_credentials):
def requires_auth():
"""Check authentication over all provided usernames else sends a 401 response that enables basic auth"""
auth = request.authorization
if auth:
for credentials in broker_credentials:
if auth.username == credentials.username and auth.password == credentials.password:
return
return to_json_response(ErrorResponse(
description='Could not verify your access level for that URL.\nYou have to login with proper credentials'
)), HTTPStatus.UNAUTHORIZED, {'WWW-Authenticate': 'Basic realm="Login Required"'}
return requires_auth
def check_version():
version = request.headers.get("X-Broker-Api-Version", None)
if not version:
return to_json_response(ErrorResponse(description="No X-Broker-Api-Version found.")), HTTPStatus.BAD_REQUEST
<|code_end|>
, predict the next line using imports from the current file:
import base64
import functools
import logging
from http import HTTPStatus
from openbrokerapi.helper import to_json_response, version_tuple
from openbrokerapi.response import ErrorResponse
from openbrokerapi.settings import MIN_VERSION
from flask import request
from flask import request, json
from flask import request
from flask import request
from flask import request
and context including class names, function names, and sometimes code from other files:
# Path: openbrokerapi/helper.py
# def to_json_response(obj):
# """ Following https://stackoverflow.com/a/1118038 """
# from flask import jsonify
# return jsonify(_to_dict(obj))
#
# def version_tuple(v):
# return tuple(map(int, (v.split("."))))
#
# Path: openbrokerapi/response.py
# class ErrorResponse:
# def __init__(self,
# error: str = None,
# description: str = None):
# self.error = error
# self.description = description
#
# Path: openbrokerapi/settings.py
# MIN_VERSION = version_tuple(MIN_VERSION_STR)
. Output only the next line. | if MIN_VERSION > version_tuple(version): |
Predict the next line for this snippet: <|code_start|>
logger = logging.getLogger(__name__)
def print_request():
logger.debug("--- Request Start -------------------")
logger.debug("--- Header")
for k, v in request.headers:
logger.debug("%s:%s", k, v)
logger.debug("--- Body")
logger.debug(request.data)
logger.debug("--- Request End ---------------------")
def check_originating_identity():
"""
Check and decode the "X-Broker-API-Originating-Identity" header
https://github.com/openservicebrokerapi/servicebroker/blob/v2.13/spec.md#originating-identity
"""
if "X-Broker-API-Originating-Identity" in request.headers:
try:
platform, value = request.headers["X-Broker-API-Originating-Identity"].split(None, 1)
request.originating_identity = {
'platform': platform,
'value': json.loads(base64.standard_b64decode(value))
}
except ValueError as e:
<|code_end|>
with the help of current file imports:
import base64
import functools
import logging
from http import HTTPStatus
from openbrokerapi.helper import to_json_response, version_tuple
from openbrokerapi.response import ErrorResponse
from openbrokerapi.settings import MIN_VERSION
from flask import request
from flask import request, json
from flask import request
from flask import request
from flask import request
and context from other files:
# Path: openbrokerapi/helper.py
# def to_json_response(obj):
# """ Following https://stackoverflow.com/a/1118038 """
# from flask import jsonify
# return jsonify(_to_dict(obj))
#
# def version_tuple(v):
# return tuple(map(int, (v.split("."))))
#
# Path: openbrokerapi/response.py
# class ErrorResponse:
# def __init__(self,
# error: str = None,
# description: str = None):
# self.error = error
# self.description = description
#
# Path: openbrokerapi/settings.py
# MIN_VERSION = version_tuple(MIN_VERSION_STR)
, which may contain function names, class names, or code. Output only the next line. | return to_json_response(ErrorResponse( |
Continue the code snippet: <|code_start|> @functools.wraps(f)
def wrapped(*args, **kwargs):
if request.get_json(silent=True) is None:
er = ErrorResponse(description='Improper Content-Type header. Expecting "application/json"')
return to_json_response(er), HTTPStatus.BAD_REQUEST
else:
return f(*args, **kwargs)
return wrapped
def get_auth_filter(broker_credentials):
def requires_auth():
"""Check authentication over all provided usernames else sends a 401 response that enables basic auth"""
auth = request.authorization
if auth:
for credentials in broker_credentials:
if auth.username == credentials.username and auth.password == credentials.password:
return
return to_json_response(ErrorResponse(
description='Could not verify your access level for that URL.\nYou have to login with proper credentials'
)), HTTPStatus.UNAUTHORIZED, {'WWW-Authenticate': 'Basic realm="Login Required"'}
return requires_auth
def check_version():
version = request.headers.get("X-Broker-Api-Version", None)
if not version:
return to_json_response(ErrorResponse(description="No X-Broker-Api-Version found.")), HTTPStatus.BAD_REQUEST
<|code_end|>
. Use current file imports:
import base64
import functools
import logging
from http import HTTPStatus
from openbrokerapi.helper import to_json_response, version_tuple
from openbrokerapi.response import ErrorResponse
from openbrokerapi.settings import MIN_VERSION
from flask import request
from flask import request, json
from flask import request
from flask import request
from flask import request
and context (classes, functions, or code) from other files:
# Path: openbrokerapi/helper.py
# def to_json_response(obj):
# """ Following https://stackoverflow.com/a/1118038 """
# from flask import jsonify
# return jsonify(_to_dict(obj))
#
# def version_tuple(v):
# return tuple(map(int, (v.split("."))))
#
# Path: openbrokerapi/response.py
# class ErrorResponse:
# def __init__(self,
# error: str = None,
# description: str = None):
# self.error = error
# self.description = description
#
# Path: openbrokerapi/settings.py
# MIN_VERSION = version_tuple(MIN_VERSION_STR)
. Output only the next line. | if MIN_VERSION > version_tuple(version): |
Given snippet: <|code_start|> credentials: dict = None,
syslog_drain_url: str = None,
route_service_url: str = None,
volume_mounts: List[VolumeMount] = None,
parameters: Optional[dict] = None
):
self.credentials = credentials
self.syslog_drain_url = syslog_drain_url
self.route_service_url = route_service_url
self.volume_mounts = volume_mounts
self.parameters = parameters
class UnbindResponse(AsyncResponse):
def __init__(self, operation: str):
self.operation = operation
class UpdateResponse(AsyncResponse):
def __init__(self, operation: Optional[str], dashboard_url: Optional[str]):
self.operation = operation
self.dashboard_url = dashboard_url
class DeprovisionResponse(AsyncResponse):
def __init__(self, operation: str):
self.operation = operation
class LastOperationResponse:
def __init__(self,
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from typing import List, Optional
from openbrokerapi.service_broker import OperationState, VolumeMount, Service
and context:
# Path: openbrokerapi/service_broker.py
# class OperationState(Enum):
# IN_PROGRESS = "in progress"
# SUCCEEDED = "succeeded"
# FAILED = "failed"
#
# class VolumeMount:
# def __init__(self,
# driver: str,
# container_dir: str,
# mode: str,
# device_type: str,
# device: SharedDevice
# ):
# self.driver = driver
# self.container_dir = container_dir
# self.mode = mode
# self.device_type = device_type
# self.device = device
#
# class Service:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# bindable: bool,
# plans: List[ServicePlan],
# tags: List[str] = None,
# requires: List[str] = None,
# metadata: ServiceMetadata = None,
# dashboard_client: ServiceDashboardClient = None,
# plan_updateable: bool = False,
# instances_retrievable: bool = False,
# bindings_retrievable: bool = False,
# **kwargs
# ):
# """
# :param requires: syslog_drain, route_forwarding or volume_mount
# """
# self.id = id
# self.name = name
# self.description = description
# self.bindable = bindable
# self.plans = plans
# self.tags = tags
# self.requires = requires
# self.metadata = metadata
# self.dashboard_client = dashboard_client
# self.plan_updateable = plan_updateable
# self.instances_retrievable = instances_retrievable
# self.bindings_retrievable = bindings_retrievable
#
# self.__dict__.update(kwargs)
which might include code, classes, or functions. Output only the next line. | state: OperationState, |
Given the following code snippet before the placeholder: <|code_start|> def __init__(self, services: List[Service]):
self.services = services
class ProvisioningResponse(AsyncResponse):
def __init__(self,
dashboard_url: str,
operation: str):
self.dashboard_url = dashboard_url
self.operation = operation
class GetInstanceResponse:
def __init__(self,
service_id: str,
plan_id: str,
dashboard_url: Optional[str] = None,
parameters: Optional[dict] = None
):
self.service_id = service_id
self.plan_id = plan_id
self.dashboard_url = dashboard_url
self.parameters = parameters
class BindResponse:
def __init__(self,
credentials: dict = None,
syslog_drain_url: str = None,
route_service_url: str = None,
<|code_end|>
, predict the next line using imports from the current file:
from typing import List, Optional
from openbrokerapi.service_broker import OperationState, VolumeMount, Service
and context including class names, function names, and sometimes code from other files:
# Path: openbrokerapi/service_broker.py
# class OperationState(Enum):
# IN_PROGRESS = "in progress"
# SUCCEEDED = "succeeded"
# FAILED = "failed"
#
# class VolumeMount:
# def __init__(self,
# driver: str,
# container_dir: str,
# mode: str,
# device_type: str,
# device: SharedDevice
# ):
# self.driver = driver
# self.container_dir = container_dir
# self.mode = mode
# self.device_type = device_type
# self.device = device
#
# class Service:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# bindable: bool,
# plans: List[ServicePlan],
# tags: List[str] = None,
# requires: List[str] = None,
# metadata: ServiceMetadata = None,
# dashboard_client: ServiceDashboardClient = None,
# plan_updateable: bool = False,
# instances_retrievable: bool = False,
# bindings_retrievable: bool = False,
# **kwargs
# ):
# """
# :param requires: syslog_drain, route_forwarding or volume_mount
# """
# self.id = id
# self.name = name
# self.description = description
# self.bindable = bindable
# self.plans = plans
# self.tags = tags
# self.requires = requires
# self.metadata = metadata
# self.dashboard_client = dashboard_client
# self.plan_updateable = plan_updateable
# self.instances_retrievable = instances_retrievable
# self.bindings_retrievable = bindings_retrievable
#
# self.__dict__.update(kwargs)
. Output only the next line. | volume_mounts: List[VolumeMount] = None, |
Predict the next line after this snippet: <|code_start|>
class EmptyResponse:
pass
class ErrorResponse:
def __init__(self,
error: str = None,
description: str = None):
self.error = error
self.description = description
class AsyncResponse:
pass
class CatalogResponse:
<|code_end|>
using the current file's imports:
from typing import List, Optional
from openbrokerapi.service_broker import OperationState, VolumeMount, Service
and any relevant context from other files:
# Path: openbrokerapi/service_broker.py
# class OperationState(Enum):
# IN_PROGRESS = "in progress"
# SUCCEEDED = "succeeded"
# FAILED = "failed"
#
# class VolumeMount:
# def __init__(self,
# driver: str,
# container_dir: str,
# mode: str,
# device_type: str,
# device: SharedDevice
# ):
# self.driver = driver
# self.container_dir = container_dir
# self.mode = mode
# self.device_type = device_type
# self.device = device
#
# class Service:
# def __init__(self,
# id: str,
# name: str,
# description: str,
# bindable: bool,
# plans: List[ServicePlan],
# tags: List[str] = None,
# requires: List[str] = None,
# metadata: ServiceMetadata = None,
# dashboard_client: ServiceDashboardClient = None,
# plan_updateable: bool = False,
# instances_retrievable: bool = False,
# bindings_retrievable: bool = False,
# **kwargs
# ):
# """
# :param requires: syslog_drain, route_forwarding or volume_mount
# """
# self.id = id
# self.name = name
# self.description = description
# self.bindable = bindable
# self.plans = plans
# self.tags = tags
# self.requires = requires
# self.metadata = metadata
# self.dashboard_client = dashboard_client
# self.plan_updateable = plan_updateable
# self.instances_retrievable = instances_retrievable
# self.bindings_retrievable = bindings_retrievable
#
# self.__dict__.update(kwargs)
. Output only the next line. | def __init__(self, services: List[Service]): |
Predict the next line for this snippet: <|code_start|>
def user_logged_in(sender, request, user, **kwargs):
try:
with transaction.atomic():
login_event = audit_logger.login({
'login_type': LoginEvent.LOGIN,
'username': getattr(user, user.USERNAME_FIELD),
'user_id': getattr(user, 'id', None),
'remote_ip': request.META[REMOTE_ADDR_HEADER]
})
except:
pass
def user_logged_out(sender, request, user, **kwargs):
try:
with transaction.atomic():
login_event = audit_logger.login({
'login_type': LoginEvent.LOGOUT,
'username': getattr(user, user.USERNAME_FIELD),
'user_id': getattr(user, 'id', None),
'remote_ip': request.META[REMOTE_ADDR_HEADER]
})
except:
pass
def user_login_failed(sender, credentials, **kwargs):
try:
with transaction.atomic():
<|code_end|>
with the help of current file imports:
from django.contrib.auth import signals, get_user_model
from django.db import transaction
from django.utils.module_loading import import_string
from easyaudit.middleware.easyaudit import get_current_request
from easyaudit.models import LoginEvent
from easyaudit.settings import REMOTE_ADDR_HEADER, WATCH_AUTH_EVENTS, LOGGING_BACKEND
and context from other files:
# Path: easyaudit/middleware/easyaudit.py
# def get_current_request():
# return getattr(_thread_locals, 'request', None)
#
# Path: easyaudit/models.py
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
#
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# WATCH_AUTH_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_AUTH_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
, which may contain function names, class names, or code. Output only the next line. | request = get_current_request() # request argument not available in django < 1.11 |
Continue the code snippet: <|code_start|>
audit_logger = import_string(LOGGING_BACKEND)()
def user_logged_in(sender, request, user, **kwargs):
try:
with transaction.atomic():
login_event = audit_logger.login({
<|code_end|>
. Use current file imports:
from django.contrib.auth import signals, get_user_model
from django.db import transaction
from django.utils.module_loading import import_string
from easyaudit.middleware.easyaudit import get_current_request
from easyaudit.models import LoginEvent
from easyaudit.settings import REMOTE_ADDR_HEADER, WATCH_AUTH_EVENTS, LOGGING_BACKEND
and context (classes, functions, or code) from other files:
# Path: easyaudit/middleware/easyaudit.py
# def get_current_request():
# return getattr(_thread_locals, 'request', None)
#
# Path: easyaudit/models.py
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
#
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# WATCH_AUTH_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_AUTH_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
. Output only the next line. | 'login_type': LoginEvent.LOGIN, |
Continue the code snippet: <|code_start|>
audit_logger = import_string(LOGGING_BACKEND)()
def user_logged_in(sender, request, user, **kwargs):
try:
with transaction.atomic():
login_event = audit_logger.login({
'login_type': LoginEvent.LOGIN,
'username': getattr(user, user.USERNAME_FIELD),
'user_id': getattr(user, 'id', None),
<|code_end|>
. Use current file imports:
from django.contrib.auth import signals, get_user_model
from django.db import transaction
from django.utils.module_loading import import_string
from easyaudit.middleware.easyaudit import get_current_request
from easyaudit.models import LoginEvent
from easyaudit.settings import REMOTE_ADDR_HEADER, WATCH_AUTH_EVENTS, LOGGING_BACKEND
and context (classes, functions, or code) from other files:
# Path: easyaudit/middleware/easyaudit.py
# def get_current_request():
# return getattr(_thread_locals, 'request', None)
#
# Path: easyaudit/models.py
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
#
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# WATCH_AUTH_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_AUTH_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
. Output only the next line. | 'remote_ip': request.META[REMOTE_ADDR_HEADER] |
Predict the next line for this snippet: <|code_start|> pass
def user_logged_out(sender, request, user, **kwargs):
try:
with transaction.atomic():
login_event = audit_logger.login({
'login_type': LoginEvent.LOGOUT,
'username': getattr(user, user.USERNAME_FIELD),
'user_id': getattr(user, 'id', None),
'remote_ip': request.META[REMOTE_ADDR_HEADER]
})
except:
pass
def user_login_failed(sender, credentials, **kwargs):
try:
with transaction.atomic():
request = get_current_request() # request argument not available in django < 1.11
user_model = get_user_model()
login_event = audit_logger.login({
'login_type': LoginEvent.FAILED,
'username': credentials[user_model.USERNAME_FIELD],
'remote_ip': request.META[REMOTE_ADDR_HEADER]
})
except:
pass
<|code_end|>
with the help of current file imports:
from django.contrib.auth import signals, get_user_model
from django.db import transaction
from django.utils.module_loading import import_string
from easyaudit.middleware.easyaudit import get_current_request
from easyaudit.models import LoginEvent
from easyaudit.settings import REMOTE_ADDR_HEADER, WATCH_AUTH_EVENTS, LOGGING_BACKEND
and context from other files:
# Path: easyaudit/middleware/easyaudit.py
# def get_current_request():
# return getattr(_thread_locals, 'request', None)
#
# Path: easyaudit/models.py
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
#
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# WATCH_AUTH_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_AUTH_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
, which may contain function names, class names, or code. Output only the next line. | if WATCH_AUTH_EVENTS: |
Given snippet: <|code_start|>
logger = logging.getLogger(__name__)
class ModelBackend:
def request(self, request_info):
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import logging
from easyaudit.models import RequestEvent, CRUDEvent, LoginEvent
and context:
# Path: easyaudit/models.py
# class RequestEvent(models.Model):
# url = models.CharField(null=False, db_index=True, max_length=254, verbose_name=_('URL'))
# method = models.CharField(max_length=20, null=False, db_index=True, verbose_name=_('Method'))
# query_string = models.TextField(null=True, verbose_name=_('Query string'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('request event')
# verbose_name_plural = _('request events')
# ordering = ['-datetime']
#
# class CRUDEvent(models.Model):
# CREATE = 1
# UPDATE = 2
# DELETE = 3
# M2M_CHANGE = 4
# M2M_CHANGE_REV = 5
# M2M_ADD = 6
# M2M_ADD_REV = 7
# M2M_REMOVE = 8
# M2M_REMOVE_REV = 9
# M2M_CLEAR = 10
# M2M_CLEAR_REV = 11
#
# TYPES = (
# (CREATE, _('Create')),
# (UPDATE, _('Update')),
# (DELETE, _('Delete')),
# (M2M_CHANGE, _('Many-to-Many Change')),
# (M2M_CHANGE_REV, _('Reverse Many-to-Many Change')),
# (M2M_ADD, _('Many-to-Many Add')),
# (M2M_ADD_REV, _('Reverse Many-to-Many Add')),
# (M2M_REMOVE, _('Many-to-Many Remove')),
# (M2M_REMOVE_REV, _('Reverse Many-to-Many Remove')),
# (M2M_CLEAR, _('Many-to-Many Clear')),
# (M2M_CLEAR_REV, _('Reverse Many-to-Many Clear')),
# )
#
# event_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# object_id = models.CharField(max_length=255, verbose_name=_('Object ID'))
# content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, db_constraint=False, verbose_name=_('Content type'))
# object_repr = models.TextField(null=True, blank=True, verbose_name=_('Object representation'))
# object_json_repr = models.TextField(null=True, blank=True, verbose_name=_('Object JSON representation'))
# changed_fields = models.TextField(null=True, blank=True, verbose_name=_('Changed fields'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True,
# blank=True, on_delete=models.SET_NULL,
# db_constraint=False, verbose_name=_('User'))
# user_pk_as_string = models.CharField(max_length=255, null=True, blank=True,
# help_text=_('String version of the user pk'), verbose_name=_('User PK as string'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# def is_create(self):
# return self.CREATE == self.event_type
#
# def is_update(self):
# return self.UPDATE == self.event_type
#
# def is_delete(self):
# return self.DELETE == self.event_type
#
# class Meta:
# verbose_name = _('CRUD event')
# verbose_name_plural = _('CRUD events')
# ordering = ['-datetime']
# index_together = ['object_id', 'content_type', ]
#
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
which might include code, classes, or functions. Output only the next line. | return RequestEvent.objects.create(**request_info) |
Given the following code snippet before the placeholder: <|code_start|>
logger = logging.getLogger(__name__)
class ModelBackend:
def request(self, request_info):
return RequestEvent.objects.create(**request_info)
def crud(self, crud_info):
<|code_end|>
, predict the next line using imports from the current file:
import logging
from easyaudit.models import RequestEvent, CRUDEvent, LoginEvent
and context including class names, function names, and sometimes code from other files:
# Path: easyaudit/models.py
# class RequestEvent(models.Model):
# url = models.CharField(null=False, db_index=True, max_length=254, verbose_name=_('URL'))
# method = models.CharField(max_length=20, null=False, db_index=True, verbose_name=_('Method'))
# query_string = models.TextField(null=True, verbose_name=_('Query string'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('request event')
# verbose_name_plural = _('request events')
# ordering = ['-datetime']
#
# class CRUDEvent(models.Model):
# CREATE = 1
# UPDATE = 2
# DELETE = 3
# M2M_CHANGE = 4
# M2M_CHANGE_REV = 5
# M2M_ADD = 6
# M2M_ADD_REV = 7
# M2M_REMOVE = 8
# M2M_REMOVE_REV = 9
# M2M_CLEAR = 10
# M2M_CLEAR_REV = 11
#
# TYPES = (
# (CREATE, _('Create')),
# (UPDATE, _('Update')),
# (DELETE, _('Delete')),
# (M2M_CHANGE, _('Many-to-Many Change')),
# (M2M_CHANGE_REV, _('Reverse Many-to-Many Change')),
# (M2M_ADD, _('Many-to-Many Add')),
# (M2M_ADD_REV, _('Reverse Many-to-Many Add')),
# (M2M_REMOVE, _('Many-to-Many Remove')),
# (M2M_REMOVE_REV, _('Reverse Many-to-Many Remove')),
# (M2M_CLEAR, _('Many-to-Many Clear')),
# (M2M_CLEAR_REV, _('Reverse Many-to-Many Clear')),
# )
#
# event_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# object_id = models.CharField(max_length=255, verbose_name=_('Object ID'))
# content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, db_constraint=False, verbose_name=_('Content type'))
# object_repr = models.TextField(null=True, blank=True, verbose_name=_('Object representation'))
# object_json_repr = models.TextField(null=True, blank=True, verbose_name=_('Object JSON representation'))
# changed_fields = models.TextField(null=True, blank=True, verbose_name=_('Changed fields'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True,
# blank=True, on_delete=models.SET_NULL,
# db_constraint=False, verbose_name=_('User'))
# user_pk_as_string = models.CharField(max_length=255, null=True, blank=True,
# help_text=_('String version of the user pk'), verbose_name=_('User PK as string'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# def is_create(self):
# return self.CREATE == self.event_type
#
# def is_update(self):
# return self.UPDATE == self.event_type
#
# def is_delete(self):
# return self.DELETE == self.event_type
#
# class Meta:
# verbose_name = _('CRUD event')
# verbose_name_plural = _('CRUD events')
# ordering = ['-datetime']
# index_together = ['object_id', 'content_type', ]
#
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
. Output only the next line. | return CRUDEvent.objects.create(**crud_info) |
Given the following code snippet before the placeholder: <|code_start|>
logger = logging.getLogger(__name__)
class ModelBackend:
def request(self, request_info):
return RequestEvent.objects.create(**request_info)
def crud(self, crud_info):
return CRUDEvent.objects.create(**crud_info)
def login(self, login_info):
<|code_end|>
, predict the next line using imports from the current file:
import logging
from easyaudit.models import RequestEvent, CRUDEvent, LoginEvent
and context including class names, function names, and sometimes code from other files:
# Path: easyaudit/models.py
# class RequestEvent(models.Model):
# url = models.CharField(null=False, db_index=True, max_length=254, verbose_name=_('URL'))
# method = models.CharField(max_length=20, null=False, db_index=True, verbose_name=_('Method'))
# query_string = models.TextField(null=True, verbose_name=_('Query string'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('request event')
# verbose_name_plural = _('request events')
# ordering = ['-datetime']
#
# class CRUDEvent(models.Model):
# CREATE = 1
# UPDATE = 2
# DELETE = 3
# M2M_CHANGE = 4
# M2M_CHANGE_REV = 5
# M2M_ADD = 6
# M2M_ADD_REV = 7
# M2M_REMOVE = 8
# M2M_REMOVE_REV = 9
# M2M_CLEAR = 10
# M2M_CLEAR_REV = 11
#
# TYPES = (
# (CREATE, _('Create')),
# (UPDATE, _('Update')),
# (DELETE, _('Delete')),
# (M2M_CHANGE, _('Many-to-Many Change')),
# (M2M_CHANGE_REV, _('Reverse Many-to-Many Change')),
# (M2M_ADD, _('Many-to-Many Add')),
# (M2M_ADD_REV, _('Reverse Many-to-Many Add')),
# (M2M_REMOVE, _('Many-to-Many Remove')),
# (M2M_REMOVE_REV, _('Reverse Many-to-Many Remove')),
# (M2M_CLEAR, _('Many-to-Many Clear')),
# (M2M_CLEAR_REV, _('Reverse Many-to-Many Clear')),
# )
#
# event_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# object_id = models.CharField(max_length=255, verbose_name=_('Object ID'))
# content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, db_constraint=False, verbose_name=_('Content type'))
# object_repr = models.TextField(null=True, blank=True, verbose_name=_('Object representation'))
# object_json_repr = models.TextField(null=True, blank=True, verbose_name=_('Object JSON representation'))
# changed_fields = models.TextField(null=True, blank=True, verbose_name=_('Changed fields'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True,
# blank=True, on_delete=models.SET_NULL,
# db_constraint=False, verbose_name=_('User'))
# user_pk_as_string = models.CharField(max_length=255, null=True, blank=True,
# help_text=_('String version of the user pk'), verbose_name=_('User PK as string'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# def is_create(self):
# return self.CREATE == self.event_type
#
# def is_update(self):
# return self.UPDATE == self.event_type
#
# def is_delete(self):
# return self.DELETE == self.event_type
#
# class Meta:
# verbose_name = _('CRUD event')
# verbose_name_plural = _('CRUD events')
# ordering = ['-datetime']
# index_together = ['object_id', 'content_type', ]
#
# class LoginEvent(models.Model):
# LOGIN = 0
# LOGOUT = 1
# FAILED = 2
# TYPES = (
# (LOGIN, _('Login')),
# (LOGOUT, _('Logout')),
# (FAILED, _('Failed login')),
# )
# login_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# username = models.CharField(max_length=255, null=True, blank=True, verbose_name=_('Username'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('login event')
# verbose_name_plural = _('login events')
# ordering = ['-datetime']
. Output only the next line. | return LoginEvent.objects.create(**login_info) |
Predict the next line for this snippet: <|code_start|>
audit_logger = import_string(LOGGING_BACKEND)()
def should_log_url(url):
# check if current url is blacklisted
for unregistered_url in UNREGISTERED_URLS:
pattern = re.compile(unregistered_url)
if pattern.match(url):
return False
# only audit URLs listed in REGISTERED_URLS (if it's set)
if len(REGISTERED_URLS) > 0:
for registered_url in REGISTERED_URLS:
pattern = re.compile(registered_url)
if pattern.match(url):
return True
return False
# all good
return True
def request_started_handler(sender, **kwargs):
environ = kwargs.get("environ")
scope = kwargs.get("scope")
if environ:
path = environ["PATH_INFO"]
cookie_string = environ.get('HTTP_COOKIE')
<|code_end|>
with the help of current file imports:
from django.contrib.auth import get_user_model
from django.contrib.sessions.models import Session
from django.core.signals import request_started
from django.http.cookie import SimpleCookie
from django.utils import timezone
from django.conf import settings
from django.utils.module_loading import import_string
from easyaudit.settings import REMOTE_ADDR_HEADER, UNREGISTERED_URLS, REGISTERED_URLS, WATCH_REQUEST_EVENTS, \
LOGGING_BACKEND
import re
and context from other files:
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# UNREGISTERED_URLS = [r'^/admin/', r'^/static/', r'^/favicon.ico$']
#
# REGISTERED_URLS = getattr(settings, 'DJANGO_EASY_AUDIT_REGISTERED_URLS', [])
#
# WATCH_REQUEST_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_REQUEST_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
, which may contain function names, class names, or code. Output only the next line. | remote_ip = environ[REMOTE_ADDR_HEADER] |
Given the following code snippet before the placeholder: <|code_start|>
# try and get the user from the request; commented for now, may have a bug in this flow.
# from easyaudit.middleware.easyaudit import get_current_user
audit_logger = import_string(LOGGING_BACKEND)()
def should_log_url(url):
# check if current url is blacklisted
for unregistered_url in UNREGISTERED_URLS:
pattern = re.compile(unregistered_url)
if pattern.match(url):
return False
# only audit URLs listed in REGISTERED_URLS (if it's set)
<|code_end|>
, predict the next line using imports from the current file:
from django.contrib.auth import get_user_model
from django.contrib.sessions.models import Session
from django.core.signals import request_started
from django.http.cookie import SimpleCookie
from django.utils import timezone
from django.conf import settings
from django.utils.module_loading import import_string
from easyaudit.settings import REMOTE_ADDR_HEADER, UNREGISTERED_URLS, REGISTERED_URLS, WATCH_REQUEST_EVENTS, \
LOGGING_BACKEND
import re
and context including class names, function names, and sometimes code from other files:
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# UNREGISTERED_URLS = [r'^/admin/', r'^/static/', r'^/favicon.ico$']
#
# REGISTERED_URLS = getattr(settings, 'DJANGO_EASY_AUDIT_REGISTERED_URLS', [])
#
# WATCH_REQUEST_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_REQUEST_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
. Output only the next line. | if len(REGISTERED_URLS) > 0: |
Given the following code snippet before the placeholder: <|code_start|> cookie = SimpleCookie()
cookie.load(cookie_string)
session_cookie_name = settings.SESSION_COOKIE_NAME
if session_cookie_name in cookie:
session_id = cookie[session_cookie_name].value
try:
session = Session.objects.get(session_key=session_id)
except Session.DoesNotExist:
session = None
if session:
user_id = session.get_decoded().get('_auth_user_id')
try:
user = get_user_model().objects.get(id=user_id)
except:
user = None
# may want to wrap this in an atomic transaction later
request_event = audit_logger.request({
'url': path,
'method': method,
'query_string': query_string,
'user_id': getattr(user, 'id', None),
'remote_ip': remote_ip,
'datetime': timezone.now()
})
<|code_end|>
, predict the next line using imports from the current file:
from django.contrib.auth import get_user_model
from django.contrib.sessions.models import Session
from django.core.signals import request_started
from django.http.cookie import SimpleCookie
from django.utils import timezone
from django.conf import settings
from django.utils.module_loading import import_string
from easyaudit.settings import REMOTE_ADDR_HEADER, UNREGISTERED_URLS, REGISTERED_URLS, WATCH_REQUEST_EVENTS, \
LOGGING_BACKEND
import re
and context including class names, function names, and sometimes code from other files:
# Path: easyaudit/settings.py
# REMOTE_ADDR_HEADER = getattr(settings, 'DJANGO_EASY_AUDIT_REMOTE_ADDR_HEADER', 'REMOTE_ADDR')
#
# UNREGISTERED_URLS = [r'^/admin/', r'^/static/', r'^/favicon.ico$']
#
# REGISTERED_URLS = getattr(settings, 'DJANGO_EASY_AUDIT_REGISTERED_URLS', [])
#
# WATCH_REQUEST_EVENTS = getattr(settings, 'DJANGO_EASY_AUDIT_WATCH_REQUEST_EVENTS', True)
#
# LOGGING_BACKEND = getattr(settings, 'DJANGO_EASY_AUDIT_LOGGING_BACKEND', 'easyaudit.backends.ModelBackend')
. Output only the next line. | if WATCH_REQUEST_EVENTS: |
Based on the snippet: <|code_start|>
asgi_views_supported = django.VERSION >= (3, 1)
if asgi_views_supported:
class WithUserInfoMixin:
def setUp(self):
self.username = 'joe@example.com'
self.email = 'joe@example.com'
self.password = 'password'
class TestDjangoCompat(SimpleTestCase):
def test_model_state(self):
"""Ensures models have the internal `_state` object."""
inst = TestModel()
self.assertTrue(hasattr(inst, '_state'))
@override_settings(TEST=True)
class TestAuditModels(TestCase):
Model = TestModel
FKModel = TestForeignKey
M2MModel = TestM2M
def test_create_model(self):
obj = self.Model.objects.create()
<|code_end|>
, predict the immediate next line with the help of imports:
import json
import re
import django
import bs4
from unittest import skip, skipIf
from asgiref.sync import sync_to_async
from django.test import TestCase, override_settings, tag, TransactionTestCase, SimpleTestCase
from django.urls import reverse, reverse_lazy
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from test_app.models import (
TestModel, TestForeignKey, TestM2M,
TestBigIntModel, TestBigIntForeignKey, TestBigIntM2M,
TestUUIDModel, TestUUIDForeignKey, TestUUIDM2M
)
from easyaudit.models import CRUDEvent, RequestEvent
from easyaudit.middleware.easyaudit import set_current_user, clear_request
and context (classes, functions, sometimes code) from other files:
# Path: easyaudit/models.py
# class CRUDEvent(models.Model):
# CREATE = 1
# UPDATE = 2
# DELETE = 3
# M2M_CHANGE = 4
# M2M_CHANGE_REV = 5
# M2M_ADD = 6
# M2M_ADD_REV = 7
# M2M_REMOVE = 8
# M2M_REMOVE_REV = 9
# M2M_CLEAR = 10
# M2M_CLEAR_REV = 11
#
# TYPES = (
# (CREATE, _('Create')),
# (UPDATE, _('Update')),
# (DELETE, _('Delete')),
# (M2M_CHANGE, _('Many-to-Many Change')),
# (M2M_CHANGE_REV, _('Reverse Many-to-Many Change')),
# (M2M_ADD, _('Many-to-Many Add')),
# (M2M_ADD_REV, _('Reverse Many-to-Many Add')),
# (M2M_REMOVE, _('Many-to-Many Remove')),
# (M2M_REMOVE_REV, _('Reverse Many-to-Many Remove')),
# (M2M_CLEAR, _('Many-to-Many Clear')),
# (M2M_CLEAR_REV, _('Reverse Many-to-Many Clear')),
# )
#
# event_type = models.SmallIntegerField(choices=TYPES, verbose_name=_('Event type'))
# object_id = models.CharField(max_length=255, verbose_name=_('Object ID'))
# content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE, db_constraint=False, verbose_name=_('Content type'))
# object_repr = models.TextField(null=True, blank=True, verbose_name=_('Object representation'))
# object_json_repr = models.TextField(null=True, blank=True, verbose_name=_('Object JSON representation'))
# changed_fields = models.TextField(null=True, blank=True, verbose_name=_('Changed fields'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True,
# blank=True, on_delete=models.SET_NULL,
# db_constraint=False, verbose_name=_('User'))
# user_pk_as_string = models.CharField(max_length=255, null=True, blank=True,
# help_text=_('String version of the user pk'), verbose_name=_('User PK as string'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# def is_create(self):
# return self.CREATE == self.event_type
#
# def is_update(self):
# return self.UPDATE == self.event_type
#
# def is_delete(self):
# return self.DELETE == self.event_type
#
# class Meta:
# verbose_name = _('CRUD event')
# verbose_name_plural = _('CRUD events')
# ordering = ['-datetime']
# index_together = ['object_id', 'content_type', ]
#
# class RequestEvent(models.Model):
# url = models.CharField(null=False, db_index=True, max_length=254, verbose_name=_('URL'))
# method = models.CharField(max_length=20, null=False, db_index=True, verbose_name=_('Method'))
# query_string = models.TextField(null=True, verbose_name=_('Query string'))
# user = models.ForeignKey(settings.AUTH_USER_MODEL, null=True, blank=True,
# on_delete=models.SET_NULL, db_constraint=False,
# verbose_name=_('User'))
# remote_ip = models.CharField(max_length=50, null=True, db_index=True, verbose_name=_('Remote IP'))
# datetime = models.DateTimeField(auto_now_add=True, verbose_name=_('Date time'))
#
# class Meta:
# verbose_name = _('request event')
# verbose_name_plural = _('request events')
# ordering = ['-datetime']
#
# Path: easyaudit/middleware/easyaudit.py
# def set_current_user(user):
# try:
# _thread_locals.request.user = user
# except AttributeError:
# request = MockRequest(user=user)
# _thread_locals.request = request
#
# def clear_request():
# try:
# del _thread_locals.request
# except AttributeError:
# pass
. Output only the next line. | crud_event_qs = CRUDEvent.objects.filter(object_id=obj.id, content_type=ContentType.objects.get_for_model(obj)) |
Given the following code snippet before the placeholder: <|code_start|> bash_command += " ".join(cls.extra_compile_args)
bash_command += " -ptx"
if cls.use_fast_math:
bash_command += " --use_fast_math"
for include_path in cls._program_directories:
if os.path.exists(include_path):
bash_command += " -I=" + include_path
bash_command += " " + source_path
bash_command += " -o=" + output_ptx_path
logger.debug("Executing: {0}".format(bash_command))
try:
check_call(shlex.split(bash_command))
except CalledProcessError as e:
logger.error(e)
if not os.path.exists(output_ptx_path):
logger.error("Could not compile {0}".format(source_path))
raise RuntimeError("Could not compile {0}".format(source_path))
else:
os.chmod(output_ptx_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
else:
logger.debug("No compiling required for {0}".format(source_path))
is_compiled = False
return output_ptx_path, is_compiled
@classmethod
def compile_all_directories(cls, source_extension='.cu'):
for program_dir in cls._program_directories:
<|code_end|>
, predict the next line using imports from the current file:
import logging
import re
import os
import sys
import shlex
import fnmatch
from stat import S_IRUSR, S_IWUSR, S_IRGRP, S_IWGRP, S_IROTH, S_IWOTH, S_IXUSR, S_IXGRP, S_IXOTH
from subprocess import check_call, CalledProcessError
from pyoptix.utils import glob_recursive, find_sub_path
from configparser import ConfigParser
from ConfigParser import SafeConfigParser as ConfigParser
and context including class names, function names, and sometimes code from other files:
# Path: pyoptix/utils.py
# def glob_recursive(path, pattern):
# matches = []
# for dirpath, dirnames, filenames in os.walk(path):
# for filename in fnmatch.filter(filenames, pattern):
# matches.append(os.path.join(dirpath, filename))
# return matches
#
# def find_sub_path(sub_path, search_paths):
# import os.path
#
# for search_path in search_paths:
# path = os.path.join(search_path, sub_path)
# if os.path.exists(path):
# return path
#
# raise ValueError('Sub-path not found in searched paths: {0}'.format(sub_path))
. Output only the next line. | for program_path in glob_recursive(program_dir, '*' + source_extension): |
Next line prediction: <|code_start|> is_compiled = False
return output_ptx_path, is_compiled
@classmethod
def compile_all_directories(cls, source_extension='.cu'):
for program_dir in cls._program_directories:
for program_path in glob_recursive(program_dir, '*' + source_extension):
Compiler.compile(os.path.abspath(program_path))
@classmethod
def clean(cls):
if os.path.exists(cls.output_path):
for dirpath, dirnames, filenames in os.walk(cls.output_path):
for filename in fnmatch.filter(filenames, '*.ptx'):
os.remove(os.path.join(dirpath, filename))
@staticmethod
def is_ptx(file_path):
return os.path.splitext(file_path)[1].lower() == '.ptx'
@staticmethod
def get_ptx_name(file_path):
return '%s.ptx' % file_path.replace(os.sep, '_')
@classmethod
def get_abs_program_path(cls, file_path):
if os.path.exists(file_path):
return file_path
else:
<|code_end|>
. Use current file imports:
(import logging
import re
import os
import sys
import shlex
import fnmatch
from stat import S_IRUSR, S_IWUSR, S_IRGRP, S_IWGRP, S_IROTH, S_IWOTH, S_IXUSR, S_IXGRP, S_IXOTH
from subprocess import check_call, CalledProcessError
from pyoptix.utils import glob_recursive, find_sub_path
from configparser import ConfigParser
from ConfigParser import SafeConfigParser as ConfigParser)
and context including class names, function names, or small code snippets from other files:
# Path: pyoptix/utils.py
# def glob_recursive(path, pattern):
# matches = []
# for dirpath, dirnames, filenames in os.walk(path):
# for filename in fnmatch.filter(filenames, pattern):
# matches.append(os.path.join(dirpath, filename))
# return matches
#
# def find_sub_path(sub_path, search_paths):
# import os.path
#
# for search_path in search_paths:
# path = os.path.join(search_path, sub_path)
# if os.path.exists(path):
# return path
#
# raise ValueError('Sub-path not found in searched paths: {0}'.format(sub_path))
. Output only the next line. | abs_path = find_sub_path(file_path, cls._program_directories) |
Predict the next line for this snippet: <|code_start|>
elif optix_has_type:
# OPTION 2: OptiX variable has a type but value is not a known OptiX object.
# Try to form a numpy array from value that is compatible with the variable type.
try:
dtype, shape = get_dtype_from_object_type(self.type)
if dtype is None or shape is None:
raise ValueError()
value = numpy.array(value, dtype=dtype)
if len(value.shape) == 0:
value = value.reshape(1)
if value.shape != shape:
raise TypeError("Array shape does not match to the shape of {0}.".format(self.type))
self._native.set_from_array(value, self.type)
self._value = value
except (ValueError, AttributeError):
raise TypeError("Variable type is {0}, but {1} was given".format(self.type, type(value)))
elif isinstance(value, numpy.ndarray) and not optix_has_type:
# OPTION 3: OptiX variable type is unknown or it is user-type, but the value is a numpy array.
# Use ndarray's dtype to determine variable type
if len(value.shape) == 0:
value = value.reshape(1)
<|code_end|>
with the help of current file imports:
import numpy
from pyoptix.enums import ObjectType, get_object_type_from_dtype, get_dtype_from_object_type, \
get_object_type_from_pyoptix_class
and context from other files:
# Path: pyoptix/enums.py
# class ObjectType:
# unknown = RTobjecttype.RT_OBJECTTYPE_UNKNOWN
# group = RTobjecttype.RT_OBJECTTYPE_GROUP
# geometry_group = RTobjecttype.RT_OBJECTTYPE_GEOMETRY_GROUP
# transform = RTobjecttype.RT_OBJECTTYPE_TRANSFORM
# selector = RTobjecttype.RT_OBJECTTYPE_SELECTOR
# geometry_instance = RTobjecttype.RT_OBJECTTYPE_GEOMETRY_INSTANCE
# buffer = RTobjecttype.RT_OBJECTTYPE_BUFFER
# texture_sampler = RTobjecttype.RT_OBJECTTYPE_TEXTURE_SAMPLER
# object = RTobjecttype.RT_OBJECTTYPE_OBJECT
# matrix2x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x2
# matrix2x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x3
# matrix2x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x4
# matrix3x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x2
# matrix3x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x3
# matrix3x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x4
# matrix4x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x2
# matrix4x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x3
# matrix4x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x4
# float = RTobjecttype.RT_OBJECTTYPE_FLOAT
# float2 = RTobjecttype.RT_OBJECTTYPE_FLOAT2
# float3 = RTobjecttype.RT_OBJECTTYPE_FLOAT3
# float4 = RTobjecttype.RT_OBJECTTYPE_FLOAT4
# int = RTobjecttype.RT_OBJECTTYPE_INT
# int2 = RTobjecttype.RT_OBJECTTYPE_INT2
# int3 = RTobjecttype.RT_OBJECTTYPE_INT3
# int4 = RTobjecttype.RT_OBJECTTYPE_INT4
# unsigned_int = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT
# unsigned_int2 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT2
# unsigned_int3 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT3
# unsigned_int4 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT4
# user = RTobjecttype.RT_OBJECTTYPE_USER
# program = RTobjecttype.RT_OBJECTTYPE_PROGRAM
#
# def get_object_type_from_dtype(dtype, shape):
# if dtype in DTYPE_SHAPE_TO_OBJECT_TYPE and shape in DTYPE_SHAPE_TO_OBJECT_TYPE[dtype]:
# return DTYPE_SHAPE_TO_OBJECT_TYPE[dtype][shape]
# else:
# return DTYPE_SHAPE_TO_OBJECT_TYPE['default']
#
# def get_dtype_from_object_type(object_type):
# if object_type in OBJECT_TYPE_TO_DTYPE_SHAPE:
# return OBJECT_TYPE_TO_DTYPE_SHAPE[object_type]
# else:
# return None, None
#
# def get_object_type_from_pyoptix_class(instance):
# try:
# if instance.__class__.__name__ in PYOPTIX_CLASS_TO_OBJECT_TYPE:
# return PYOPTIX_CLASS_TO_OBJECT_TYPE[instance.__class__.__name__]
# else:
# for base in instance.__class__.__bases__:
# if base.__name__ in PYOPTIX_CLASS_TO_OBJECT_TYPE:
# return PYOPTIX_CLASS_TO_OBJECT_TYPE[base.__name__]
# return PYOPTIX_CLASS_TO_OBJECT_TYPE['default']
# except Exception:
# return None
, which may contain function names, class names, or code. Output only the next line. | object_type = get_object_type_from_dtype(value.dtype, value.shape) |
Given the following code snippet before the placeholder: <|code_start|> def annotation(self):
return self._native.annotation
@property
def nbytes(self):
return self._native.nbytes
@property
def value(self):
return self._value
@value.setter
def value(self, value):
optix_has_type = self.type != ObjectType.unknown and self.type != ObjectType.user
class_object_type = get_object_type_from_pyoptix_class(value)
if class_object_type:
# OPTION 1: value is a known OptiX object like GeometryGroup, Buffer etc.
# do a preliminary check on type right now so it won't fail in device-compile time
if optix_has_type and self.type != class_object_type and self.type != ObjectType.object:
raise TypeError("Variable type is {0}, but {1} was given".format(self.type, type(value)))
# call the respective set function of the optix type of the variable
getattr(self._native, OBJECT_TYPE_TO_SET_FUNCTION[class_object_type])(value._native)
self._value = value
elif optix_has_type:
# OPTION 2: OptiX variable has a type but value is not a known OptiX object.
# Try to form a numpy array from value that is compatible with the variable type.
try:
<|code_end|>
, predict the next line using imports from the current file:
import numpy
from pyoptix.enums import ObjectType, get_object_type_from_dtype, get_dtype_from_object_type, \
get_object_type_from_pyoptix_class
and context including class names, function names, and sometimes code from other files:
# Path: pyoptix/enums.py
# class ObjectType:
# unknown = RTobjecttype.RT_OBJECTTYPE_UNKNOWN
# group = RTobjecttype.RT_OBJECTTYPE_GROUP
# geometry_group = RTobjecttype.RT_OBJECTTYPE_GEOMETRY_GROUP
# transform = RTobjecttype.RT_OBJECTTYPE_TRANSFORM
# selector = RTobjecttype.RT_OBJECTTYPE_SELECTOR
# geometry_instance = RTobjecttype.RT_OBJECTTYPE_GEOMETRY_INSTANCE
# buffer = RTobjecttype.RT_OBJECTTYPE_BUFFER
# texture_sampler = RTobjecttype.RT_OBJECTTYPE_TEXTURE_SAMPLER
# object = RTobjecttype.RT_OBJECTTYPE_OBJECT
# matrix2x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x2
# matrix2x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x3
# matrix2x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x4
# matrix3x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x2
# matrix3x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x3
# matrix3x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x4
# matrix4x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x2
# matrix4x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x3
# matrix4x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x4
# float = RTobjecttype.RT_OBJECTTYPE_FLOAT
# float2 = RTobjecttype.RT_OBJECTTYPE_FLOAT2
# float3 = RTobjecttype.RT_OBJECTTYPE_FLOAT3
# float4 = RTobjecttype.RT_OBJECTTYPE_FLOAT4
# int = RTobjecttype.RT_OBJECTTYPE_INT
# int2 = RTobjecttype.RT_OBJECTTYPE_INT2
# int3 = RTobjecttype.RT_OBJECTTYPE_INT3
# int4 = RTobjecttype.RT_OBJECTTYPE_INT4
# unsigned_int = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT
# unsigned_int2 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT2
# unsigned_int3 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT3
# unsigned_int4 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT4
# user = RTobjecttype.RT_OBJECTTYPE_USER
# program = RTobjecttype.RT_OBJECTTYPE_PROGRAM
#
# def get_object_type_from_dtype(dtype, shape):
# if dtype in DTYPE_SHAPE_TO_OBJECT_TYPE and shape in DTYPE_SHAPE_TO_OBJECT_TYPE[dtype]:
# return DTYPE_SHAPE_TO_OBJECT_TYPE[dtype][shape]
# else:
# return DTYPE_SHAPE_TO_OBJECT_TYPE['default']
#
# def get_dtype_from_object_type(object_type):
# if object_type in OBJECT_TYPE_TO_DTYPE_SHAPE:
# return OBJECT_TYPE_TO_DTYPE_SHAPE[object_type]
# else:
# return None, None
#
# def get_object_type_from_pyoptix_class(instance):
# try:
# if instance.__class__.__name__ in PYOPTIX_CLASS_TO_OBJECT_TYPE:
# return PYOPTIX_CLASS_TO_OBJECT_TYPE[instance.__class__.__name__]
# else:
# for base in instance.__class__.__bases__:
# if base.__name__ in PYOPTIX_CLASS_TO_OBJECT_TYPE:
# return PYOPTIX_CLASS_TO_OBJECT_TYPE[base.__name__]
# return PYOPTIX_CLASS_TO_OBJECT_TYPE['default']
# except Exception:
# return None
. Output only the next line. | dtype, shape = get_dtype_from_object_type(self.type) |
Given snippet: <|code_start|>
class Variable(object):
def __init__(self, wrapped_variable):
self._native = wrapped_variable
self._value = None
@property
def name(self):
return self._native.name
@property
def type(self):
return self._native.type
@property
def annotation(self):
return self._native.annotation
@property
def nbytes(self):
return self._native.nbytes
@property
def value(self):
return self._value
@value.setter
def value(self, value):
optix_has_type = self.type != ObjectType.unknown and self.type != ObjectType.user
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy
from pyoptix.enums import ObjectType, get_object_type_from_dtype, get_dtype_from_object_type, \
get_object_type_from_pyoptix_class
and context:
# Path: pyoptix/enums.py
# class ObjectType:
# unknown = RTobjecttype.RT_OBJECTTYPE_UNKNOWN
# group = RTobjecttype.RT_OBJECTTYPE_GROUP
# geometry_group = RTobjecttype.RT_OBJECTTYPE_GEOMETRY_GROUP
# transform = RTobjecttype.RT_OBJECTTYPE_TRANSFORM
# selector = RTobjecttype.RT_OBJECTTYPE_SELECTOR
# geometry_instance = RTobjecttype.RT_OBJECTTYPE_GEOMETRY_INSTANCE
# buffer = RTobjecttype.RT_OBJECTTYPE_BUFFER
# texture_sampler = RTobjecttype.RT_OBJECTTYPE_TEXTURE_SAMPLER
# object = RTobjecttype.RT_OBJECTTYPE_OBJECT
# matrix2x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x2
# matrix2x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x3
# matrix2x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT2x4
# matrix3x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x2
# matrix3x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x3
# matrix3x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT3x4
# matrix4x2 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x2
# matrix4x3 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x3
# matrix4x4 = RTobjecttype.RT_OBJECTTYPE_MATRIX_FLOAT4x4
# float = RTobjecttype.RT_OBJECTTYPE_FLOAT
# float2 = RTobjecttype.RT_OBJECTTYPE_FLOAT2
# float3 = RTobjecttype.RT_OBJECTTYPE_FLOAT3
# float4 = RTobjecttype.RT_OBJECTTYPE_FLOAT4
# int = RTobjecttype.RT_OBJECTTYPE_INT
# int2 = RTobjecttype.RT_OBJECTTYPE_INT2
# int3 = RTobjecttype.RT_OBJECTTYPE_INT3
# int4 = RTobjecttype.RT_OBJECTTYPE_INT4
# unsigned_int = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT
# unsigned_int2 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT2
# unsigned_int3 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT3
# unsigned_int4 = RTobjecttype.RT_OBJECTTYPE_UNSIGNED_INT4
# user = RTobjecttype.RT_OBJECTTYPE_USER
# program = RTobjecttype.RT_OBJECTTYPE_PROGRAM
#
# def get_object_type_from_dtype(dtype, shape):
# if dtype in DTYPE_SHAPE_TO_OBJECT_TYPE and shape in DTYPE_SHAPE_TO_OBJECT_TYPE[dtype]:
# return DTYPE_SHAPE_TO_OBJECT_TYPE[dtype][shape]
# else:
# return DTYPE_SHAPE_TO_OBJECT_TYPE['default']
#
# def get_dtype_from_object_type(object_type):
# if object_type in OBJECT_TYPE_TO_DTYPE_SHAPE:
# return OBJECT_TYPE_TO_DTYPE_SHAPE[object_type]
# else:
# return None, None
#
# def get_object_type_from_pyoptix_class(instance):
# try:
# if instance.__class__.__name__ in PYOPTIX_CLASS_TO_OBJECT_TYPE:
# return PYOPTIX_CLASS_TO_OBJECT_TYPE[instance.__class__.__name__]
# else:
# for base in instance.__class__.__bases__:
# if base.__name__ in PYOPTIX_CLASS_TO_OBJECT_TYPE:
# return PYOPTIX_CLASS_TO_OBJECT_TYPE[base.__name__]
# return PYOPTIX_CLASS_TO_OBJECT_TYPE['default']
# except Exception:
# return None
which might include code, classes, or functions. Output only the next line. | class_object_type = get_object_type_from_pyoptix_class(value) |
Predict the next line for this snippet: <|code_start|> if not isinstance(stack_size_bytes, int) or stack_size_bytes < 0:
raise TypeError('Stack size is the number of bytes that must be a positive integer')
self._native.set_stack_size(stack_size_bytes)
def get_available_devices_count(self):
return self._native.get_available_devices_count()
def get_device_name(self, device_id):
return self._native.get_device_name(device_id)
def get_device_compute_capability(self, device_id):
return self._native.get_device_compute_capability(device_id)
def get_enabled_device_count(self):
return self._native.get_enabled_device_count()
def get_enabled_devices(self):
return self._native.get_enabled_devices()
def set_devices(self, devices):
self._native.set_devices(devices)
def get_used_host_memory(self):
return self._native.get_used_host_memory()
def get_available_device_memory(self, device_id):
return self._native.get_available_device_memory(device_id)
def get_exception_enabled(self, exception_type):
<|code_end|>
with the help of current file imports:
import weakref
import atexit
from pyoptix._driver import NativeContextWrapper
from pyoptix.enums import ExceptionType
from pyoptix.mixins.scoped import ScopedObject
and context from other files:
# Path: pyoptix/enums.py
# class ExceptionType:
# program_id_invalid = RTexception.RT_EXCEPTION_PROGRAM_ID_INVALID
# texture_id_invalid = RTexception.RT_EXCEPTION_TEXTURE_ID_INVALID
# buffer_id_invalid = RTexception.RT_EXCEPTION_BUFFER_ID_INVALID
# index_out_of_bounds = RTexception.RT_EXCEPTION_INDEX_OUT_OF_BOUNDS
# stack_overflow = RTexception.RT_EXCEPTION_STACK_OVERFLOW
# buffer_index_out_of_bounds = RTexception.RT_EXCEPTION_BUFFER_INDEX_OUT_OF_BOUNDS
# invalid_ray = RTexception.RT_EXCEPTION_INVALID_RAY
# internal_error = RTexception.RT_EXCEPTION_INTERNAL_ERROR
# user = RTexception.RT_EXCEPTION_USER
# all = RTexception.RT_EXCEPTION_ALL
#
# Path: pyoptix/mixins/scoped.py
# class ScopedObject(DestroyableObject):
# def __init__(self, native):
# DestroyableObject.__init__(self, native)
# self._variables = {}
#
# def __setitem__(self, key, value):
# from pyoptix.variable import Variable
#
# variable_wrapper = self._safe_native.query_variable(key)
# declared = False
#
# if variable_wrapper is None:
# variable_wrapper = self._safe_native.declare_variable(key)
# declared = True
#
# try:
# optix_variable = Variable(variable_wrapper)
# optix_variable.value = value
# self._variables[key] = optix_variable
# except Exception as e:
# if declared:
# self._safe_native.remove_variable(variable_wrapper)
# raise e
#
# def __getitem__(self, key):
# return self._variables[key].value
#
# def __len__(self):
# return len(self._variables)
#
# def __delitem__(self, key):
# wrapped_variable = self._safe_native.query_variable(key)
# if not wrapped_variable.is_valid():
# raise ValueError("Variable not found")
#
# self._safe_native.remove_variable(wrapped_variable)
# del self._variables[key]
#
# def __contains__(self, item):
# return item in self._variables
, which may contain function names, class names, or code. Output only the next line. | if not isinstance(exception_type, ExceptionType): |
Here is a snippet: <|code_start|>
class TextureSampler(HasContextMixin, DestroyableObject, BindlessMixin):
def __init__(self, buffer, wrap_mode=None, indexing_mode=None,
read_mode=None, filter_mode=None, max_anisotropy=1):
HasContextMixin.__init__(self, current_context())
DestroyableObject.__init__(self, self._safe_context._create_texture_sampler())
BindlessMixin.__init__(self)
self._buffer = None
self._filtering_mode_minification = None
self._filtering_mode_magnification = None
self._filtering_mode_mipmapping = None
if indexing_mode is not None:
self.set_indexing_mode(indexing_mode)
if wrap_mode is not None:
self.set_wrap_mode(0, wrap_mode)
self.set_wrap_mode(1, wrap_mode)
self.set_wrap_mode(2, wrap_mode)
if read_mode is not None:
self.set_read_mode(read_mode)
if filter_mode is not None:
if OPTIX_VERSION >= 3090 and buffer.get_mip_level_count() > 1:
self.set_filtering_modes(filter_mode, filter_mode, filter_mode)
else:
<|code_end|>
. Write the next line using the current file imports:
from pyoptix._driver import OPTIX_VERSION
from pyoptix.enums import FilterMode, convert_filtering_mode, convert_wrap_mode, convert_read_mode, \
convert_indexing_mode
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context from other files:
# Path: pyoptix/enums.py
# class FilterMode:
# nearest = RTfiltermode.RT_FILTER_NEAREST
# linear = RTfiltermode.RT_FILTER_LINEAR
# none = RTfiltermode.RT_FILTER_NONE
#
# def convert_filtering_mode(string):
# if isinstance(string, str) and string.lower() in FILTERING_STRING_TO_OPTIX_ENUM:
# return FILTERING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_wrap_mode(string):
# if isinstance(string, str) and string.lower() in WRAP_STRING_TO_OPTIX_ENUM:
# return WRAP_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_read_mode(string):
# if isinstance(string, str) and string.lower() in READ_STRING_TO_OPTIX_ENUM:
# return READ_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_indexing_mode(string):
# if isinstance(string, str) and string.lower() in INDEXING_STRING_TO_OPTIX_ENUM:
# return INDEXING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
, which may include functions, classes, or code. Output only the next line. | self.set_filtering_modes(filter_mode, filter_mode, FilterMode.none) |
Given the code snippet: <|code_start|> if filter_mode is not None:
if OPTIX_VERSION >= 3090 and buffer.get_mip_level_count() > 1:
self.set_filtering_modes(filter_mode, filter_mode, filter_mode)
else:
self.set_filtering_modes(filter_mode, filter_mode, FilterMode.none)
self._safe_native.set_max_anisotropy(max_anisotropy)
if OPTIX_VERSION < 3090:
# required with OptiX < 3.9.0
self._safe_native.set_mip_level_count(1)
self._safe_native.set_array_size(1)
self.set_buffer(0, 0, buffer)
@property
def id(self):
return self.get_id()
def get_id(self):
return self._safe_native.get_id()
def set_buffer(self, texture_array_idx, mip_level, buffer):
self._buffer = buffer
self._safe_native.set_buffer(texture_array_idx, mip_level, buffer._safe_native)
def get_buffer(self):
return self._buffer
def set_filtering_modes(self, minification=None, magnification=None, mipmapping=None):
<|code_end|>
, generate the next line using the imports in this file:
from pyoptix._driver import OPTIX_VERSION
from pyoptix.enums import FilterMode, convert_filtering_mode, convert_wrap_mode, convert_read_mode, \
convert_indexing_mode
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context (functions, classes, or occasionally code) from other files:
# Path: pyoptix/enums.py
# class FilterMode:
# nearest = RTfiltermode.RT_FILTER_NEAREST
# linear = RTfiltermode.RT_FILTER_LINEAR
# none = RTfiltermode.RT_FILTER_NONE
#
# def convert_filtering_mode(string):
# if isinstance(string, str) and string.lower() in FILTERING_STRING_TO_OPTIX_ENUM:
# return FILTERING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_wrap_mode(string):
# if isinstance(string, str) and string.lower() in WRAP_STRING_TO_OPTIX_ENUM:
# return WRAP_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_read_mode(string):
# if isinstance(string, str) and string.lower() in READ_STRING_TO_OPTIX_ENUM:
# return READ_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_indexing_mode(string):
# if isinstance(string, str) and string.lower() in INDEXING_STRING_TO_OPTIX_ENUM:
# return INDEXING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | minification = convert_filtering_mode(minification) |
Here is a snippet: <|code_start|> self._buffer = buffer
self._safe_native.set_buffer(texture_array_idx, mip_level, buffer._safe_native)
def get_buffer(self):
return self._buffer
def set_filtering_modes(self, minification=None, magnification=None, mipmapping=None):
minification = convert_filtering_mode(minification)
magnification = convert_filtering_mode(magnification)
mipmapping = convert_filtering_mode(mipmapping)
if minification is None:
minification = FilterMode.none
if magnification is None:
magnification = FilterMode.none
if mipmapping is None:
mipmapping = FilterMode.none
self._filtering_mode_minification = minification
self._filtering_mode_magnification = magnification
self._filtering_mode_mipmapping = mipmapping
self._safe_native.set_filtering_modes(minification, magnification, mipmapping)
def get_filtering_modes(self):
return self._filtering_mode_minification, self._filtering_mode_magnification, self._filtering_mode_mipmapping
def set_wrap_mode(self, dim, mode):
<|code_end|>
. Write the next line using the current file imports:
from pyoptix._driver import OPTIX_VERSION
from pyoptix.enums import FilterMode, convert_filtering_mode, convert_wrap_mode, convert_read_mode, \
convert_indexing_mode
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context from other files:
# Path: pyoptix/enums.py
# class FilterMode:
# nearest = RTfiltermode.RT_FILTER_NEAREST
# linear = RTfiltermode.RT_FILTER_LINEAR
# none = RTfiltermode.RT_FILTER_NONE
#
# def convert_filtering_mode(string):
# if isinstance(string, str) and string.lower() in FILTERING_STRING_TO_OPTIX_ENUM:
# return FILTERING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_wrap_mode(string):
# if isinstance(string, str) and string.lower() in WRAP_STRING_TO_OPTIX_ENUM:
# return WRAP_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_read_mode(string):
# if isinstance(string, str) and string.lower() in READ_STRING_TO_OPTIX_ENUM:
# return READ_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_indexing_mode(string):
# if isinstance(string, str) and string.lower() in INDEXING_STRING_TO_OPTIX_ENUM:
# return INDEXING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
, which may include functions, classes, or code. Output only the next line. | mode = convert_wrap_mode(mode) |
Predict the next line after this snippet: <|code_start|> minification = convert_filtering_mode(minification)
magnification = convert_filtering_mode(magnification)
mipmapping = convert_filtering_mode(mipmapping)
if minification is None:
minification = FilterMode.none
if magnification is None:
magnification = FilterMode.none
if mipmapping is None:
mipmapping = FilterMode.none
self._filtering_mode_minification = minification
self._filtering_mode_magnification = magnification
self._filtering_mode_mipmapping = mipmapping
self._safe_native.set_filtering_modes(minification, magnification, mipmapping)
def get_filtering_modes(self):
return self._filtering_mode_minification, self._filtering_mode_magnification, self._filtering_mode_mipmapping
def set_wrap_mode(self, dim, mode):
mode = convert_wrap_mode(mode)
self._safe_native.set_wrap_mode(dim, mode)
def get_wrap_mode(self):
return self._safe_native.get_wrap_mode()
def set_read_mode(self, mode):
<|code_end|>
using the current file's imports:
from pyoptix._driver import OPTIX_VERSION
from pyoptix.enums import FilterMode, convert_filtering_mode, convert_wrap_mode, convert_read_mode, \
convert_indexing_mode
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and any relevant context from other files:
# Path: pyoptix/enums.py
# class FilterMode:
# nearest = RTfiltermode.RT_FILTER_NEAREST
# linear = RTfiltermode.RT_FILTER_LINEAR
# none = RTfiltermode.RT_FILTER_NONE
#
# def convert_filtering_mode(string):
# if isinstance(string, str) and string.lower() in FILTERING_STRING_TO_OPTIX_ENUM:
# return FILTERING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_wrap_mode(string):
# if isinstance(string, str) and string.lower() in WRAP_STRING_TO_OPTIX_ENUM:
# return WRAP_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_read_mode(string):
# if isinstance(string, str) and string.lower() in READ_STRING_TO_OPTIX_ENUM:
# return READ_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_indexing_mode(string):
# if isinstance(string, str) and string.lower() in INDEXING_STRING_TO_OPTIX_ENUM:
# return INDEXING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | mode = convert_read_mode(mode) |
Given the code snippet: <|code_start|> if magnification is None:
magnification = FilterMode.none
if mipmapping is None:
mipmapping = FilterMode.none
self._filtering_mode_minification = minification
self._filtering_mode_magnification = magnification
self._filtering_mode_mipmapping = mipmapping
self._safe_native.set_filtering_modes(minification, magnification, mipmapping)
def get_filtering_modes(self):
return self._filtering_mode_minification, self._filtering_mode_magnification, self._filtering_mode_mipmapping
def set_wrap_mode(self, dim, mode):
mode = convert_wrap_mode(mode)
self._safe_native.set_wrap_mode(dim, mode)
def get_wrap_mode(self):
return self._safe_native.get_wrap_mode()
def set_read_mode(self, mode):
mode = convert_read_mode(mode)
self._safe_native.set_read_mode(mode)
def get_read_mode(self):
return self._safe_native.get_read_mode()
def set_indexing_mode(self, mode):
<|code_end|>
, generate the next line using the imports in this file:
from pyoptix._driver import OPTIX_VERSION
from pyoptix.enums import FilterMode, convert_filtering_mode, convert_wrap_mode, convert_read_mode, \
convert_indexing_mode
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context (functions, classes, or occasionally code) from other files:
# Path: pyoptix/enums.py
# class FilterMode:
# nearest = RTfiltermode.RT_FILTER_NEAREST
# linear = RTfiltermode.RT_FILTER_LINEAR
# none = RTfiltermode.RT_FILTER_NONE
#
# def convert_filtering_mode(string):
# if isinstance(string, str) and string.lower() in FILTERING_STRING_TO_OPTIX_ENUM:
# return FILTERING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_wrap_mode(string):
# if isinstance(string, str) and string.lower() in WRAP_STRING_TO_OPTIX_ENUM:
# return WRAP_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_read_mode(string):
# if isinstance(string, str) and string.lower() in READ_STRING_TO_OPTIX_ENUM:
# return READ_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_indexing_mode(string):
# if isinstance(string, str) and string.lower() in INDEXING_STRING_TO_OPTIX_ENUM:
# return INDEXING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | mode = convert_indexing_mode(mode) |
Based on the snippet: <|code_start|>
class TextureSampler(HasContextMixin, DestroyableObject, BindlessMixin):
def __init__(self, buffer, wrap_mode=None, indexing_mode=None,
read_mode=None, filter_mode=None, max_anisotropy=1):
<|code_end|>
, predict the immediate next line with the help of imports:
from pyoptix._driver import OPTIX_VERSION
from pyoptix.enums import FilterMode, convert_filtering_mode, convert_wrap_mode, convert_read_mode, \
convert_indexing_mode
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context (classes, functions, sometimes code) from other files:
# Path: pyoptix/enums.py
# class FilterMode:
# nearest = RTfiltermode.RT_FILTER_NEAREST
# linear = RTfiltermode.RT_FILTER_LINEAR
# none = RTfiltermode.RT_FILTER_NONE
#
# def convert_filtering_mode(string):
# if isinstance(string, str) and string.lower() in FILTERING_STRING_TO_OPTIX_ENUM:
# return FILTERING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_wrap_mode(string):
# if isinstance(string, str) and string.lower() in WRAP_STRING_TO_OPTIX_ENUM:
# return WRAP_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_read_mode(string):
# if isinstance(string, str) and string.lower() in READ_STRING_TO_OPTIX_ENUM:
# return READ_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# def convert_indexing_mode(string):
# if isinstance(string, str) and string.lower() in INDEXING_STRING_TO_OPTIX_ENUM:
# return INDEXING_STRING_TO_OPTIX_ENUM[string]
# else:
# return string
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | HasContextMixin.__init__(self, current_context()) |
Given the following code snippet before the placeholder: <|code_start|>
logger = logging.getLogger(__name__)
class EntryPoint(HasContextMixin):
__default_exception_program = None
@classmethod
def set_default_exception_program(cls, file_path, function_name):
cls.__default_exception_program = (file_path, function_name)
def __init__(self, ray_generation_program, exception_program=None, size=None):
<|code_end|>
, predict the next line using imports from the current file:
import logging
from pyoptix.context import current_context
from pyoptix.program import Program
from pyoptix.utils import is_2_string_tuple
from pyoptix.mixins.hascontext import HasContextMixin
and context including class names, function names, and sometimes code from other files:
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/program.py
# class Program(ScopedObject, HasContextMixin, BindlessMixin):
# dynamic_programs = False
#
# def __init__(self, file_path, function_name, output_ptx_name=None):
# HasContextMixin.__init__(self, current_context())
# self._function_name = function_name
#
# file_path = Compiler.get_abs_program_path(file_path)
#
# if Compiler.is_ptx(file_path):
# self._ptx_path = file_path
# else:
# # if not ptx, compile to ptx
# self._ptx_path, _ = Compiler.compile(file_path, output_ptx_name)
#
# # Create program object from compiled file
# ScopedObject.__init__(self, self._safe_context._create_program_from_file(self._ptx_path, self._function_name))
# BindlessMixin.__init__(self)
#
# self._safe_context.program_cache[(file_path, function_name)] = self
#
# @property
# def id(self):
# return self.get_id()
#
# @property
# def name(self):
# return "({0}, {1})".format(os.path.basename(self._ptx_path), self._function_name)
#
# @property
# def file_path(self):
# return self._ptx_path
#
# @property
# def function_name(self):
# return self._function_name
#
# def get_id(self):
# return self._safe_native.get_id()
#
# def validate(self):
# self._safe_native.validate()
#
# @classmethod
# def get_or_create(cls, file_path, function_name):
# file_path = Compiler.get_abs_program_path(file_path)
# cache_key = (file_path, function_name)
# context = current_context()
#
# if cache_key not in context.program_cache:
# # create new if it does not exist in cache
# context.program_cache[cache_key] = cls(file_path, function_name)
# elif not Compiler.is_ptx(file_path) and Program.dynamic_programs:
# # check if the source file was changed. it is compiled if it was changed
# ptx_path, is_compiled = Compiler.compile(file_path)
#
# # recreate program object if it was changed
# if is_compiled:
# context.program_cache[cache_key] = cls(ptx_path, function_name)
#
# return context.program_cache[cache_key]
#
# Path: pyoptix/utils.py
# def is_2_string_tuple(obj):
# return isinstance(obj, tuple) and len(obj) == 2 \
# and isinstance(obj[0], str) and isinstance(obj[1], str)
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | HasContextMixin.__init__(self, current_context()) |
Continue the code snippet: <|code_start|>
logger = logging.getLogger(__name__)
class EntryPoint(HasContextMixin):
__default_exception_program = None
@classmethod
def set_default_exception_program(cls, file_path, function_name):
cls.__default_exception_program = (file_path, function_name)
def __init__(self, ray_generation_program, exception_program=None, size=None):
HasContextMixin.__init__(self, current_context())
if is_2_string_tuple(ray_generation_program):
<|code_end|>
. Use current file imports:
import logging
from pyoptix.context import current_context
from pyoptix.program import Program
from pyoptix.utils import is_2_string_tuple
from pyoptix.mixins.hascontext import HasContextMixin
and context (classes, functions, or code) from other files:
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/program.py
# class Program(ScopedObject, HasContextMixin, BindlessMixin):
# dynamic_programs = False
#
# def __init__(self, file_path, function_name, output_ptx_name=None):
# HasContextMixin.__init__(self, current_context())
# self._function_name = function_name
#
# file_path = Compiler.get_abs_program_path(file_path)
#
# if Compiler.is_ptx(file_path):
# self._ptx_path = file_path
# else:
# # if not ptx, compile to ptx
# self._ptx_path, _ = Compiler.compile(file_path, output_ptx_name)
#
# # Create program object from compiled file
# ScopedObject.__init__(self, self._safe_context._create_program_from_file(self._ptx_path, self._function_name))
# BindlessMixin.__init__(self)
#
# self._safe_context.program_cache[(file_path, function_name)] = self
#
# @property
# def id(self):
# return self.get_id()
#
# @property
# def name(self):
# return "({0}, {1})".format(os.path.basename(self._ptx_path), self._function_name)
#
# @property
# def file_path(self):
# return self._ptx_path
#
# @property
# def function_name(self):
# return self._function_name
#
# def get_id(self):
# return self._safe_native.get_id()
#
# def validate(self):
# self._safe_native.validate()
#
# @classmethod
# def get_or_create(cls, file_path, function_name):
# file_path = Compiler.get_abs_program_path(file_path)
# cache_key = (file_path, function_name)
# context = current_context()
#
# if cache_key not in context.program_cache:
# # create new if it does not exist in cache
# context.program_cache[cache_key] = cls(file_path, function_name)
# elif not Compiler.is_ptx(file_path) and Program.dynamic_programs:
# # check if the source file was changed. it is compiled if it was changed
# ptx_path, is_compiled = Compiler.compile(file_path)
#
# # recreate program object if it was changed
# if is_compiled:
# context.program_cache[cache_key] = cls(ptx_path, function_name)
#
# return context.program_cache[cache_key]
#
# Path: pyoptix/utils.py
# def is_2_string_tuple(obj):
# return isinstance(obj, tuple) and len(obj) == 2 \
# and isinstance(obj[0], str) and isinstance(obj[1], str)
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | self.ray_generation_program = Program(*ray_generation_program) |
Predict the next line after this snippet: <|code_start|>
logger = logging.getLogger(__name__)
class EntryPoint(HasContextMixin):
__default_exception_program = None
@classmethod
def set_default_exception_program(cls, file_path, function_name):
cls.__default_exception_program = (file_path, function_name)
def __init__(self, ray_generation_program, exception_program=None, size=None):
HasContextMixin.__init__(self, current_context())
<|code_end|>
using the current file's imports:
import logging
from pyoptix.context import current_context
from pyoptix.program import Program
from pyoptix.utils import is_2_string_tuple
from pyoptix.mixins.hascontext import HasContextMixin
and any relevant context from other files:
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/program.py
# class Program(ScopedObject, HasContextMixin, BindlessMixin):
# dynamic_programs = False
#
# def __init__(self, file_path, function_name, output_ptx_name=None):
# HasContextMixin.__init__(self, current_context())
# self._function_name = function_name
#
# file_path = Compiler.get_abs_program_path(file_path)
#
# if Compiler.is_ptx(file_path):
# self._ptx_path = file_path
# else:
# # if not ptx, compile to ptx
# self._ptx_path, _ = Compiler.compile(file_path, output_ptx_name)
#
# # Create program object from compiled file
# ScopedObject.__init__(self, self._safe_context._create_program_from_file(self._ptx_path, self._function_name))
# BindlessMixin.__init__(self)
#
# self._safe_context.program_cache[(file_path, function_name)] = self
#
# @property
# def id(self):
# return self.get_id()
#
# @property
# def name(self):
# return "({0}, {1})".format(os.path.basename(self._ptx_path), self._function_name)
#
# @property
# def file_path(self):
# return self._ptx_path
#
# @property
# def function_name(self):
# return self._function_name
#
# def get_id(self):
# return self._safe_native.get_id()
#
# def validate(self):
# self._safe_native.validate()
#
# @classmethod
# def get_or_create(cls, file_path, function_name):
# file_path = Compiler.get_abs_program_path(file_path)
# cache_key = (file_path, function_name)
# context = current_context()
#
# if cache_key not in context.program_cache:
# # create new if it does not exist in cache
# context.program_cache[cache_key] = cls(file_path, function_name)
# elif not Compiler.is_ptx(file_path) and Program.dynamic_programs:
# # check if the source file was changed. it is compiled if it was changed
# ptx_path, is_compiled = Compiler.compile(file_path)
#
# # recreate program object if it was changed
# if is_compiled:
# context.program_cache[cache_key] = cls(ptx_path, function_name)
#
# return context.program_cache[cache_key]
#
# Path: pyoptix/utils.py
# def is_2_string_tuple(obj):
# return isinstance(obj, tuple) and len(obj) == 2 \
# and isinstance(obj[0], str) and isinstance(obj[1], str)
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | if is_2_string_tuple(ray_generation_program): |
Given the following code snippet before the placeholder: <|code_start|> def from_array(cls, array, dtype=None, buffer_type='io', drop_last_dim=False):
if not isinstance(array, numpy.ndarray):
try:
array = numpy.array(array, dtype=dtype)
except Exception as e:
raise TypeError('array parameter must be a numpy array or castable to numpy array')
instance = cls(buffer_type=buffer_type)
instance._restructure_and_copy_from_numpy_array(array, drop_last_dim)
return instance
def get_id(self):
return self._safe_native.get_id()
def mark_dirty(self):
self._safe_native.mark_dirty()
def get_element_size(self):
return self._safe_native.get_element_size()
def get_size(self):
return self._safe_native.get_size()
def get_size_in_bytes(self):
return self._safe_native.get_size_in_bytes()
def set_format(self, format=None, dtype=None, type_size=1):
_format = None
if format is not None:
<|code_end|>
, predict the next line using imports from the current file:
import numpy
from pyoptix.enums import Format, convert_buffer_type, get_format_from_dtype
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context including class names, function names, and sometimes code from other files:
# Path: pyoptix/enums.py
# class Format:
# unknown = RTformat.RT_FORMAT_UNKNOWN
# float = RTformat.RT_FORMAT_FLOAT
# float2 = RTformat.RT_FORMAT_FLOAT2
# float3 = RTformat.RT_FORMAT_FLOAT3
# float4 = RTformat.RT_FORMAT_FLOAT4
# byte = RTformat.RT_FORMAT_BYTE
# byte2 = RTformat.RT_FORMAT_BYTE2
# byte3 = RTformat.RT_FORMAT_BYTE3
# byte4 = RTformat.RT_FORMAT_BYTE4
# unsigned_byte = RTformat.RT_FORMAT_UNSIGNED_BYTE
# unsigned_byte2 = RTformat.RT_FORMAT_UNSIGNED_BYTE2
# unsigned_byte3 = RTformat.RT_FORMAT_UNSIGNED_BYTE3
# unsigned_byte4 = RTformat.RT_FORMAT_UNSIGNED_BYTE4
# short = RTformat.RT_FORMAT_SHORT
# short2 = RTformat.RT_FORMAT_SHORT2
# short3 = RTformat.RT_FORMAT_SHORT3
# short4 = RTformat.RT_FORMAT_SHORT4
# unsigned_short = RTformat.RT_FORMAT_UNSIGNED_SHORT
# unsigned_short2 = RTformat.RT_FORMAT_UNSIGNED_SHORT2
# unsigned_short3 = RTformat.RT_FORMAT_UNSIGNED_SHORT3
# unsigned_short4 = RTformat.RT_FORMAT_UNSIGNED_SHORT4
# int = RTformat.RT_FORMAT_INT
# int2 = RTformat.RT_FORMAT_INT2
# int3 = RTformat.RT_FORMAT_INT3
# int4 = RTformat.RT_FORMAT_INT4
# unsigned_int = RTformat.RT_FORMAT_UNSIGNED_INT
# unsigned_int2 = RTformat.RT_FORMAT_UNSIGNED_INT2
# unsigned_int3 = RTformat.RT_FORMAT_UNSIGNED_INT3
# unsigned_int4 = RTformat.RT_FORMAT_UNSIGNED_INT4
# user = RTformat.RT_FORMAT_USER
# buffer_id = RTformat.RT_FORMAT_BUFFER_ID
# program_id = RTformat.RT_FORMAT_PROGRAM_ID
#
# def convert_buffer_type(string):
# if isinstance(string, str) and string.lower() in BUFFER_STRING_TO_OPTIX_ENUM:
# return BUFFER_STRING_TO_OPTIX_ENUM[string]
# else:
# raise string
#
# def get_format_from_dtype(dtype, type_size):
# if dtype in DTYPE_TO_FORMAT and type_size in DTYPE_TO_FORMAT[dtype]:
# return DTYPE_TO_FORMAT[dtype][type_size]
# else:
# return DTYPE_TO_FORMAT['default']
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | if isinstance(format, Format): |
Given the following code snippet before the placeholder: <|code_start|>
class Buffer(HasContextMixin, DestroyableObject, BindlessMixin):
def __init__(self, buffer_type='io'):
HasContextMixin.__init__(self, current_context())
<|code_end|>
, predict the next line using imports from the current file:
import numpy
from pyoptix.enums import Format, convert_buffer_type, get_format_from_dtype
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context including class names, function names, and sometimes code from other files:
# Path: pyoptix/enums.py
# class Format:
# unknown = RTformat.RT_FORMAT_UNKNOWN
# float = RTformat.RT_FORMAT_FLOAT
# float2 = RTformat.RT_FORMAT_FLOAT2
# float3 = RTformat.RT_FORMAT_FLOAT3
# float4 = RTformat.RT_FORMAT_FLOAT4
# byte = RTformat.RT_FORMAT_BYTE
# byte2 = RTformat.RT_FORMAT_BYTE2
# byte3 = RTformat.RT_FORMAT_BYTE3
# byte4 = RTformat.RT_FORMAT_BYTE4
# unsigned_byte = RTformat.RT_FORMAT_UNSIGNED_BYTE
# unsigned_byte2 = RTformat.RT_FORMAT_UNSIGNED_BYTE2
# unsigned_byte3 = RTformat.RT_FORMAT_UNSIGNED_BYTE3
# unsigned_byte4 = RTformat.RT_FORMAT_UNSIGNED_BYTE4
# short = RTformat.RT_FORMAT_SHORT
# short2 = RTformat.RT_FORMAT_SHORT2
# short3 = RTformat.RT_FORMAT_SHORT3
# short4 = RTformat.RT_FORMAT_SHORT4
# unsigned_short = RTformat.RT_FORMAT_UNSIGNED_SHORT
# unsigned_short2 = RTformat.RT_FORMAT_UNSIGNED_SHORT2
# unsigned_short3 = RTformat.RT_FORMAT_UNSIGNED_SHORT3
# unsigned_short4 = RTformat.RT_FORMAT_UNSIGNED_SHORT4
# int = RTformat.RT_FORMAT_INT
# int2 = RTformat.RT_FORMAT_INT2
# int3 = RTformat.RT_FORMAT_INT3
# int4 = RTformat.RT_FORMAT_INT4
# unsigned_int = RTformat.RT_FORMAT_UNSIGNED_INT
# unsigned_int2 = RTformat.RT_FORMAT_UNSIGNED_INT2
# unsigned_int3 = RTformat.RT_FORMAT_UNSIGNED_INT3
# unsigned_int4 = RTformat.RT_FORMAT_UNSIGNED_INT4
# user = RTformat.RT_FORMAT_USER
# buffer_id = RTformat.RT_FORMAT_BUFFER_ID
# program_id = RTformat.RT_FORMAT_PROGRAM_ID
#
# def convert_buffer_type(string):
# if isinstance(string, str) and string.lower() in BUFFER_STRING_TO_OPTIX_ENUM:
# return BUFFER_STRING_TO_OPTIX_ENUM[string]
# else:
# raise string
#
# def get_format_from_dtype(dtype, type_size):
# if dtype in DTYPE_TO_FORMAT and type_size in DTYPE_TO_FORMAT[dtype]:
# return DTYPE_TO_FORMAT[dtype][type_size]
# else:
# return DTYPE_TO_FORMAT['default']
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
. Output only the next line. | DestroyableObject.__init__(self, self._safe_context._create_buffer(convert_buffer_type(buffer_type))) |
Given snippet: <|code_start|> instance = cls(buffer_type=buffer_type)
instance._restructure_and_copy_from_numpy_array(array, drop_last_dim)
return instance
def get_id(self):
return self._safe_native.get_id()
def mark_dirty(self):
self._safe_native.mark_dirty()
def get_element_size(self):
return self._safe_native.get_element_size()
def get_size(self):
return self._safe_native.get_size()
def get_size_in_bytes(self):
return self._safe_native.get_size_in_bytes()
def set_format(self, format=None, dtype=None, type_size=1):
_format = None
if format is not None:
if isinstance(format, Format):
_format = format
else:
raise ValueError('Invalid buffer format')
elif dtype is not None:
try:
dtype = numpy.dtype(dtype)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import numpy
from pyoptix.enums import Format, convert_buffer_type, get_format_from_dtype
from pyoptix.context import current_context
from pyoptix.mixins.bindless import BindlessMixin
from pyoptix.mixins.destroyable import DestroyableObject
from pyoptix.mixins.hascontext import HasContextMixin
and context:
# Path: pyoptix/enums.py
# class Format:
# unknown = RTformat.RT_FORMAT_UNKNOWN
# float = RTformat.RT_FORMAT_FLOAT
# float2 = RTformat.RT_FORMAT_FLOAT2
# float3 = RTformat.RT_FORMAT_FLOAT3
# float4 = RTformat.RT_FORMAT_FLOAT4
# byte = RTformat.RT_FORMAT_BYTE
# byte2 = RTformat.RT_FORMAT_BYTE2
# byte3 = RTformat.RT_FORMAT_BYTE3
# byte4 = RTformat.RT_FORMAT_BYTE4
# unsigned_byte = RTformat.RT_FORMAT_UNSIGNED_BYTE
# unsigned_byte2 = RTformat.RT_FORMAT_UNSIGNED_BYTE2
# unsigned_byte3 = RTformat.RT_FORMAT_UNSIGNED_BYTE3
# unsigned_byte4 = RTformat.RT_FORMAT_UNSIGNED_BYTE4
# short = RTformat.RT_FORMAT_SHORT
# short2 = RTformat.RT_FORMAT_SHORT2
# short3 = RTformat.RT_FORMAT_SHORT3
# short4 = RTformat.RT_FORMAT_SHORT4
# unsigned_short = RTformat.RT_FORMAT_UNSIGNED_SHORT
# unsigned_short2 = RTformat.RT_FORMAT_UNSIGNED_SHORT2
# unsigned_short3 = RTformat.RT_FORMAT_UNSIGNED_SHORT3
# unsigned_short4 = RTformat.RT_FORMAT_UNSIGNED_SHORT4
# int = RTformat.RT_FORMAT_INT
# int2 = RTformat.RT_FORMAT_INT2
# int3 = RTformat.RT_FORMAT_INT3
# int4 = RTformat.RT_FORMAT_INT4
# unsigned_int = RTformat.RT_FORMAT_UNSIGNED_INT
# unsigned_int2 = RTformat.RT_FORMAT_UNSIGNED_INT2
# unsigned_int3 = RTformat.RT_FORMAT_UNSIGNED_INT3
# unsigned_int4 = RTformat.RT_FORMAT_UNSIGNED_INT4
# user = RTformat.RT_FORMAT_USER
# buffer_id = RTformat.RT_FORMAT_BUFFER_ID
# program_id = RTformat.RT_FORMAT_PROGRAM_ID
#
# def convert_buffer_type(string):
# if isinstance(string, str) and string.lower() in BUFFER_STRING_TO_OPTIX_ENUM:
# return BUFFER_STRING_TO_OPTIX_ENUM[string]
# else:
# raise string
#
# def get_format_from_dtype(dtype, type_size):
# if dtype in DTYPE_TO_FORMAT and type_size in DTYPE_TO_FORMAT[dtype]:
# return DTYPE_TO_FORMAT[dtype][type_size]
# else:
# return DTYPE_TO_FORMAT['default']
#
# Path: pyoptix/context.py
# def current_context():
# return _context_stack[-1]
#
# Path: pyoptix/mixins/bindless.py
# class BindlessMixin(object):
# def __init__(self):
# self._bindless = False
#
# @property
# def bindless(self):
# return self._bindless
#
# @bindless.setter
# def bindless(self, value):
# value = bool(value)
# self._safe_native.auto_destroy = not value
# self._bindless = value
#
# Path: pyoptix/mixins/destroyable.py
# class DestroyableObject(object):
# def __init__(self, native):
# self._native = native
#
# @property
# def _safe_native(self):
# if not self._native.is_destroyed:
# return self._native
# else:
# raise RuntimeError('Underlying OptiX object was destroyed before.')
#
# Path: pyoptix/mixins/hascontext.py
# class HasContextMixin(object):
# def __init__(self, context):
# self._context_ref = weakref.ref(context)
#
# @property
# def _safe_context(self):
# ctx = self._context_ref()
# if ctx is not None:
# return ctx
# else:
# raise RuntimeError('Context of this object is no longer valid')
which might include code, classes, or functions. Output only the next line. | _format = get_format_from_dtype(dtype, type_size) |
Given snippet: <|code_start|>
class DoesNotExistError(LookupError):
pass
class NonUniqueError(LookupError):
pass
class Model(object):
_conn = sqlite3.connect('ncssmurder.db', isolation_level=None)
_table = None
@classmethod
def _sql(cls, query, args=()):
args = tuple(args)
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import sqlite3
from tornado.ncss import ncssbook_log
and context:
# Path: tornado/ncss.py
# class Server:
# class Handler(tornado.web.RequestHandler):
# def __init__(self, *, hostname='', port=8888, static_path='static'):
# def register(self, url_pattern, handler, *, delete=None, get=None, patch=None, post=None, put=None, url_name=None, write_error=None, **kwargs):
# def delete(self, *args, **kwargs):
# def get(self, *args, **kwargs):
# def patch(self, *args, **kwargs):
# def post(self, *args, **kwargs):
# def put(self, *args, **kwargs):
# def get_field(self, name, default=None, strip=True):
# def get_fields(self, strip=True):
# def get_file(self, name, default=None):
# def get_files(self, name, default=None):
# def write_error(self, status_code, **kwargs):
# def app(self, **kwargs):
# def loop(self):
# def run(self):
which might include code, classes, or functions. Output only the next line. | ncssbook_log.debug('sql query=%r args=%r', query, args) |
Predict the next line after this snippet: <|code_start|>'''
Unit tests for the gbdxtools.BrowseImage class
See tests/readme.md for more about tests
'''
class BrowseImageTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.gbdx = mockable_interface()
@gbdx_vcr.use_cassette('tests/unit/cassettes/test_browse_image.yaml')
def test_browse_image(self):
<|code_end|>
using the current file's imports:
import unittest
from gbdxtools.images.browse_image import BrowseImage
from helpers import mockable_interface, gbdx_vcr, WV02_CATID
and any relevant context from other files:
# Path: gbdxtools/images/browse_image.py
# class BrowseImage(object):
# """
# Image class for fetching and spatially indexing an image's browse image (low res previews)
#
# Args:
# catalog_id (str): the catalog id for the browse image
# bbox (list): the bounding box in WGS84 coords for spatial indexing
# Returns:
# BrowseImage (object)
# """
# def __init__(self, catalog_id, bbox=None):
# self._interface = Auth()
# self.catalog_id = catalog_id
# self._get_image()
# self.metadata = self._get_metadata()
# self.shape = self.image.shape
# self.geom = self._get_geometry()
# self.xmin, self.ymin, self.xmax, self.ymax = self.geom.bounds
# self.cell_width = (self.xmax - self.xmin)/self.shape[1]
# self.cell_height = (self.ymax - self.ymin)/self.shape[0]
# self.bbox = bbox
#
# if self.bbox is not None:
# # find which cells intersect the bbox
# bbox_xmin, bbox_ymin, bbox_xmax, bbox_ymax = self.bbox
# window_xmin = int(np.floor((bbox_xmin - self.xmin)/self.cell_width))
# window_xmax = int(np.ceil((bbox_xmax - self.xmin)/self.cell_width))
# window_ymax = self.shape[0]-int(np.floor((bbox_ymin - self.ymin)/self.cell_height))
# window_ymin = self.shape[0]-int(np.ceil((bbox_ymax - self.ymin)/self.cell_height))
# self.window = ((window_ymin, window_ymax), (window_xmin, window_xmax))
# else:
# self.window = None
#
#
# def _get_image(self):
# url = 'https://api.discover.digitalglobe.com/show?id={}'.format(self.catalog_id)
# self.image = imread(url)
#
# def rgb(self):
# return self.read()
#
# def _get_metadata(self):
# url = 'https://geobigdata.io/catalog/v2/record/{}'.format(self.catalog_id)
# response = self._interface.gbdx_connection.get(url)
# response.raise_for_status()
# return response.json()
#
# def _get_geometry(self):
# if 'footprintWkt' in self.metadata['properties'].keys():
# geom = loads(self.metadata['properties']['footprintWkt'])
# elif 'geometry' in self.metadata.keys():
# geom = shape(self.metadata['geometry'])
# else:
# raise ValueError("Invalid metadata returned by metadata service. Cannot create BrowseImage")
# return geom
#
# def read(self):
# if self.window is None:
# return self.image
# else:
# (miny, maxy), (minx, maxx) = self.window
# return self.image[miny:maxy,minx:maxx,:]
#
# def plot(self, w=10, h=10, title='', fontsize=24):
# assert has_matplotlib, 'Matplotlib is required to plot images'
# plt.figure(figsize=(w, h))
# sp = plt.subplot(1, 1, 1)
# plt.axis('off')
# sp.set_title(title, fontsize=fontsize)
# plt.imshow(self.rgb())
# plt.show()
. Output only the next line. | img = BrowseImage(WV02_CATID) |
Using the snippet: <|code_start|>
rda = RDA()
class DemDriver(RDADaskImageDriver):
image_option_support = ["proj", "bbox"]
__image_option_defaults__ = {"bbox": None}
<|code_end|>
, determine the next line of code. You have imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.rda.util import reproject_params
from gbdxtools.rda.interface import RDA
from shapely.geometry import box
and context (class names, function names, or code) available:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/rda/util.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["Source pixel-to-world transform"] = None
# _params["DestSRSCode"] = proj
# _params["Dest pixel-to-world transform"] = None
# return _params
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
. Output only the next line. | class DemImage(RDABaseImage): |
Using the snippet: <|code_start|>
class DemImage(RDABaseImage):
''' Image class for Digital Elevation Model (DEM) data from the NED/SRTM dataset.
This class has no Catalog IDs and is created by passing an AOI. It shares most of the same methods as CatalogImage objects.
Args:
aoi (list): list of coordinate in BBOX format
proj (str): (optional) EPSG string of projection reproject to. Native projection is "EPSG:4326" (WGS84)
Example:
>>> dem = DemImage(aoi=[5.279, 60.358, 5.402, 60.419])'''
__Driver__ = DemDriver
__rda_id__ = "dgdem-v20180406-DEFLATED-ca4649c5acb"
def __post_new_hook__(self, **kwargs):
self = self.aoi(**kwargs)
if self.rda.metadata["image"]["minX"] == -1:
return self[:, :, 1:-1]
return self
@classmethod
def _build_graph(cls, aoi, proj="EPSG:4326", **kwargs):
bucket = kwargs.get("bucket", "idaho-dems-2018")
imageId = kwargs.get("imageId", "dgdem-v20180406-DEFLATED-ca4649c5acb")
wkt = box(*aoi).wkt
dem = rda.IdahoTemplate(bucketName=bucket, imageId=imageId, objectStore="S3", geospatialWKT=str(wkt), nodeId="GeospatialCrop")
if proj is not "EPSG:4326":
<|code_end|>
, determine the next line of code. You have imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.rda.util import reproject_params
from gbdxtools.rda.interface import RDA
from shapely.geometry import box
and context (class names, function names, or code) available:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/rda/util.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["Source pixel-to-world transform"] = None
# _params["DestSRSCode"] = proj
# _params["Dest pixel-to-world transform"] = None
# return _params
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
. Output only the next line. | dem = dem(nodeId="Reproject", **reproject_params(proj)) |
Predict the next line for this snippet: <|code_start|>rda = RDA()
band_types = {
'MS': 'multispectral',
'ms': 'multispectral',
'Panchromatic': 'panchromatic',
'Pan': 'panchromatic',
'pan': 'panchromatic',
'thermal': 'thermal'
}
class IkonosDriver(RDADaskImageDriver):
image_option_support = ["proj", "gsd", "band_type", "pansharpen"]
__image_option_defaults__ = {"gsd": None, "band_type": "MS", "pansharpen": False}
<|code_end|>
with the help of current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.rda.interface import RDA
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.util import ortho_params
and context from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/util.py
# def ortho_params(proj, gsd=None):
# params = {}
# if gsd is not None:
# params["Requested GSD"] = str(gsd)
# params["Resampling Kernel"] = "INTERP_BILINEAR"
# params["Grid Size"] = 10
# if proj is not None:
# params["Output Coordinate Reference System"] = proj
# params["Sensor Model"] = None
# params["Elevation Source"] = ""
# params["Output Pixel to World Transform"] = ""
# return params
, which may contain function names, class names, or code. Output only the next line. | class IkonosImage(RDABaseImage): |
Given the following code snippet before the placeholder: <|code_start|>rda = RDA()
band_types = {
'MS': 'multispectral',
'ms': 'multispectral',
'Panchromatic': 'panchromatic',
'Pan': 'panchromatic',
'pan': 'panchromatic',
'thermal': 'thermal'
}
<|code_end|>
, predict the next line using imports from the current file:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.rda.interface import RDA
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.util import ortho_params
and context including class names, function names, and sometimes code from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/util.py
# def ortho_params(proj, gsd=None):
# params = {}
# if gsd is not None:
# params["Requested GSD"] = str(gsd)
# params["Resampling Kernel"] = "INTERP_BILINEAR"
# params["Grid Size"] = 10
# if proj is not None:
# params["Output Coordinate Reference System"] = proj
# params["Sensor Model"] = None
# params["Elevation Source"] = ""
# params["Output Pixel to World Transform"] = ""
# return params
. Output only the next line. | class IkonosDriver(RDADaskImageDriver): |
Continue the code snippet: <|code_start|>
class IkonosImage(RDABaseImage):
"""
Dask based access to ikonos images backed by RDA Graphs.
"""
__Driver__ = IkonosDriver
@property
def _record(self):
return self.__rda_id__
@property
def _spec(self):
return self.options["band_type"]
@property
def _gsd(self):
return self.options["gsd"]
@property
def _rgb_bands(self):
return [2,1,0]
@classmethod
def _build_graph(cls, record, band_type="MS", proj="EPSG:4326", gsd=None, **kwargs):
spec = band_types[band_type]
prefix = record['properties']['attributes']['bucketPrefix']
bucket = record['properties']['attributes']['bucketName']
pansharpen = kwargs.get('pansharpen', False)
if spec == "thermal" and pansharpen:
<|code_end|>
. Use current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.rda.interface import RDA
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.util import ortho_params
and context (classes, functions, or code) from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/util.py
# def ortho_params(proj, gsd=None):
# params = {}
# if gsd is not None:
# params["Requested GSD"] = str(gsd)
# params["Resampling Kernel"] = "INTERP_BILINEAR"
# params["Grid Size"] = 10
# if proj is not None:
# params["Output Coordinate Reference System"] = proj
# params["Sensor Model"] = None
# params["Elevation Source"] = ""
# params["Output Pixel to World Transform"] = ""
# return params
. Output only the next line. | raise IncompatibleOptions('Cannot generate a pansharpened thermal Ikonos image') |
Using the snippet: <|code_start|> """
Dask based access to ikonos images backed by RDA Graphs.
"""
__Driver__ = IkonosDriver
@property
def _record(self):
return self.__rda_id__
@property
def _spec(self):
return self.options["band_type"]
@property
def _gsd(self):
return self.options["gsd"]
@property
def _rgb_bands(self):
return [2,1,0]
@classmethod
def _build_graph(cls, record, band_type="MS", proj="EPSG:4326", gsd=None, **kwargs):
spec = band_types[band_type]
prefix = record['properties']['attributes']['bucketPrefix']
bucket = record['properties']['attributes']['bucketName']
pansharpen = kwargs.get('pansharpen', False)
if spec == "thermal" and pansharpen:
raise IncompatibleOptions('Cannot generate a pansharpened thermal Ikonos image')
<|code_end|>
, determine the next line of code. You have imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.rda.interface import RDA
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.util import ortho_params
and context (class names, function names, or code) available:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/util.py
# def ortho_params(proj, gsd=None):
# params = {}
# if gsd is not None:
# params["Requested GSD"] = str(gsd)
# params["Resampling Kernel"] = "INTERP_BILINEAR"
# params["Grid Size"] = 10
# if proj is not None:
# params["Output Coordinate Reference System"] = proj
# params["Sensor Model"] = None
# params["Elevation Source"] = ""
# params["Output Pixel to World Transform"] = ""
# return params
. Output only the next line. | params = ortho_params(proj, gsd=gsd) |
Next line prediction: <|code_start|>"""
GBDX Ordering Interface.
Contact: kostas.stamatiou@digitalglobe.com
"""
class Ordering(object):
def __init__(self, **kwargs):
'''Instantiate the GBDX Ordering Interface
Returns:
An instance of the Ordering interface.
'''
<|code_end|>
. Use current file imports:
(from builtins import zip
from builtins import object
from gbdxtools.auth import Auth
import requests
import json)
and context including class names, function names, or small code snippets from other files:
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | interface = Auth(**kwargs) |
Continue the code snippet: <|code_start|>
class VectorStyle(object):
""" Allows setting parameters common to all layer styles
Args:
opacity (float/StyleExpression/list): the opacity of the circles (will accept either a float value, a
StyleExpression, or a list representing a mapbox-gl conditional expression)
color (str/StyleExpression/list): the color of the circles (will accept either an an rgb/hex/html-color-name
string, a StyleExpression, or a list representing a mapbox-gl conditional expression)
translate: (float): the offset from the original vector location at which the vector will be rendered
"""
def __init__(self, opacity=1.0, color='rgb(255,0,0)', translate=None, **kwargs):
self.opacity = opacity
self.color = color
self.translate = translate
self.type = None
@staticmethod
def get_style_value(style_value):
"""
Decides which value will be added to a style's 'paint' configuration
Args:
style_value: the value set on the style instance
Returns:
a value suitable for inclusion in a 'paint' configuration
"""
<|code_end|>
. Use current file imports:
from gbdxtools.vector_style_expressions import StyleExpression
and context (classes, functions, or code) from other files:
# Path: gbdxtools/vector_style_expressions.py
# class StyleExpression(object):
# """ Represents a mapbox-gl conditional for styling, knowing how
# to turn itself into the appropriate javascript for use in
# styling a layer.
#
# Returns:
# list of values for mapbox-gl conditional
# """
# def _expression_def(self):
# """ Creates the list values which will be passed as a mapbox-gl
# conditional expression.
# """
# raise NotImplementedError()
#
# @property
# def expression(self):
# return self._expression_def()
. Output only the next line. | if isinstance(style_value, StyleExpression): |
Based on the snippet: <|code_start|> try:
except:
print("IPython is required to produce maps.")
return
assert api_key is not None, "No Mapbox API Key found. You can either pass in a key or set the MAPBOX_API_KEY environment variable. Use outside of GBDX Notebooks requires a MapBox API key, sign up for free at https://www.mapbox.com/pricing/"
if features is None and query is not None:
wkt = box(*bbox).wkt
features = self.query(wkt, query, index=None)
elif features is None and query is None and image is None:
print('Must provide either a list of features or a query or an image')
return
if styles is not None and not isinstance(styles, list):
styles = [styles]
geojson = {"type":"FeatureCollection", "features": features}
if center is None and features is not None:
union = cascaded_union([shape(f['geometry']) for f in features])
lon, lat = union.centroid.coords[0]
elif center is None and image is not None:
try:
lon, lat = shape(image).centroid.coords[0]
except:
lon, lat = box(*image_bounds).centroid.coords[0]
else:
lat, lon = center
map_id = "map_{}".format(str(int(time.time())))
<|code_end|>
, predict the immediate next line with the help of imports:
from string import Template
from imageio import imsave
from io import BytesIO
from shapely.wkt import loads as load_wkt
from collections import OrderedDict
from shapely.ops import cascaded_union
from shapely.geometry import shape, box, mapping
from gbdxtools.vector_layers import VectorGeojsonLayer, VectorTileLayer, \
ImageLayer
from gbdxtools.map_templates import BaseTemplate
from gbdxtools.auth import Auth
from IPython.display import display
from IPython.display import display
import base64
import dask.array as da
import requests
import json, time, os
and context (classes, functions, sometimes code) from other files:
# Path: gbdxtools/vector_layers.py
# class VectorGeojsonLayer(VectorLayer):
# """ Represents a vector layer created from a geojson source
#
# Args:
# geojson (dict): a list of geojson features to render
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, geojson, **kwargs):
# super(VectorGeojsonLayer, self).__init__(**kwargs)
# self.geojson = geojson
#
# def _datasource_def(self):
# return {'type': 'geojson', 'data': self.geojson}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'paint': style.paint()
# }
#
# class VectorTileLayer(VectorLayer):
# """ Represents a vector tile layer in a tile map
#
# Args:
# url (str): a vector tile url template
# source_name (str): the name of the source layer in the vector tiles
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, url=None, source_layer_name='GBDX_Task_Output', **kwargs):
# super(VectorTileLayer, self).__init__(**kwargs)
# self.url = url
# self.source_layer_name = source_layer_name
#
# def _datasource_def(self):
# return {'type': 'vector', 'tiles': [self.url]}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'source-layer': self.source_layer_name,
# 'paint': style.paint()
# }
#
# class ImageLayer(object):
# """ A layer for rendering images and image arrays to slippy maps
#
# Args:
# image (str): a vector tile url template
# coordinates: the coordinate bounds (list of polygon corners) for placing the image
#
# Returns:
# An string of the layer definition
# """
# def __new__(self, image, coordinates):
# return json.dumps({
# "id": uuid.uuid4().hex,
# "type": "raster",
# "source": {
# "type": "image",
# "url": image,
# "coordinates": coordinates
# }
# })
#
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | map_data = VectorGeojsonLayer(geojson, styles=styles, **kwargs) |
Continue the code snippet: <|code_start|> r.raise_for_status()
return r.json(object_pairs_hook=OrderedDict)['aggregations']
def tilemap(self, query, styles={}, bbox=[-180,-90,180,90], zoom=16,
api_key=os.environ.get('MAPBOX_API_KEY', None),
image=None, image_bounds=None,
index="vector-user-provided", name="GBDX_Task_Output", **kwargs):
"""
Renders a mapbox gl map from a vector service query
"""
try:
except:
print("IPython is required to produce maps.")
return
assert api_key is not None, "No Mapbox API Key found. You can either pass in a token or set the MAPBOX_API_KEY environment variable."
wkt = box(*bbox).wkt
features = self.query(wkt, query, index=index)
union = cascaded_union([shape(f['geometry']) for f in features])
lon, lat = union.centroid.coords[0]
url = 'https://vector.geobigdata.io/insight-vector/api/mvt/{z}/{x}/{y}?';
url += 'q={}&index={}'.format(query, index);
if styles is not None and not isinstance(styles, list):
styles = [styles]
map_id = "map_{}".format(str(int(time.time())))
<|code_end|>
. Use current file imports:
from string import Template
from imageio import imsave
from io import BytesIO
from shapely.wkt import loads as load_wkt
from collections import OrderedDict
from shapely.ops import cascaded_union
from shapely.geometry import shape, box, mapping
from gbdxtools.vector_layers import VectorGeojsonLayer, VectorTileLayer, \
ImageLayer
from gbdxtools.map_templates import BaseTemplate
from gbdxtools.auth import Auth
from IPython.display import display
from IPython.display import display
import base64
import dask.array as da
import requests
import json, time, os
and context (classes, functions, or code) from other files:
# Path: gbdxtools/vector_layers.py
# class VectorGeojsonLayer(VectorLayer):
# """ Represents a vector layer created from a geojson source
#
# Args:
# geojson (dict): a list of geojson features to render
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, geojson, **kwargs):
# super(VectorGeojsonLayer, self).__init__(**kwargs)
# self.geojson = geojson
#
# def _datasource_def(self):
# return {'type': 'geojson', 'data': self.geojson}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'paint': style.paint()
# }
#
# class VectorTileLayer(VectorLayer):
# """ Represents a vector tile layer in a tile map
#
# Args:
# url (str): a vector tile url template
# source_name (str): the name of the source layer in the vector tiles
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, url=None, source_layer_name='GBDX_Task_Output', **kwargs):
# super(VectorTileLayer, self).__init__(**kwargs)
# self.url = url
# self.source_layer_name = source_layer_name
#
# def _datasource_def(self):
# return {'type': 'vector', 'tiles': [self.url]}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'source-layer': self.source_layer_name,
# 'paint': style.paint()
# }
#
# class ImageLayer(object):
# """ A layer for rendering images and image arrays to slippy maps
#
# Args:
# image (str): a vector tile url template
# coordinates: the coordinate bounds (list of polygon corners) for placing the image
#
# Returns:
# An string of the layer definition
# """
# def __new__(self, image, coordinates):
# return json.dumps({
# "id": uuid.uuid4().hex,
# "type": "raster",
# "source": {
# "type": "image",
# "url": image,
# "coordinates": coordinates
# }
# })
#
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | map_data = VectorTileLayer(url, source_name=name, styles=styles, **kwargs) |
Continue the code snippet: <|code_start|> map_id = "map_{}".format(str(int(time.time())))
map_data = VectorGeojsonLayer(geojson, styles=styles, **kwargs)
image_layer = self._build_image_layer(image, image_bounds, cmap)
template = BaseTemplate(map_id, **{
"lat": lat,
"lon": lon,
"zoom": zoom,
"datasource": json.dumps(map_data.datasource),
"layers": json.dumps(map_data.layers),
"image_layer": image_layer,
"mbkey": api_key,
"token": 'dummy'
})
template.inject()
def _build_image_layer(self, image, image_bounds, cmap='viridis'):
if image is not None:
if isinstance(image, da.Array):
if len(image.shape) == 2 or \
(image.shape[0] == 1 and len(image.shape) == 3):
arr = image.compute()
else:
arr = image.rgb()
coords = box(*image.bounds)
else:
assert image_bounds is not None, "Must pass image_bounds with ndarray images"
arr = image
coords = box(*image_bounds)
b64 = self._encode_image(arr, cmap)
<|code_end|>
. Use current file imports:
from string import Template
from imageio import imsave
from io import BytesIO
from shapely.wkt import loads as load_wkt
from collections import OrderedDict
from shapely.ops import cascaded_union
from shapely.geometry import shape, box, mapping
from gbdxtools.vector_layers import VectorGeojsonLayer, VectorTileLayer, \
ImageLayer
from gbdxtools.map_templates import BaseTemplate
from gbdxtools.auth import Auth
from IPython.display import display
from IPython.display import display
import base64
import dask.array as da
import requests
import json, time, os
and context (classes, functions, or code) from other files:
# Path: gbdxtools/vector_layers.py
# class VectorGeojsonLayer(VectorLayer):
# """ Represents a vector layer created from a geojson source
#
# Args:
# geojson (dict): a list of geojson features to render
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, geojson, **kwargs):
# super(VectorGeojsonLayer, self).__init__(**kwargs)
# self.geojson = geojson
#
# def _datasource_def(self):
# return {'type': 'geojson', 'data': self.geojson}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'paint': style.paint()
# }
#
# class VectorTileLayer(VectorLayer):
# """ Represents a vector tile layer in a tile map
#
# Args:
# url (str): a vector tile url template
# source_name (str): the name of the source layer in the vector tiles
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, url=None, source_layer_name='GBDX_Task_Output', **kwargs):
# super(VectorTileLayer, self).__init__(**kwargs)
# self.url = url
# self.source_layer_name = source_layer_name
#
# def _datasource_def(self):
# return {'type': 'vector', 'tiles': [self.url]}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'source-layer': self.source_layer_name,
# 'paint': style.paint()
# }
#
# class ImageLayer(object):
# """ A layer for rendering images and image arrays to slippy maps
#
# Args:
# image (str): a vector tile url template
# coordinates: the coordinate bounds (list of polygon corners) for placing the image
#
# Returns:
# An string of the layer definition
# """
# def __new__(self, image, coordinates):
# return json.dumps({
# "id": uuid.uuid4().hex,
# "type": "raster",
# "source": {
# "type": "image",
# "url": image,
# "coordinates": coordinates
# }
# })
#
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | return ImageLayer(b64, self._polygon_coords(coords)) |
Next line prediction: <|code_start|>"""
GBDX Vector Services Interface.
Contact: nate.ricklin@digitalglobe.com
"""
class Vectors(object):
default_index = 'vector-gbdx-alpha-catalog-v2-*'
def __init__(self, **kwargs):
''' Construct the Vectors interface class
Returns:
An instance of the Vectors interface class.
'''
<|code_end|>
. Use current file imports:
(from string import Template
from imageio import imsave
from io import BytesIO
from shapely.wkt import loads as load_wkt
from collections import OrderedDict
from shapely.ops import cascaded_union
from shapely.geometry import shape, box, mapping
from gbdxtools.vector_layers import VectorGeojsonLayer, VectorTileLayer, \
ImageLayer
from gbdxtools.map_templates import BaseTemplate
from gbdxtools.auth import Auth
from IPython.display import display
from IPython.display import display
import base64
import dask.array as da
import requests
import json, time, os)
and context including class names, function names, or small code snippets from other files:
# Path: gbdxtools/vector_layers.py
# class VectorGeojsonLayer(VectorLayer):
# """ Represents a vector layer created from a geojson source
#
# Args:
# geojson (dict): a list of geojson features to render
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, geojson, **kwargs):
# super(VectorGeojsonLayer, self).__init__(**kwargs)
# self.geojson = geojson
#
# def _datasource_def(self):
# return {'type': 'geojson', 'data': self.geojson}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'paint': style.paint()
# }
#
# class VectorTileLayer(VectorLayer):
# """ Represents a vector tile layer in a tile map
#
# Args:
# url (str): a vector tile url template
# source_name (str): the name of the source layer in the vector tiles
# styles (list): A list of style objects to be applied to the layer
# """
# def __init__(self, url=None, source_layer_name='GBDX_Task_Output', **kwargs):
# super(VectorTileLayer, self).__init__(**kwargs)
# self.url = url
# self.source_layer_name = source_layer_name
#
# def _datasource_def(self):
# return {'type': 'vector', 'tiles': [self.url]}
#
# def _layer_def(self, style):
# return {
# 'id': type(style).__name__, # TODO - make this unique in the various styles
# 'type': style.type,
# 'source': self.source_id,
# 'source-layer': self.source_layer_name,
# 'paint': style.paint()
# }
#
# class ImageLayer(object):
# """ A layer for rendering images and image arrays to slippy maps
#
# Args:
# image (str): a vector tile url template
# coordinates: the coordinate bounds (list of polygon corners) for placing the image
#
# Returns:
# An string of the layer definition
# """
# def __new__(self, image, coordinates):
# return json.dumps({
# "id": uuid.uuid4().hex,
# "type": "raster",
# "source": {
# "type": "image",
# "url": image,
# "coordinates": coordinates
# }
# })
#
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | interface = Auth(**kwargs) |
Given the code snippet: <|code_start|> raise KeyError('Unknown histogram parameter, use "equalize", "match", "minmax", or "ignore"')
def histogram_equalize(self, use_bands, **kwargs):
''' Equalize and the histogram and normalize value range
Equalization is on all three bands, not per-band'''
data = self._read(self[use_bands,...], **kwargs)
data = np.rollaxis(data.astype(np.float32), 0, 3)
flattened = data.flatten()
if 0 in data:
masked = np.ma.masked_values(data, 0).compressed()
image_histogram, bin_edges = np.histogram(masked, 256)
else:
image_histogram, bin_edges = np.histogram(flattened, 256)
bins = (bin_edges[:-1] + bin_edges[1:]) / 2.0
cdf = image_histogram.cumsum()
cdf = cdf / float(cdf[-1])
image_equalized = np.interp(flattened, bins, cdf).reshape(data.shape)
if 'stretch' in kwargs or 'gamma' in kwargs:
return self._histogram_stretch(image_equalized, **kwargs)
else:
return image_equalized
def histogram_match(self, use_bands, blm_source='browse', **kwargs):
''' Match the histogram to Browse imagery '''
assert has_rio, "To match image histograms please install rio_hist"
data = self._read(self[use_bands,...], **kwargs)
data = np.rollaxis(data.astype(np.float32), 0, 3)
if 0 in data:
data = np.ma.masked_values(data, 0)
bounds = self._reproject(box(*self.bounds), from_proj=self.proj, to_proj="EPSG:4326").bounds
<|code_end|>
, generate the next line using the imports in this file:
import os
import math
import mercantile
import numpy as np
from rio_hist.match import histogram_match as rio_match
from shapely.geometry import box, shape, mapping, asShape
from gbdxtools.deprecate import deprecation
from gbdxtools.images.browse_image import BrowseImage
from matplotlib import pyplot as plt
and context (functions, classes, or occasionally code) from other files:
# Path: gbdxtools/deprecate.py
# def deprecation(message):
# warnings.warn(message, GBDXDeprecation)
#
# Path: gbdxtools/images/browse_image.py
# class BrowseImage(object):
# """
# Image class for fetching and spatially indexing an image's browse image (low res previews)
#
# Args:
# catalog_id (str): the catalog id for the browse image
# bbox (list): the bounding box in WGS84 coords for spatial indexing
# Returns:
# BrowseImage (object)
# """
# def __init__(self, catalog_id, bbox=None):
# self._interface = Auth()
# self.catalog_id = catalog_id
# self._get_image()
# self.metadata = self._get_metadata()
# self.shape = self.image.shape
# self.geom = self._get_geometry()
# self.xmin, self.ymin, self.xmax, self.ymax = self.geom.bounds
# self.cell_width = (self.xmax - self.xmin)/self.shape[1]
# self.cell_height = (self.ymax - self.ymin)/self.shape[0]
# self.bbox = bbox
#
# if self.bbox is not None:
# # find which cells intersect the bbox
# bbox_xmin, bbox_ymin, bbox_xmax, bbox_ymax = self.bbox
# window_xmin = int(np.floor((bbox_xmin - self.xmin)/self.cell_width))
# window_xmax = int(np.ceil((bbox_xmax - self.xmin)/self.cell_width))
# window_ymax = self.shape[0]-int(np.floor((bbox_ymin - self.ymin)/self.cell_height))
# window_ymin = self.shape[0]-int(np.ceil((bbox_ymax - self.ymin)/self.cell_height))
# self.window = ((window_ymin, window_ymax), (window_xmin, window_xmax))
# else:
# self.window = None
#
#
# def _get_image(self):
# url = 'https://api.discover.digitalglobe.com/show?id={}'.format(self.catalog_id)
# self.image = imread(url)
#
# def rgb(self):
# return self.read()
#
# def _get_metadata(self):
# url = 'https://geobigdata.io/catalog/v2/record/{}'.format(self.catalog_id)
# response = self._interface.gbdx_connection.get(url)
# response.raise_for_status()
# return response.json()
#
# def _get_geometry(self):
# if 'footprintWkt' in self.metadata['properties'].keys():
# geom = loads(self.metadata['properties']['footprintWkt'])
# elif 'geometry' in self.metadata.keys():
# geom = shape(self.metadata['geometry'])
# else:
# raise ValueError("Invalid metadata returned by metadata service. Cannot create BrowseImage")
# return geom
#
# def read(self):
# if self.window is None:
# return self.image
# else:
# (miny, maxy), (minx, maxx) = self.window
# return self.image[miny:maxy,minx:maxx,:]
#
# def plot(self, w=10, h=10, title='', fontsize=24):
# assert has_matplotlib, 'Matplotlib is required to plot images'
# plt.figure(figsize=(w, h))
# sp = plt.subplot(1, 1, 1)
# plt.axis('off')
# sp.set_title(title, fontsize=fontsize)
# plt.imshow(self.rgb())
# plt.show()
. Output only the next line. | ref = BrowseImage(self.cat_id, bbox=bounds).read() |
Continue the code snippet: <|code_start|>
def expire_token(r, *args, **kw):
"""
Requests a new token if 401, retries request, mainly for auth v2 migration
:param r:
:param args:
:param kw:
:return:
"""
if r.status_code == 401:
try:
# remove hooks so it doesn't get into infinite loop
r.request.hooks = None
# expire the token
gbdx_auth.expire_token(token_to_expire=self.gbdx_connection.token,
config_file=kwargs.get('config_file'))
# re-init the session
self.gbdx_connection = gbdx_auth.get_session(kwargs.get('config_file'))
# make original request, triggers new token request first
return self.gbdx_connection.request(method=r.request.method, url=r.request.url)
except Exception as e:
r.request.hooks = None
print("Error expiring token from session, Reason {}".format(e))
if self.gbdx_connection is not None:
self.gbdx_connection.hooks['response'].append(expire_token)
# status_forcelist=[500, 502, 504]))
<|code_end|>
. Use current file imports:
import os
import logging
from requests.adapters import HTTPAdapter
from gbdx_auth import gbdx_auth
from gbdxtools.rda.graph import VIRTUAL_RDA_URL
and context (classes, functions, or code) from other files:
# Path: gbdxtools/rda/graph.py
# VIRTUAL_RDA_URL = os.environ.get("VIRTUAL_RDA_URL", "https://rda.geobigdata.io/v1")
. Output only the next line. | self.gbdx_connection.mount(VIRTUAL_RDA_URL, HTTPAdapter(max_retries=5)) |
Using the snippet: <|code_start|>"""
AnswerFactory Project and Recipe interfaces
Contact: nricklin@digitalglobe.com
Contact: mtrotter@digitalglobe.com
"""
class Recipe(object):
def __init__(self, **kwargs):
'''
Construct an instance of an AnswerFactory Recipe
Args:
**kwargs
Returns:
An instance of a Recipe.
'''
<|code_end|>
, determine the next line of code. You have imports:
import json
from gbdxtools.auth import Auth
and context (class names, function names, or code) available:
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | interface = Auth(**kwargs) |
Continue the code snippet: <|code_start|>rda = RDA()
band_types = {
'MS': 'multispectral',
'ms': 'multispectral',
'Panchromatic': 'panchromatic',
'Pan': 'panchromatic',
'pan': 'panchromatic',
'thermal': 'thermal'
}
class LandsatDriver(RDADaskImageDriver):
__default_options__ = {}
image_option_support = ["band_type", "proj", "pansharpen"]
__image_option_defaults__ = {"band_type": "MS", "proj": None, "pansharpen": False}
<|code_end|>
. Use current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.interface import RDA
and context (classes, functions, or code) from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
. Output only the next line. | class LandsatImage(RDABaseImage): |
Predict the next line for this snippet: <|code_start|>rda = RDA()
band_types = {
'MS': 'multispectral',
'ms': 'multispectral',
'Panchromatic': 'panchromatic',
'Pan': 'panchromatic',
'pan': 'panchromatic',
'thermal': 'thermal'
}
<|code_end|>
with the help of current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.interface import RDA
and context from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
, which may contain function names, class names, or code. Output only the next line. | class LandsatDriver(RDADaskImageDriver): |
Given the following code snippet before the placeholder: <|code_start|> return self.__rda_id__
@property
def _spec(self):
return self.options["band_type"]
@property
def _rgb_bands(self):
return [3,2,1]
@property
def _ndvi_bands(self):
return [4,3]
@property
def _ndwi_bands(self):
return[2,4]
@classmethod
def _build_graph(cls, _id, band_type="MS", proj=None, **kwargs):
spec = band_types[band_type]
pansharpen = kwargs.get('pansharpen', False)
if spec == "thermal" and pansharpen:
raise IncompatibleOptions('Cannot generate a pansharpened thermal Landsat image')
if pansharpen is True:
landsat = rda.LandsatPanSharpenTemplate(catalogIdMultispectral=_id, catalogIdPanchromatic=_id)
else:
landsat = rda.LandsatTemplate(catalogId=_id, productSpec=spec)
if proj is not None:
<|code_end|>
, predict the next line using imports from the current file:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.interface import RDA
and context including class names, function names, and sometimes code from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
. Output only the next line. | landsat = landsat(nodeId="Reproject", **reproject_params(proj)) |
Given snippet: <|code_start|> """
Dask based access to landsat image backed by rda Graphs.
"""
__Driver__ = LandsatDriver
@property
def _id(self):
return self.__rda_id__
@property
def _spec(self):
return self.options["band_type"]
@property
def _rgb_bands(self):
return [3,2,1]
@property
def _ndvi_bands(self):
return [4,3]
@property
def _ndwi_bands(self):
return[2,4]
@classmethod
def _build_graph(cls, _id, band_type="MS", proj=None, **kwargs):
spec = band_types[band_type]
pansharpen = kwargs.get('pansharpen', False)
if spec == "thermal" and pansharpen:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.error import IncompatibleOptions
from gbdxtools.rda.interface import RDA
and context:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/error.py
# class IncompatibleOptions(Exception):
# pass
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
which might include code, classes, or functions. Output only the next line. | raise IncompatibleOptions('Cannot generate a pansharpened thermal Landsat image') |
Here is a snippet: <|code_start|>rda = RDA()
class ModisDriver(RDADaskImageDriver):
image_option_support = ["proj"]
__image_option_defaults__ = {"proj": None}
<|code_end|>
. Write the next line using the current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.interface import RDA
and context from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
, which may include functions, classes, or code. Output only the next line. | class Modis(RDABaseImage): |
Here is a snippet: <|code_start|>class ModisDriver(RDADaskImageDriver):
image_option_support = ["proj"]
__image_option_defaults__ = {"proj": None}
class Modis(RDABaseImage):
"""
Dask based access to Modis images backed by rda Graphs.
Args:
catalog_id (str): The Catalog ID for the modis image.
"""
__Driver__ = ModisDriver
@property
def _id(self):
return self.__rda_id__
@property
def _rgb_bands(self):
return [1,4,3]
@property
def _ndvi_bands(self):
return [1,4]
@classmethod
def _build_graph(cls, cat_id, proj=None, **kwargs):
modis = rda.ModisTemplate(modisId=cat_id)
if proj is not None:
<|code_end|>
. Write the next line using the current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.interface import RDA
and context from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
, which may include functions, classes, or code. Output only the next line. | modis = modis(nodeId="Reproject", **reproject_params(proj)) |
Using the snippet: <|code_start|>
gbdx = gbdxtools.Interface()
# Let's look in colorado
colorado_aoi = "POLYGON((-108.89 40.87,-102.19 40.87,-102.19 37.03,-108.89 37.03,-108.89 40.87))"
# Let's limit our search to the OSM indexes
search_index = 'read-vector-osm-*'
# Let's find things that match 'transportation' somewhere in a text field
query = 'transportation'
# let's get 5 geohash buckets with the top 5 item_type values in each
<|code_end|>
, determine the next line of code. You have imports:
import gbdxtools
from gbdxtools.vectors import TermsAggDef, GeohashAggDef
and context (class names, function names, or code) available:
# Path: gbdxtools/vectors.py
# class TermsAggDef(FieldBasedAggDef):
#
# def __init__(self, field=None, **kwargs):
# super(TermsAggDef, self).__init__('terms', field, **kwargs)
#
# class GeohashAggDef(AggregationDef):
#
# def __init__(self, hash_length='3', **kwargs):
# super(GeohashAggDef, self).__init__('geohash', hash_length, **kwargs)
. Output only the next line. | child_agg = TermsAggDef('item_type') |
Based on the snippet: <|code_start|>
gbdx = gbdxtools.Interface()
# Let's look in colorado
colorado_aoi = "POLYGON((-108.89 40.87,-102.19 40.87,-102.19 37.03,-108.89 37.03,-108.89 40.87))"
# Let's limit our search to the OSM indexes
search_index = 'read-vector-osm-*'
# Let's find things that match 'transportation' somewhere in a text field
query = 'transportation'
# let's get 5 geohash buckets with the top 5 item_type values in each
child_agg = TermsAggDef('item_type')
<|code_end|>
, predict the immediate next line with the help of imports:
import gbdxtools
from gbdxtools.vectors import TermsAggDef, GeohashAggDef
and context (classes, functions, sometimes code) from other files:
# Path: gbdxtools/vectors.py
# class TermsAggDef(FieldBasedAggDef):
#
# def __init__(self, field=None, **kwargs):
# super(TermsAggDef, self).__init__('terms', field, **kwargs)
#
# class GeohashAggDef(AggregationDef):
#
# def __init__(self, hash_length='3', **kwargs):
# super(GeohashAggDef, self).__init__('geohash', hash_length, **kwargs)
. Output only the next line. | agg = GeohashAggDef('3', children=child_agg) |
Continue the code snippet: <|code_start|>"""
GBDX Catalog Interface.
Contact: nate.ricklin@digitalglobe.com
"""
class Catalog(object):
def __init__(self, **kwargs):
''' Construct the Catalog interface class
Returns:
An instance of the Catalog interface class.
'''
<|code_end|>
. Use current file imports:
import requests
import json
import datetime
from gbdxtools.auth import Auth
from gbdxtools.ordering import Ordering
and context (classes, functions, or code) from other files:
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
#
# Path: gbdxtools/ordering.py
# class Ordering(object):
#
# def __init__(self, **kwargs):
# '''Instantiate the GBDX Ordering Interface
#
# Returns:
# An instance of the Ordering interface.
# '''
# interface = Auth(**kwargs)
# self.base_url = '%s/orders/v2' % interface.root_url
# self.gbdx_connection = interface.gbdx_connection
# self.logger = interface.logger
#
#
# def order(self, image_catalog_ids, batch_size=100, callback=None):
# '''Orders images from GBDX.
#
# Args:
# image_catalog_ids (str or list): A single catalog id or a list of
# catalog ids.
# batch_size (int): The image_catalog_ids will be split into
# batches of batch_size. The ordering API max
# batch size is 100, if batch_size is greater
# than 100 it will be truncated.
# callback (str): A url to call when ordering is completed.
#
# Returns:
# order_ids (str or list): If one batch, returns a string. If more
# than one batch, returns a list of order ids,
# one for each batch.
# '''
# def _order_single_batch(url_, ids, results_list):
# data = json.dumps(ids) if callback is None else json.dumps({"acquisitionIds": ids, "callback": callback})
# r = self.gbdx_connection.post(url_, data=data)
# r.raise_for_status()
# order_id = r.json().get("order_id")
# if order_id:
# results_list.append(order_id)
#
# self.logger.debug('Place order')
# url = ('%s/order' if callback is None else '%s/ordercb') % self.base_url
#
# batch_size = min(100, batch_size)
#
# if not isinstance(image_catalog_ids, list):
# image_catalog_ids = [image_catalog_ids]
#
# sanitized_ids = list(set((id for id in (_id.strip() for _id in image_catalog_ids) if id)))
#
# res = []
# # Use itertool batch recipe
# acq_ids_by_batch = zip(*([iter(sanitized_ids)] * batch_size))
# for ids_batch in acq_ids_by_batch:
# _order_single_batch(url, ids_batch, res)
#
# # Order reminder
# remain_count = len(sanitized_ids) % batch_size
# if remain_count > 0:
# _order_single_batch(url, sanitized_ids[-remain_count:], res)
#
# if len(res) == 1:
# return res[0]
# elif len(res)>1:
# return res
#
# def status(self, order_id):
# '''Checks imagery order status. There can be more than one image per
# order and this function returns the status of all images
# within the order.
#
# Args:
# order_id (str): The id of the order placed.
#
# Returns:
# List of dictionaries, one per image. Each dictionary consists
# of the keys 'acquisition_id', 'location' and 'state'.
# '''
#
# self.logger.debug('Get status of order ' + order_id)
# url = '%(base_url)s/order/%(order_id)s' % {
# 'base_url': self.base_url, 'order_id': order_id
# }
# r = self.gbdx_connection.get(url)
# r.raise_for_status()
# return r.json().get("acquisitions", {})
#
# def heartbeat(self):
# '''
# Check the heartbeat of the ordering API
#
# Args: None
#
# Returns: True or False
# '''
# url = '%s/heartbeat' % self.base_url
# # Auth is not required to hit the heartbeat
# r = requests.get(url)
#
# try:
# return r.json() == "ok"
# except:
# return False
#
# def is_delivered(self, cat_id):
# '''
# Check to see if a CatID is delivered
#
# Args:
# cat_id(str): Catalog ID
#
# Returns:
# bool: if the Catalog ID has been delivered
# '''
#
# locations = self.location(cat_id)
# return locations['acquisitions'][0]['state'] == 'delivered'
#
# def location(self, image_catalog_ids, batch_size=100):
# def _process_single_batch(url_, ids, results_dict):
# query_string = 'acquisitionIds=[' + ','.join(['"{}"'.format(id_) for id_ in ids]) + ']'
# r = self.gbdx_connection.get(url_, params=query_string)
# r.raise_for_status()
# results_dict['acquisitions'].extend(r.json()['acquisitions'])
#
# url = '%s/location' % self.base_url
#
# batch_size = min(100, batch_size)
#
# if not isinstance(image_catalog_ids, list):
# image_catalog_ids = [image_catalog_ids]
#
# sanitized_ids = list(set((stripped_id for stripped_id in (_id.strip() for _id in image_catalog_ids) if stripped_id)))
#
# res = {'acquisitions': []}
# # Use itertool batch recipe
# acq_ids_by_batch = zip(*([iter(sanitized_ids)] * batch_size))
# for ids_batch in acq_ids_by_batch:
# _process_single_batch(url, ids_batch, res)
#
# # Process remainder
# remain_count = len(sanitized_ids) % batch_size
# if remain_count > 0:
# _process_single_batch(url, sanitized_ids[-remain_count:], res)
#
# return res
. Output only the next line. | interface = Auth(**kwargs) |
Here is a snippet: <|code_start|>
VIRTUAL_RDA_URL = os.environ.get("VIRTUAL_RDA_URL", "https://rda.geobigdata.io/v1")
@lru_cache()
def req_with_retries(conn, url, retries=5):
for i in range(retries):
try:
res = conn.get(url)
if res.status_code not in [502, 429]:
return res
elif res.status_code == 501:
raise Exception('501 Auth error')
except:
pass
time.sleep(0.5 * (i + 1))
raise Exception('RDA is overloaded')
def get_template_stats(conn, template_id, **kwargs):
qs = urlencode(kwargs)
url = "{}/template/{}/display_stats.json?{}".format(VIRTUAL_RDA_URL, template_id, qs)
req = req_with_retries(conn, url)
if req.status_code == 200:
return req.json()
else:
<|code_end|>
. Write the next line using the current file imports:
import os
import json
import time
from gbdxtools.rda.error import NotFound, BadRequest
from urllib.parse import urlencode
from functools import lru_cache
and context from other files:
# Path: gbdxtools/rda/error.py
# class NotFound(Exception):
# pass
#
# class BadRequest(Exception):
# pass
, which may include functions, classes, or code. Output only the next line. | raise NotFound("Could not fetch stats for template/args: {} / {}".format(template_id, kwargs)) |
Given snippet: <|code_start|>def _search_for_rda_template(conn, template_name):
"""
Searches for template by name, eventually RDA will have named templates and this method goes away.
:param conn:
:param template_name:
:return:
"""
url = "{}/template/metadata/search?free-text={}".format(VIRTUAL_RDA_URL, template_name)
req = req_with_retries(conn, url)
if req.status_code == 200:
request_json = req.json()
# make sure list is not empty
if request_json is not None:
# make sure list contains 1 entry
for template in request_json:
if template.get("name") == template_name:
# parse template Id
return template.get("templateId")
# if anything fails, raise as we should always get a template Id
raise Exception("Error fetching template Id")
def get_rda_template_metadata(conn, _id, **kwargs):
qs = urlencode(kwargs)
url = VIRTUAL_RDA_URL + "/template/{}/metadata?{}".format(_id, qs)
md_response = req_with_retries(conn, url)
if md_response.status_code != 200:
md_json = md_response.json()
if 'error' in md_json:
<|code_end|>
, continue by predicting the next line. Consider current file imports:
import os
import json
import time
from gbdxtools.rda.error import NotFound, BadRequest
from urllib.parse import urlencode
from functools import lru_cache
and context:
# Path: gbdxtools/rda/error.py
# class NotFound(Exception):
# pass
#
# class BadRequest(Exception):
# pass
which might include code, classes, or functions. Output only the next line. | raise BadRequest("RDA error: {}. RDA Graph: {}".format(md_json['error'], _id)) |
Based on the snippet: <|code_start|>try:
has_matplotlib = True
except ImportError:
has_matplotlib = False
class BrowseImage(object):
"""
Image class for fetching and spatially indexing an image's browse image (low res previews)
Args:
catalog_id (str): the catalog id for the browse image
bbox (list): the bounding box in WGS84 coords for spatial indexing
Returns:
BrowseImage (object)
"""
def __init__(self, catalog_id, bbox=None):
<|code_end|>
, predict the immediate next line with the help of imports:
import numpy as np
import matplotlib.pyplot as plt
from imageio import imread
from shapely.geometry import shape
from shapely.wkt import loads
from gbdxtools.auth import Auth
and context (classes, functions, sometimes code) from other files:
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | self._interface = Auth() |
Here is a snippet: <|code_start|>rda = RDA()
class Sentinel2Driver(RDADaskImageDriver):
image_option_support = ["spec", "proj"]
__image_option_defaults__ = {"spec": "10m", "proj": None}
<|code_end|>
. Write the next line using the current file imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.interface import RDA
and context from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
, which may include functions, classes, or code. Output only the next line. | class Sentinel2(RDABaseImage): |
Predict the next line after this snippet: <|code_start|> """
Dask based access to Sentinel2 images backed by rda Graphs.
Args:
prefix (str): The Sentinel data location from Catalog metadata item 'bucketPrefix'
spec (str): Sensor group to use, values are '10m' (default), '20m', and '60m'
proj (str): EPSG code for the resulting image, defaults to EPSG:4326 (WGS 84 Lat/Lon)
"""
__Driver__ = Sentinel2Driver
@property
def _id(self):
return self.__rda_id__
@property
def _spec(self):
return self.options["spec"]
@property
def _rgb_bands(self):
return [2,1,0]
@property
def _ndvi_bands(self):
return [1,3]
@classmethod
def _build_graph(cls, prefix, spec="10m", proj=None, **kwargs):
sentinel2 = rda.Sentinel2Template(sentinelId=prefix, sentinelProductSpec=spec, nodeId="Sentinel2Read")
if proj is not None:
<|code_end|>
using the current file's imports:
from gbdxtools.images.base import RDABaseImage
from gbdxtools.images.drivers import RDADaskImageDriver
from gbdxtools.images.util.image import reproject_params
from gbdxtools.rda.interface import RDA
and any relevant context from other files:
# Path: gbdxtools/images/base.py
# class RDABaseImage(RDAImage):
# __rda_id__ = None
# def __new__(cls, rda_id=None, **kwargs):
# cls = cls.__Driver__(rda_id=rda_id, **kwargs).drive(cls, **kwargs)
# self = super(RDABaseImage, cls).__new__(cls, cls.__driver__.payload, **kwargs)
# return self.__post_new_hook__(**kwargs)
#
# def __post_new_hook__(self, **kwargs):
# return self.aoi(**kwargs)
#
# @property
# def options(self):
# return self.__driver__.options
#
# @property
# def _graph(self):
# return self.__driver__.graph
#
# Path: gbdxtools/images/drivers/base.py
# class RDADaskImageDriver(RDADriverInterface, metaclass=OptionParserFactory):
# __default_options__ = RDA_DEFAULT_OPTIONS
# __image_option_defaults__ = {}
# image_option_support = []
#
# def __init__(self, rda_id=None, **kwargs):
# self.rda_id = rda_id
# options = kwargs.get("rda_options")
# if not options:
# options = self.parse_options(kwargs)
# options = self.configure_options(options._asdict())
# self._options = options
# self._graph = None
# self._payload = None
#
# def parse_options(self, inputs):
# options = self.parser(**{opt: inputs[opt] for opt in self.image_option_support if opt in inputs})
# return options
#
# @property
# def options(self):
# if not self._options:
# raise DriverConfigurationError("Image options not provided")
# if isinstance(self._options, dict):
# return self._options
# return self._options._asdict()
#
# @property
# def graph(self):
# if not self._graph:
# raise DriverConfigurationError("Image graph not configured")
# return self._graph
#
# @classmethod
# def configure_options(cls, options):
# return options
#
# @property
# def payload(self):
# return self.graph
#
# @payload.setter
# def payload(self, payload):
# self._payload = payload
#
# def build_payload(self, target):
# # build_graph should always return an rda graph / dask meta
# graph = target._build_graph(self.rda_id, **self.options)
# self._graph = graph
#
# def drive(self, target, **kwargs):
# if not self.rda_id:
# rda_id = getattr(target, "__rda_id__", None)
# if not rda_id:
# raise AttributeError("RDA Image ID not provided")
# self.rda_id = rda_id
# target.__driver__ = self
# target.__rda_id__ = self.rda_id
# target.__supported_options__ = self.image_option_support
# target.__default_options__ = self.default_options
# self.build_payload(target)
# return target
#
# Path: gbdxtools/images/util/image.py
# def reproject_params(proj):
# _params = {}
# if proj is not None:
# _params["SourceSRSCode"] = "EPSG:4326"
# _params["DestSRSCode"] = proj
# return _params
#
# Path: gbdxtools/rda/interface.py
# class RDA(object):
# def __getattr__(self, name, **kwargs):
# return Op(name=name, interface=Auth(), **kwargs)
. Output only the next line. | sentinel2 = sentinel2(nodeId="Reproject", **reproject_params(proj)) |
Predict the next line after this snippet: <|code_start|>"""
GBDX S3 Interface.
Contact: kostas.stamatiou@digitalglobe.com
"""
class S3(object):
def __init__(self, **kwargs):
'''Instantiate the s3 interface
Returns:
An instance of gbdxtools.S3.
'''
<|code_end|>
using the current file's imports:
import os
import boto3
from builtins import object
from gbdxtools.auth import Auth
and any relevant context from other files:
# Path: gbdxtools/auth.py
# def Auth(**kwargs):
# global auth
# if auth is None or len(kwargs) > 0:
# auth = _Auth(**kwargs)
# return auth
. Output only the next line. | interface = Auth(**kwargs) |
Continue the code snippet: <|code_start|> """
Form a twitter query string from keywords and/or entities.
See: https://dev.twitter.com/rest/public/search
Testing shows that OR has precedence over AND:
a b OR c d is a AND (b OR c) AND d
is not (a AND b) OR (c AND d)
a OR b c OR d is (a OR b) AND (c OR d)
is not a OR (b AND c) OR d
For example, the query:
free OR good beer OR shirt
is interpreted as:
(free OR good) AND (beer OR shirt)
so it will return tweets containing:
"free" and "beer"
or "free" and "shirt"
or "good" and "beer"
or "good" and "shirt"
"""
q_entities = []
if entities:
<|code_end|>
. Use current file imports:
from .nlp.entities import collapse_entities
from .nlp.util import quoted_terms
and context (classes, functions, or code) from other files:
# Path: context/nlp/entities.py
# def collapse_entities(entity_list):
# """Return unique list of entity names collapsed into shortest forms"""
# name_list = []
#
# for e in entity_list:
# name_forms = sorted(e['name_forms'], key=lambda s: len(s))
# while name_forms:
# name = name_forms.pop(0)
# for i in range(len(name_forms) - 1, -1, -1):
# s = name_forms[i]
# if s.find(name) > -1:
# del name_forms[i]
# if name not in name_list:
# name_list.append(name)
# name_list.extend([s for s in name_forms if s not in name_list])
#
# return name_list
#
# Path: context/nlp/util.py
# def quoted_terms(term_list):
# """Return list of terms with multi-word terms quoted"""
# return [MULTIWORD_PAT.sub(r'"\1 \2"', t) for t in term_list]
. Output only the next line. | q_entities = collapse_entities( |
Given snippet: <|code_start|>
a OR b c OR d is (a OR b) AND (c OR d)
is not a OR (b AND c) OR d
For example, the query:
free OR good beer OR shirt
is interpreted as:
(free OR good) AND (beer OR shirt)
so it will return tweets containing:
"free" and "beer"
or "free" and "shirt"
or "good" and "beer"
or "good" and "shirt"
"""
q_entities = []
if entities:
q_entities = collapse_entities(
[d for d in entities if d['score'] > 0.01])
q_keywords = []
if keywords:
q_keywords = [d['keyword'] for d in keywords \
if d['count'] > 2 and d['keyword'] not in q_entities]
<|code_end|>
, continue by predicting the next line. Consider current file imports:
from .nlp.entities import collapse_entities
from .nlp.util import quoted_terms
and context:
# Path: context/nlp/entities.py
# def collapse_entities(entity_list):
# """Return unique list of entity names collapsed into shortest forms"""
# name_list = []
#
# for e in entity_list:
# name_forms = sorted(e['name_forms'], key=lambda s: len(s))
# while name_forms:
# name = name_forms.pop(0)
# for i in range(len(name_forms) - 1, -1, -1):
# s = name_forms[i]
# if s.find(name) > -1:
# del name_forms[i]
# if name not in name_list:
# name_list.append(name)
# name_list.extend([s for s in name_forms if s not in name_list])
#
# return name_list
#
# Path: context/nlp/util.py
# def quoted_terms(term_list):
# """Return list of terms with multi-word terms quoted"""
# return [MULTIWORD_PAT.sub(r'"\1 \2"', t) for t in term_list]
which might include code, classes, or functions. Output only the next line. | q_keywords = quoted_terms(q_keywords[:5]) |
Continue the code snippet: <|code_start|> entity.tokenized_name)
type_entity['locations'].append(locations[entity])
else:
type_entities[entity] = {
'count': 1,
'name_forms': [ entity.tokenized_name ],
'locations': [ locations[entity] ]
}
for entity_key, entity_data in type_entities.items():
name = best_name(entity_data['name_forms'])
if name:
all_entities.append({
'name': name,
'type': entity_type,
'name_forms': [' '.join(form) for form in
entity_data['name_forms']],
'score': entity_score(
entity_data['count'],
entity_data['locations'],
sentences)
})
return all_entities
def get_entities(text):
"""Return list of entities in text sorted by score (desc)"""
try:
text = codecs.decode(text, 'utf-8')
except:
pass
<|code_end|>
. Use current file imports:
from collections import defaultdict, namedtuple
from .util import get_sentences, pos_tag, tokenize, NLTK_VERSION, \
name_parts, compare_names
import codecs
import nltk
import re
and context (classes, functions, or code) from other files:
# Path: context/nlp/util.py
# def get_sentences(text):
# """Return sentence list"""
# if text.strip() == '':
# return []
# tokens = nltk.sent_tokenize(text)
# sentences = []
# for sent in tokens:
# sentences.extend([s.strip() for s in sent.split('\n') if s.strip()])
# sentences_ = []
# skip_next = False
# for i, sent in enumerate(sentences):
# if skip_next:
# skip_next = False
# continue
# if i == len(sentences):
# sentences_.append(sent)
# break
# if sent.split()[-1].lower() == ('no.'):
# try:
# s1 = sentences[i+1]
# int(s1.split()[0])
# sentences_.append(sent + ' ' + s1)
# skip_next = True
# except ValueError:
# sentences_.append(sent)
# else:
# sentences_.append(sent)
# assert sentences[-1] in sentences_[-1]
# return sentences_
#
# def pos_tag(tokens):
# """Return POS tagged tokens"""
# return nltk.pos_tag(tokens)
#
# def tokenize(text):
# """Return tokenized string"""
# text = text.replace('@', '__at__').replace('#', '__hash__')
# tokens = nltk.word_tokenize(text)
# tokens = [t.replace('__at__', '@').replace('__hash__', '#')
# for t in tokens]
# return tokens
#
# NLTK_VERSION = nltk_major_version()
#
# def name_parts(names, flat=False):
# """Return list of words within a name"""
# parts = []
# for name in names:
# n = ALNUM_PAT.findall(name)
# if flat:
# parts.extend(n)
# else:
# parts.append(n)
# return parts
#
# def compare_names(namepartsA, namepartsB):
# """Takes two name-parts lists (as lists of words) and returns a score."""
# complement = set(namepartsA) ^ set(namepartsB)
# intersection = set(namepartsA) & set(namepartsB)
# score = float(len(intersection))/(len(intersection)+len(complement))
# return score
. Output only the next line. | sentences = get_sentences(text) |
Given the code snippet: <|code_start|> for chunk in chunks:
if isinstance(chunk, tuple):
yield(retagger(chunk))
elif hasattr(chunk, 'leaves'):
if NLTK_VERSION >= 3:
c = nltk.tree.Tree(chunk.label(), [])
else:
c = nltk.tree.Tree('(%s)' % chunk.node)
for leaf in chunk.leaves():
newt = retagger(leaf)
c.append(leaf)
if newt[1] == 'CO_':
if NLTK_VERSION >= 3:
c.set_label('ORGANIZATION')
else:
c.node = 'ORGANIZATION'
if newt[1] == 'LOC_':
if NLTK_VERSION >= 3:
c.set_label('LOCATION')
else:
c.node = 'LOCATION'
yield c
else:
yield chunk
def _entity_types_and_locations(sentences):
entities_by_type = defaultdict(list)
locations = {}
for sentnum, sent in enumerate(sentences, start=1):
<|code_end|>
, generate the next line using the imports in this file:
from collections import defaultdict, namedtuple
from .util import get_sentences, pos_tag, tokenize, NLTK_VERSION, \
name_parts, compare_names
import codecs
import nltk
import re
and context (functions, classes, or occasionally code) from other files:
# Path: context/nlp/util.py
# def get_sentences(text):
# """Return sentence list"""
# if text.strip() == '':
# return []
# tokens = nltk.sent_tokenize(text)
# sentences = []
# for sent in tokens:
# sentences.extend([s.strip() for s in sent.split('\n') if s.strip()])
# sentences_ = []
# skip_next = False
# for i, sent in enumerate(sentences):
# if skip_next:
# skip_next = False
# continue
# if i == len(sentences):
# sentences_.append(sent)
# break
# if sent.split()[-1].lower() == ('no.'):
# try:
# s1 = sentences[i+1]
# int(s1.split()[0])
# sentences_.append(sent + ' ' + s1)
# skip_next = True
# except ValueError:
# sentences_.append(sent)
# else:
# sentences_.append(sent)
# assert sentences[-1] in sentences_[-1]
# return sentences_
#
# def pos_tag(tokens):
# """Return POS tagged tokens"""
# return nltk.pos_tag(tokens)
#
# def tokenize(text):
# """Return tokenized string"""
# text = text.replace('@', '__at__').replace('#', '__hash__')
# tokens = nltk.word_tokenize(text)
# tokens = [t.replace('__at__', '@').replace('__hash__', '#')
# for t in tokens]
# return tokens
#
# NLTK_VERSION = nltk_major_version()
#
# def name_parts(names, flat=False):
# """Return list of words within a name"""
# parts = []
# for name in names:
# n = ALNUM_PAT.findall(name)
# if flat:
# parts.extend(n)
# else:
# parts.append(n)
# return parts
#
# def compare_names(namepartsA, namepartsB):
# """Takes two name-parts lists (as lists of words) and returns a score."""
# complement = set(namepartsA) ^ set(namepartsB)
# intersection = set(namepartsA) & set(namepartsB)
# score = float(len(intersection))/(len(intersection)+len(complement))
# return score
. Output only the next line. | sent = pos_tag(tokenize(sent)) |
Given the following code snippet before the placeholder: <|code_start|> for chunk in chunks:
if isinstance(chunk, tuple):
yield(retagger(chunk))
elif hasattr(chunk, 'leaves'):
if NLTK_VERSION >= 3:
c = nltk.tree.Tree(chunk.label(), [])
else:
c = nltk.tree.Tree('(%s)' % chunk.node)
for leaf in chunk.leaves():
newt = retagger(leaf)
c.append(leaf)
if newt[1] == 'CO_':
if NLTK_VERSION >= 3:
c.set_label('ORGANIZATION')
else:
c.node = 'ORGANIZATION'
if newt[1] == 'LOC_':
if NLTK_VERSION >= 3:
c.set_label('LOCATION')
else:
c.node = 'LOCATION'
yield c
else:
yield chunk
def _entity_types_and_locations(sentences):
entities_by_type = defaultdict(list)
locations = {}
for sentnum, sent in enumerate(sentences, start=1):
<|code_end|>
, predict the next line using imports from the current file:
from collections import defaultdict, namedtuple
from .util import get_sentences, pos_tag, tokenize, NLTK_VERSION, \
name_parts, compare_names
import codecs
import nltk
import re
and context including class names, function names, and sometimes code from other files:
# Path: context/nlp/util.py
# def get_sentences(text):
# """Return sentence list"""
# if text.strip() == '':
# return []
# tokens = nltk.sent_tokenize(text)
# sentences = []
# for sent in tokens:
# sentences.extend([s.strip() for s in sent.split('\n') if s.strip()])
# sentences_ = []
# skip_next = False
# for i, sent in enumerate(sentences):
# if skip_next:
# skip_next = False
# continue
# if i == len(sentences):
# sentences_.append(sent)
# break
# if sent.split()[-1].lower() == ('no.'):
# try:
# s1 = sentences[i+1]
# int(s1.split()[0])
# sentences_.append(sent + ' ' + s1)
# skip_next = True
# except ValueError:
# sentences_.append(sent)
# else:
# sentences_.append(sent)
# assert sentences[-1] in sentences_[-1]
# return sentences_
#
# def pos_tag(tokens):
# """Return POS tagged tokens"""
# return nltk.pos_tag(tokens)
#
# def tokenize(text):
# """Return tokenized string"""
# text = text.replace('@', '__at__').replace('#', '__hash__')
# tokens = nltk.word_tokenize(text)
# tokens = [t.replace('__at__', '@').replace('__hash__', '#')
# for t in tokens]
# return tokens
#
# NLTK_VERSION = nltk_major_version()
#
# def name_parts(names, flat=False):
# """Return list of words within a name"""
# parts = []
# for name in names:
# n = ALNUM_PAT.findall(name)
# if flat:
# parts.extend(n)
# else:
# parts.append(n)
# return parts
#
# def compare_names(namepartsA, namepartsB):
# """Takes two name-parts lists (as lists of words) and returns a score."""
# complement = set(namepartsA) ^ set(namepartsB)
# intersection = set(namepartsA) & set(namepartsB)
# score = float(len(intersection))/(len(intersection)+len(complement))
# return score
. Output only the next line. | sent = pos_tag(tokenize(sent)) |
Using the snippet: <|code_start|> return names[-1]
def entity_score(count, occurrences, sentences):
"""Compute entity score"""
return ( count / len(sentences) / min(occurrences) )
def retagger(chunk):
chunk = (clean_token(chunk[0]), chunk[1])
if chunk[1] == 'NNP' and chunk[0][0].isupper():
chunk = (chunk[0], 'NNPX_')
if chunk[0] in LOCATION_SUFFIXES:
chunk = (chunk[0], 'LOC_')
if chunk[0][0].isupper() and (
chunk[0].endswith('istan') or \
chunk[0].endswith('abad') ):
chunk = (chunk[0], 'GPE')
if chunk[0].strip('.') in ORGANIZATION_SUFFIXES:
chunk = (chunk[0], 'CO_')
if chunk[0] in ('The',):
chunk = (chunk[0], 'DTX_')
return chunk
def retag(chunks):
for chunk in chunks:
if isinstance(chunk, tuple):
yield(retagger(chunk))
elif hasattr(chunk, 'leaves'):
<|code_end|>
, determine the next line of code. You have imports:
from collections import defaultdict, namedtuple
from .util import get_sentences, pos_tag, tokenize, NLTK_VERSION, \
name_parts, compare_names
import codecs
import nltk
import re
and context (class names, function names, or code) available:
# Path: context/nlp/util.py
# def get_sentences(text):
# """Return sentence list"""
# if text.strip() == '':
# return []
# tokens = nltk.sent_tokenize(text)
# sentences = []
# for sent in tokens:
# sentences.extend([s.strip() for s in sent.split('\n') if s.strip()])
# sentences_ = []
# skip_next = False
# for i, sent in enumerate(sentences):
# if skip_next:
# skip_next = False
# continue
# if i == len(sentences):
# sentences_.append(sent)
# break
# if sent.split()[-1].lower() == ('no.'):
# try:
# s1 = sentences[i+1]
# int(s1.split()[0])
# sentences_.append(sent + ' ' + s1)
# skip_next = True
# except ValueError:
# sentences_.append(sent)
# else:
# sentences_.append(sent)
# assert sentences[-1] in sentences_[-1]
# return sentences_
#
# def pos_tag(tokens):
# """Return POS tagged tokens"""
# return nltk.pos_tag(tokens)
#
# def tokenize(text):
# """Return tokenized string"""
# text = text.replace('@', '__at__').replace('#', '__hash__')
# tokens = nltk.word_tokenize(text)
# tokens = [t.replace('__at__', '@').replace('__hash__', '#')
# for t in tokens]
# return tokens
#
# NLTK_VERSION = nltk_major_version()
#
# def name_parts(names, flat=False):
# """Return list of words within a name"""
# parts = []
# for name in names:
# n = ALNUM_PAT.findall(name)
# if flat:
# parts.extend(n)
# else:
# parts.append(n)
# return parts
#
# def compare_names(namepartsA, namepartsB):
# """Takes two name-parts lists (as lists of words) and returns a score."""
# complement = set(namepartsA) ^ set(namepartsB)
# intersection = set(namepartsA) & set(namepartsB)
# score = float(len(intersection))/(len(intersection)+len(complement))
# return score
. Output only the next line. | if NLTK_VERSION >= 3: |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.