_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q244200 | Resource.security_label_pivot | train | def security_label_pivot(self, security_label_resource):
"""Pivot point on security labels for this resource.
This method will return all *resources* (group, indicators, task,
victims, etc) for this resource that have the provided security
label applied.
**Example Endpoints URI... | python | {
"resource": ""
} |
q244201 | Resource.security_labels | train | def security_labels(self, resource_id=None):
"""Security Label endpoint for this resource with optional label name.
This method will set the resource endpoint for working with Security
Labels. The HTTP GET method will return all security labels applied
to this resource or if a resource... | python | {
"resource": ""
} |
q244202 | Resource.tag_pivot | train | def tag_pivot(self, tag_resource):
"""Pivot point on tags for this resource.
This method will return all *resources* (group, indicators, task,
victims, etc) for this resource that have the provided tag applied.
**Example Endpoints URI's**
+--------------+----------------------... | python | {
"resource": ""
} |
q244203 | Resource.tags | train | def tags(self, resource_id=None):
"""Tag endpoint for this resource with optional tag name.
This method will set the resource endpoint for working with Tags. The
HTTP GET method will return all tags applied to this resource or if a
resource id (tag name) is provided it will return the p... | python | {
"resource": ""
} |
q244204 | Resource.task_pivot | train | def task_pivot(self, task_resource):
"""Pivot point on Tasks for this resource.
This method will return all *resources* (group, indicators, victims,
etc) for this resource that are associated with the provided task id.
**Example Endpoints URI's**
+--------------+--------------... | python | {
"resource": ""
} |
q244205 | Resource.victim_assets | train | def victim_assets(self, asset_type=None, asset_id=None):
"""Victim Asset endpoint for this resource with optional asset type.
This method will set the resource endpoint for working with Victim Assets.
The HTTP GET method will return all Victim Assets associated with this
resource or if ... | python | {
"resource": ""
} |
q244206 | Indicator.indicators | train | def indicators(self, indicator_data):
"""Generator for indicator values.
Some indicator such as Files (hashes) and Custom Indicators can have multiple indicator
values (e.g. md5, sha1, sha256). This method provides a generator to iterate over all
indicator values.
Both the **su... | python | {
"resource": ""
} |
q244207 | Indicator.observed | train | def observed(self, date_observed=None):
"""Retrieve indicator observations count for top 10"""
if self.name != 'Indicator':
self.tcex.log.warning(u'Observed endpoint only available for "indicator" endpoint.')
else:
| python | {
"resource": ""
} |
q244208 | Bulk.csv | train | def csv(self, ondemand=False):
"""Update request URI to return CSV data.
For onDemand bulk generation to work it must first be enabled in the
ThreatConnect platform under System settings.
Args:
ondemand (boolean): Enable on demand bulk generation.
| python | {
"resource": ""
} |
q244209 | Bulk.json | train | def json(self, ondemand=False):
"""Update request URI to return JSON data.
For onDemand bulk generation to work it must first be enabled in the
ThreatConnect platform under System settings.
Args:
ondemand (boolean): Enable on demand bulk generation.
| python | {
"resource": ""
} |
q244210 | File.indicator_body | train | def indicator_body(indicators):
"""Generate the appropriate dictionary content for POST of an File indicator
Args:
indicators (list): A list of one or more hash value(s).
"""
hash_patterns = {
'md5': re.compile(r'^([a-fA-F\d]{32})$'),
'sha1': re.compi... | python | {
"resource": ""
} |
q244211 | File.occurrence | train | def occurrence(self, indicator=None):
"""Update the URI to retrieve file occurrences for the provided indicator.
Args:
indicator (string): The indicator to retrieve file occurrences. | python | {
"resource": ""
} |
q244212 | Host.resolution | train | def resolution(self, indicator=None):
"""Update the URI to retrieve host resolutions for the provided indicator.
Args:
indicator (string): The indicator to retrieve resolutions. | python | {
"resource": ""
} |
q244213 | Group.group_id | train | def group_id(self, resource_id):
"""Update the request URI to include the Group ID for specific group retrieval.
Args:
resource_id (string): The group id.
"""
| python | {
"resource": ""
} |
q244214 | Adversary.pdf | train | def pdf(self, resource_id):
"""Update the request URI to get the pdf for this resource.
Args:
| python | {
"resource": ""
} |
q244215 | Document.download | train | def download(self, resource_id):
"""Update the request URI to download the document for this resource.
Args:
resource_id (integer): The group id.
"""
| python | {
"resource": ""
} |
q244216 | Document.upload | train | def upload(self, resource_id, data):
"""Update the request URI to upload the a document to this resource.
Args:
resource_id (integer): The group id.
data (any): The raw data to upload.
"""
| python | {
"resource": ""
} |
q244217 | CustomMetric.data | train | def data(self, resource_value, return_value=False):
"""Alias for metric_name method
+--------------+------------------------------------+
| HTTP Method | API Endpoint URI's |
+==============+====================================+
| POST | /v2/customMetric... | python | {
"resource": ""
} |
q244218 | Tag.tag | train | def tag(self, resource_id):
"""Update the request URI to include the Tag for specific retrieval.
Args:
resource_id (string): The tag name.
"""
| python | {
"resource": ""
} |
q244219 | Task.assignees | train | def assignees(self, assignee=None, resource_id=None):
"""Add an assignee to a Task
GET: /v2/tasks/{uniqueId}/assignees
GET: /v2/tasks/{uniqueId}/assignees/{assigneeId}
POST: /v2/tasks/{uniqueId}/assignees/{assigneeId}
DELETE: /v2/tasks/{uniqueId}/assignees/{assigneeId}
... | python | {
"resource": ""
} |
q244220 | Task.escalatees | train | def escalatees(self, escalatee=None, resource_id=None):
"""Add an escalatee to a Task
GET: /v2/tasks/{uniqueId}/escalatees
GET: /v2/tasks/{uniqueId}/escalatees/{escalateeId}
POST: /v2/tasks/{uniqueId}/escalatees/{escalateeId}
DELETE: /v2/tasks/{uniqueId}/escalatees/{escalateeId}... | python | {
"resource": ""
} |
q244221 | DataStore._request | train | def _request(self, domain, type_name, search_command, db_method, body=None):
"""Make the API request for a Data Store CRUD operation
Args:
domain (string): One of 'local', 'organization', or 'system'.
type_name (string): This is a free form index type name. The ThreatConnect API... | python | {
"resource": ""
} |
q244222 | DataStore.create | train | def create(self, domain, type_name, search_command, body):
"""Create entry in ThreatConnect Data Store
Args:
domain (string): One of 'local', 'organization', or 'system'.
type_name (string): This is a free form index type name. The ThreatConnect API will use
this... | python | {
"resource": ""
} |
q244223 | DataStore.delete | train | def delete(self, domain, type_name, search_command):
"""Delete entry in ThreatConnect Data Store
Args:
domain (string): One of 'local', 'organization', or 'system'.
type_name (string): This is a free form index type name. The ThreatConnect API will use
| python | {
"resource": ""
} |
q244224 | DataStore.read | train | def read(self, domain, type_name, search_command, body=None):
"""Read entry in ThreatConnect Data Store
Args:
domain (string): One of 'local', 'organization', or 'system'.
type_name (string): This is a free form index type name. The ThreatConnect API will use
thi... | python | {
"resource": ""
} |
q244225 | DataStore.update | train | def update(self, domain, type_name, search_command, body):
"""Update entry in ThreatConnect Data Store
Args:
domain (string): One of 'local', 'organization', or 'system'.
type_name (string): This is a free form index type name. The ThreatConnect API will use
this... | python | {
"resource": ""
} |
q244226 | Document.file_content | train | def file_content(self, file_content, update_if_exists=True):
"""
Updates the file content.
Args:
file_content: The file_content to upload.
update_if_exists:
Returns:
"""
if not self.can_update():
self._tcex.handle_error(910, [self.ty... | python | {
"resource": ""
} |
q244227 | Document.file_name | train | def file_name(self, file_name):
"""
Updates the file_name.
Args:
file_name:
"""
if not self.can_update():
self._tcex.handle_error(910, [self.type])
self._data['fileName'] = file_name
request = | python | {
"resource": ""
} |
q244228 | Document.malware | train | def malware(self, malware, password, file_name):
"""
Uploads to malware vault.
Args:
malware:
password:
file_name:
"""
if not self.can_update():
self._tcex.handle_error(910, [self.type])
self._data['malware'] = malware
... | python | {
"resource": ""
} |
q244229 | TcExValidate.check_imports | train | def check_imports(self):
"""Check the projects top level directory for missing imports.
This method will check only files ending in **.py** and does not handle imports validation
for sub-directories.
"""
modules = []
for filename in sorted(os.listdir(self.app_path)):
... | python | {
"resource": ""
} |
q244230 | TcExValidate.check_import_stdlib | train | def check_import_stdlib(module):
"""Check if module is in Python stdlib.
Args:
module (str): The name of the module to check.
Returns:
bool: Returns True if the module is in the stdlib or template.
"""
if (
module in stdlib_list('2.7') # pyl... | python | {
"resource": ""
} |
q244231 | TcExValidate.check_install_json | train | def check_install_json(self):
"""Check all install.json files for valid schema."""
if self.install_json_schema is None:
return
contents = os.listdir(self.app_path)
if self.args.install_json is not None:
contents = [self.args.install_json]
for install_jso... | python | {
"resource": ""
} |
q244232 | TcExValidate.check_layout_json | train | def check_layout_json(self):
"""Check all layout.json files for valid schema."""
# the install.json files can't be validates if the schema file is not present
layout_json_file = 'layout.json'
if self.layout_json_schema is None or not os.path.isfile(layout_json_file):
return
... | python | {
"resource": ""
} |
q244233 | TcExValidate.check_layout_params | train | def check_layout_params(self):
"""Check that the layout.json is consistent with install.json.
The layout.json files references the params.name from the install.json file. The method
will validate that no reference appear for inputs in install.json that don't exist.
"""
ij_inpu... | python | {
"resource": ""
} |
q244234 | TcExValidate.check_syntax | train | def check_syntax(self, app_path=None):
"""Run syntax on each ".py" and ".json" file.
Args:
app_path (str, optional): Defaults to None. The path of Python files.
"""
app_path = app_path or '.'
for filename in sorted(os.listdir(app_path)):
error = None
... | python | {
"resource": ""
} |
q244235 | TcExValidate.install_json_schema | train | def install_json_schema(self):
"""Load install.json schema file."""
if self._install_json_schema is None and self.install_json_schema_file is not None:
# remove old schema file
if os.path.isfile('tcex_json_schema.json'):
# this file is now part of tcex.
... | python | {
"resource": ""
} |
q244236 | TcExValidate.interactive | train | def interactive(self):
"""Run in interactive mode."""
while True:
line = sys.stdin.readline().strip()
if line == 'quit':
sys.exit()
elif line == 'validate':
| python | {
"resource": ""
} |
q244237 | TcExValidate.layout_json_schema | train | def layout_json_schema(self):
"""Load layout.json schema file."""
if self._layout_json_schema is None and self.layout_json_schema_file is not None:
| python | {
"resource": ""
} |
q244238 | TcExValidate.print_results | train | def print_results(self):
"""Print results."""
# Validating Syntax
if self.validation_data.get('fileSyntax'):
print('\n{}{}Validated File Syntax:'.format(c.Style.BRIGHT, c.Fore.BLUE))
print('{}{!s:<60}{!s:<25}'.format(c.Style.BRIGHT, 'File:', 'Status:'))
for f ... | python | {
"resource": ""
} |
q244239 | TcExValidate.status_color | train | def status_color(status):
"""Return the appropriate status color."""
status_color = c.Fore.GREEN
if not status: | python | {
"resource": ""
} |
q244240 | TcExCache._dt_to_epoch | train | def _dt_to_epoch(dt):
"""Convert datetime to epoch seconds."""
try:
epoch = dt.timestamp()
except AttributeError: # py2
| python | {
"resource": ""
} |
q244241 | TcExCache.get | train | def get(self, rid, data_callback=None, raise_on_error=True):
"""Get cached data from the data store.
Args:
rid (str): The record identifier.
data_callback (callable): A method that will return the data.
raise_on_error (bool): If True and not r.ok this method will rai... | python | {
"resource": ""
} |
q244242 | TcExCache.update | train | def update(self, rid, data, raise_on_error=True):
"""Write updated cache data to the DataStore.
Args:
rid (str): The record identifier.
data (dict): The record data.
raise_on_error (bool): If True and not r.ok this method will raise a RunTimeError.
Returns:
... | python | {
"resource": ""
} |
q244243 | TcEx._association_types | train | def _association_types(self):
"""Retrieve Custom Indicator Associations types from the ThreatConnect API."""
# Dynamically create custom indicator class
r = self.session.get('/v2/types/associationTypes')
# check for bad status code and response that is not JSON
if not r.ok or 'a... | python | {
"resource": ""
} |
q244244 | TcEx._log | train | def _log(self):
"""Send System and App data to logs."""
self._log_platform()
| python | {
"resource": ""
} |
q244245 | TcEx._log_app_data | train | def _log_app_data(self):
"""Log the App data information."""
# Best Effort
if self.install_json:
app_commit_hash = self.install_json.get('commitHash')
app_features = ','.join(self.install_json.get('features', []))
app_min_ver = self.install_json.get('minServer... | python | {
"resource": ""
} |
q244246 | TcEx._log_python_version | train | def _log_python_version(self):
"""Log the current Python version."""
self.log.info(
u'Python Version: {}.{}.{}'.format(
| python | {
"resource": ""
} |
q244247 | TcEx._log_tc_proxy | train | def _log_tc_proxy(self):
"""Log the proxy settings."""
if self.default_args.tc_proxy_tc:
self.log.info(
u'Proxy Server (TC): {}:{}.'.format(
| python | {
"resource": ""
} |
q244248 | TcEx._log_tcex_version | train | def _log_tcex_version(self):
"""Log the current TcEx version number."""
| python | {
"resource": ""
} |
q244249 | TcEx._logger | train | def _logger(self):
"""Create TcEx app logger instance.
The logger is accessible via the ``tc.log.<level>`` call.
**Logging examples**
.. code-block:: python
:linenos:
:lineno-start: 1
tcex.log.debug('logging debug')
tcex.log.info('loggi... | python | {
"resource": ""
} |
q244250 | TcEx._logger_api | train | def _logger_api(self):
"""Add API logging handler."""
from .tcex_logger import TcExLogHandler, TcExLogFormatter
api = TcExLogHandler(self.session)
| python | {
"resource": ""
} |
q244251 | TcEx._logger_fh | train | def _logger_fh(self):
"""Add File logging handler."""
logfile = os.path.join(self.default_args.tc_log_path, self.default_args.tc_log_file)
fh = logging.FileHandler(logfile)
| python | {
"resource": ""
} |
q244252 | TcEx._logger_levels | train | def _logger_levels(self):
"""Return log levels."""
return {
'debug': logging.DEBUG,
| python | {
"resource": ""
} |
q244253 | TcEx._logger_stream | train | def _logger_stream(self):
"""Add stream logging handler."""
sh = logging.StreamHandler()
sh.set_name('sh')
sh.setLevel(logging.INFO) | python | {
"resource": ""
} |
q244254 | TcEx._resources | train | def _resources(self, custom_indicators=False):
"""Initialize the resource module.
This method will make a request to the ThreatConnect API to dynamically
build classes to support custom Indicators. All other resources are available
via this class.
.. Note:: Resource Classes ca... | python | {
"resource": ""
} |
q244255 | TcEx.utils | train | def utils(self):
"""Include the Utils module.
.. Note:: Utils methods can be accessed using ``tcex.utils.<method>``.
| python | {
"resource": ""
} |
q244256 | TcEx.batch | train | def batch(
self,
owner,
action=None,
attribute_write_type=None,
halt_on_error=False,
playbook_triggers_enabled=None,
):
"""Return instance of Batch"""
from .tcex_ti_batch import TcExBatch
| python | {
"resource": ""
} |
q244257 | TcEx.cache | train | def cache(self, domain, data_type, ttl_minutes=None, mapping=None):
"""Get instance of the Cache module.
Args:
domain (str): The domain can be either "system", "organization", or "local". When using
"organization" the data store can be accessed by any Application in the enti... | python | {
"resource": ""
} |
q244258 | TcEx.data_filter | train | def data_filter(self, data):
"""Return an instance of the Data Filter Class.
A simple helper module to filter results from ThreatConnect API or other data
source. For example if results need to be filtered by an unsupported field the module
allows you to pass the data array/list in and... | python | {
"resource": ""
} |
q244259 | TcEx.datastore | train | def datastore(self, domain, data_type, mapping=None):
"""Get instance of the DataStore module.
Args:
domain (str): The domain can be either "system", "organization", or "local". When using
"organization" the data store can be accessed by any Application in the entire org,
... | python | {
"resource": ""
} |
q244260 | TcEx.error_codes | train | def error_codes(self):
"""ThreatConnect error codes."""
if self._error_codes is None:
from .tcex_error_codes import TcExErrorCodes
| python | {
"resource": ""
} |
q244261 | TcEx.exit | train | def exit(self, code=None, msg=None):
"""Application exit method with proper exit code
The method will run the Python standard sys.exit() with the exit code
previously defined via :py:meth:`~tcex.tcex.TcEx.exit_code` or provided
during the call of this method.
Args:
... | python | {
"resource": ""
} |
q244262 | TcEx.exit_code | train | def exit_code(self, code):
"""Set the App exit code.
For TC Exchange Apps there are 3 supported exit codes.
* 0 indicates a normal exit
* 1 indicates a failure during execution
* 3 indicates a partial failure
Args:
| python | {
"resource": ""
} |
q244263 | TcEx.get_type_from_api_entity | train | def get_type_from_api_entity(self, api_entity):
"""
Returns the object type as a string given a api entity.
Args:
api_entity:
Returns:
"""
merged = self.group_types_data.copy()
merged.update(self.indicator_types_data)
| python | {
"resource": ""
} |
q244264 | TcEx.install_json | train | def install_json(self):
"""Return contents of install.json configuration file, loading from disk if required."""
if self._install_json is None:
try:
install_json_filename = os.path.join(os.getcwd(), 'install.json')
with open(install_json_filename, 'r') as fh:
... | python | {
"resource": ""
} |
q244265 | TcEx.install_json_params | train | def install_json_params(self):
"""Parse params from install.json into a dict by name."""
if not self._install_json_params:
| python | {
"resource": ""
} |
q244266 | TcEx.metric | train | def metric(self, name, description, data_type, interval, keyed=False):
"""Get instance of the Metrics module.
Args:
name (string): The name for the metric.
description (string): The description of the metric.
data_type (string): The type of metric: Sum, Count, Min, M... | python | {
"resource": ""
} |
q244267 | TcEx.message_tc | train | def message_tc(self, message, max_length=255):
"""Write data to message_tc file in TcEX specified directory.
This method is used to set and exit message in the ThreatConnect Platform.
ThreatConnect only supports files of max_message_length. Any data exceeding
this limit will be truncat... | python | {
"resource": ""
} |
q244268 | TcEx.playbook | train | def playbook(self):
"""Include the Playbook Module.
.. Note:: Playbook methods can be accessed using ``tcex.playbook.<method>``.
| python | {
"resource": ""
} |
q244269 | TcEx.proxies | train | def proxies(self):
"""Formats proxy configuration into required format for Python Requests module.
Generates a dictionary for use with the Python Requests module format
when proxy is required for remote connections.
**Example Response**
::
{"http": "http://user:pas... | python | {
"resource": ""
} |
q244270 | TcEx.request | train | def request(self, session=None):
"""Return an instance of the Request Class.
A wrapper on the Python Requests module that provides a different interface for creating
requests. The session property of this instance has built-in logging, session level
retries, and preconfigured proxy conf... | python | {
"resource": ""
} |
q244271 | TcEx.resource | train | def resource(self, resource_type):
"""Get instance of Resource Class with dynamic type.
Args:
resource_type: The resource type name (e.g Adversary, User Agent, etc).
Returns:
(object): Instance of Resource Object child class.
"""
try:
| python | {
"resource": ""
} |
q244272 | TcEx.results_tc | train | def results_tc(self, key, value):
"""Write data to results_tc file in TcEX specified directory.
The TcEx platform support persistent values between executions of the App. This
method will store the values for TC to read and put into the Database.
Args:
key (string): The da... | python | {
"resource": ""
} |
q244273 | TcEx.safe_indicator | train | def safe_indicator(self, indicator, errors='strict'):
"""Indicator encode value for safe HTTP request.
Args:
indicator (string): Indicator to URL Encode
errors (string): The error handler type.
Returns:
(string): The urlencoded string
"""
if ... | python | {
"resource": ""
} |
q244274 | TcEx.safe_rt | train | def safe_rt(resource_type, lower=False):
"""Format the Resource Type.
Takes Custom Indicator types with a space character and return a *safe* string.
(e.g. *User Agent* is converted to User_Agent or user_agent.)
Args:
resource_type (string): The resource | python | {
"resource": ""
} |
q244275 | TcEx.safe_group_name | train | def safe_group_name(group_name, group_max_length=100, ellipsis=True):
"""Truncate group name to match limit breaking on space and optionally add an ellipsis.
.. note:: Currently the ThreatConnect group name limit is 100 characters.
Args:
group_name (string): The raw group name to be... | python | {
"resource": ""
} |
q244276 | TcEx.safe_url | train | def safe_url(self, url, errors='strict'):
"""URL encode value for safe HTTP request.
Args:
url (string): The string to URL Encode.
Returns:
(string): The urlencoded string.
| python | {
"resource": ""
} |
q244277 | TcEx.session | train | def session(self):
"""Return an instance of Requests Session configured for the ThreatConnect API."""
if self._session is None:
| python | {
"resource": ""
} |
q244278 | TcEx.ti | train | def ti(self):
"""Include the Threat Intel Module.
.. Note:: Threat Intell methods can be accessed using ``tcex.ti.<method>``. | python | {
"resource": ""
} |
q244279 | Task.assignees | train | def assignees(self):
"""
Gets the task assignees
"""
if not self.can_update():
self._tcex.handle_error(910, [self.type])
| python | {
"resource": ""
} |
q244280 | Task.escalatees | train | def escalatees(self):
"""
Gets the task escalatees
"""
if not self.can_update():
self._tcex.handle_error(910, [self.type])
| python | {
"resource": ""
} |
q244281 | TcExKeyValue.read | train | def read(self, key):
"""Read data from remote KV store for the provided key.
Args:
key (string): The key to read in remote KV store.
Returns:
(any): The response data from the remote KV store.
"""
key = quote(key, safe='~')
url = | python | {
"resource": ""
} |
q244282 | RegistryKey.can_create | train | def can_create(self):
"""
If the key_name, value_name, and value_type has been provided returns that the
Registry Key can be created, otherwise returns that the Registry Key cannot be created.
Returns:
"""
| python | {
"resource": ""
} |
q244283 | TcExMetricsV2.metric_create | train | def metric_create(self):
"""Create the defined metric.
.. code-block:: javascript
{
"status": "Success",
"data": {
"customMetricConfig": {
"id": 12,
"name": "Added Reports",
... | python | {
"resource": ""
} |
q244284 | TcExMetricsV2.metric_find | train | def metric_find(self):
"""Find the Metric by name.
.. code-block:: javascript
{
"status": "Success",
"data": {
"resultCount": 1,
"customMetricConfig": [
{
"id": 9,
... | python | {
"resource": ""
} |
q244285 | TcExMetricsV2.add | train | def add(self, value, date=None, return_value=False, key=None):
"""Add metrics data to collection.
Args:
value (str): The value of the metric.
date (str, optional): The optional date of the metric.
return_value (bool, default:False): Tell the API to return the updates... | python | {
"resource": ""
} |
q244286 | TcExMetricsV2.add_keyed | train | def add_keyed(self, value, key, date=None, return_value=False):
"""Add keyed metrics data to collection.
Args:
value (str): The value of the metric.
key (str): The key value for keyed metrics.
date (str, optional): The optional date of the metric.
return_... | python | {
"resource": ""
} |
q244287 | TcExRedis.hget | train | def hget(self, key):
"""Read data from Redis for the provided key.
Args:
key (string): The key to read in Redis.
Returns:
(any): The response data from Redis.
"""
data = self.r.hget(self.hash, | python | {
"resource": ""
} |
q244288 | TcExArgs._load_secure_params | train | def _load_secure_params(self):
"""Load secure params from the API.
# API Response:
.. code-block:: javascript
:linenos:
:lineno-start: 1
{
"inputs":
{
"tc_playbook_db_type": "Redis",
... | python | {
"resource": ""
} |
q244289 | TcExArgs._results_tc_args | train | def _results_tc_args(self):
"""Read data from results_tc file from previous run of app.
This method is only required when not running from the with the
TcEX platform and is only intended for testing apps locally.
Returns:
(dictionary): A dictionary of values written to resu... | python | {
"resource": ""
} |
q244290 | TcExArgs._unknown_args | train | def _unknown_args(self, args):
"""Log argparser unknown arguments.
Args:
args (list): List of unknown arguments
"""
| python | {
"resource": ""
} |
q244291 | TcExArgs.args_update | train | def args_update(self):
"""Update the argparser namespace with any data from configuration file."""
| python | {
"resource": ""
} |
q244292 | TcExArgs.config_file | train | def config_file(self, filename):
"""Load configuration data from provided file and inject values into sys.argv.
Args:
config (str): The configuration file name.
"""
if os.path.isfile(filename):
with open(filename, 'r') | python | {
"resource": ""
} |
q244293 | TcExArgs.default_args | train | def default_args(self):
"""Parse args and return default args."""
if self._default_args is None:
self._default_args, unknown = self.parser.parse_known_args() # pylint: disable=W0612
# reinitialize logger with new log level and api settings
self.tcex._logger()
... | python | {
"resource": ""
} |
q244294 | TcExArgs.inject_params | train | def inject_params(self, params):
"""Inject params into sys.argv from secureParams API, AOT, or user provided.
Args:
params (dict): A dictionary containing all parameters that need to be injected as args.
"""
for arg, value in params.items():
cli_arg = '--{}'.for... | python | {
"resource": ""
} |
q244295 | Owner.many | train | def many(self):
"""
Gets all of the owners available.
Args:
"""
| python | {
"resource": ""
} |
q244296 | Host.dns_resolution | train | def dns_resolution(self):
"""
Updates the Host DNS resolution
Returns:
"""
if not self.can_update():
self._tcex.handle_error(910, [self.type])
| python | {
"resource": ""
} |
q244297 | TcExProfile._create_tcex_dirs | train | def _create_tcex_dirs():
"""Create tcex.d directory and sub directories."""
dirs = | python | {
"resource": ""
} |
q244298 | TcExProfile.expand_valid_values | train | def expand_valid_values(valid_values):
"""Expand supported playbook variables to their full list.
Args:
valid_values (list): The list of valid values for Choice or MultiChoice inputs.
Returns:
List: An expanded list of valid values for Choice or MultiChoice inputs.
... | python | {
"resource": ""
} |
q244299 | TcExProfile.gen_permutations | train | def gen_permutations(self, index=0, args=None):
"""Iterate recursively over layout.json parameter names.
TODO: Add indicator values.
Args:
index (int, optional): The current index position in the layout names list.
args (list, optional): Defaults to None. The current li... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.