INSTRUCTION stringlengths 1 8.43k | RESPONSE stringlengths 75 104k |
|---|---|
Process index/ update search index update actions. | def _update_search_index(*, instance, index, update_fields):
"""Process index / update search index update actions."""
if not _in_search_queryset(instance=instance, index=index):
logger.debug(
"Object (%r) is not in search queryset, ignoring update.", instance
)
return
t... |
Remove a document from a search index. | def _delete_from_search_index(*, instance, index):
"""Remove a document from a search index."""
pre_delete.send(sender=instance.__class__, instance=instance, index=index)
if settings.auto_sync(instance):
instance.delete_search_document(index=index) |
Validate config and connect signals. | def ready(self):
"""Validate config and connect signals."""
super(ElasticAppConfig, self).ready()
_validate_config(settings.get_setting("strict_validation"))
_connect_signals() |
Return specific search setting from Django conf. | def get_setting(key, *default):
"""Return specific search setting from Django conf."""
if default:
return get_settings().get(key, default[0])
else:
return get_settings()[key] |
Return the JSON mapping file for an index. | def get_index_mapping(index):
"""Return the JSON mapping file for an index.
Mappings are stored as JSON files in the mappings subdirectory of this
app. They must be saved as {{index}}.json.
Args:
index: string, the name of the index to look for.
"""
# app_path = apps.get_app_config('e... |
Return the list of properties specified for a model in an index. | def get_model_index_properties(instance, index):
"""Return the list of properties specified for a model in an index."""
mapping = get_index_mapping(index)
doc_type = instance._meta.model_name.lower()
return list(mapping["mappings"][doc_type]["properties"].keys()) |
Return list of models configured for a named index. | def get_index_models(index):
"""Return list of models configured for a named index.
Args:
index: string, the name of the index to look up.
"""
models = []
for app_model in get_index_config(index).get("models"):
app, model = app_model.split(".")
models.append(apps.get_model(... |
Return list of all indexes in which a model is configured. | def get_model_indexes(model):
"""Return list of all indexes in which a model is configured.
A model may be configured to appear in multiple indexes. This function
will return the names of the indexes as a list of strings. This is
useful if you want to know which indexes need updating when a model
i... |
Return dict of index. doc_type: model. | def get_document_models():
"""Return dict of index.doc_type: model."""
mappings = {}
for i in get_index_names():
for m in get_index_models(i):
key = "%s.%s" % (i, m._meta.model_name)
mappings[key] = m
return mappings |
Returns bool if auto_sync is on for the model ( instance ) | def auto_sync(instance):
"""Returns bool if auto_sync is on for the model (instance)"""
# this allows us to turn off sync temporarily - e.g. when doing bulk updates
if not get_setting("auto_sync"):
return False
model_name = "{}.{}".format(instance._meta.app_label, instance._meta.model_name)
... |
Returns an indented HTML pretty - print version of JSON. | def pprint(data):
"""
Returns an indented HTML pretty-print version of JSON.
Take the event_payload JSON, indent it, order the keys and then
present it as a <code> block. That's about as good as we can get
until someone builds a custom syntax function.
"""
pretty = json.dumps(data, sort_ke... |
Adds a help menu to the plugin menu. This method should be called from the initGui () method of the plugin | def addHelpMenu(menuName, parentMenuFunction=None):
'''
Adds a help menu to the plugin menu.
This method should be called from the initGui() method of the plugin
:param menuName: The name of the plugin menu in which the about menu is to be added.
'''
parentMenuFunction = parentMenuFunction or ... |
Adds an about... menu to the plugin menu. This method should be called from the initGui () method of the plugin | def addAboutMenu(menuName, parentMenuFunction=None):
'''
Adds an 'about...' menu to the plugin menu.
This method should be called from the initGui() method of the plugin
:param menuName: The name of the plugin menu in which the about menu is to be added
'''
parentMenuFunction = parentMenuFunct... |
Show a dialog containing a given text with a given title. | def showMessageDialog(title, text):
'''
Show a dialog containing a given text, with a given title.
The text accepts HTML syntax
'''
dlg = QgsMessageOutput.createMessageOutput()
dlg.setTitle(title)
dlg.setMessage(text, QgsMessageOutput.MessageHtml)
dlg.showMessage() |
Asks for a file or files opening the corresponding dialog with the last path that was selected when this same function was invoked from the calling method. | def askForFiles(parent, msg = None, isSave = False, allowMultiple = False, exts = "*"):
'''
Asks for a file or files, opening the corresponding dialog with the last path that was selected
when this same function was invoked from the calling method.
:param parent: The parent window
:param msg: The m... |
Asks for a folder opening the corresponding dialog with the last path that was selected when this same function was invoked from the calling method | def askForFolder(parent, msg = None):
'''
Asks for a folder, opening the corresponding dialog with the last path that was selected
when this same function was invoked from the calling method
:param parent: The parent window
:param msg: The message to use for the dialog title
'''
msg = msg o... |
Executes a lengthy tasks in a separate thread and displays a waiting dialog if needed. Sets the cursor to wait cursor while the task is running. | def execute(func, message = None):
'''
Executes a lengthy tasks in a separate thread and displays a waiting dialog if needed.
Sets the cursor to wait cursor while the task is running.
This function does not provide any support for progress indication
:param func: The function to execute.
:par... |
Context manager used to temporarily disable auto_sync. | def disable_search_updates():
"""
Context manager used to temporarily disable auto_sync.
This is useful when performing bulk updates on objects - when
you may not want to flood the indexing process.
>>> with disable_search_updates():
... for obj in model.objects.all():
... obj.save... |
Make a network request by calling QgsNetworkAccessManager. redirections argument is ignored and is here only for httplib2 compatibility. | def request(self, url, method="GET", body=None, headers=None, redirections=DEFAULT_MAX_REDIRECTS, connection_type=None, blocking=True):
"""
Make a network request by calling QgsNetworkAccessManager.
redirections argument is ignored and is here only for httplib2 compatibility.
"""
... |
Trap the timeout. In Async mode requestTimedOut is called after replyFinished | def requestTimedOut(self, reply):
"""Trap the timeout. In Async mode requestTimedOut is called after replyFinished"""
# adapt http_call_result basing on receiving qgs timer timout signal
self.exception_class = RequestsExceptionTimeout
self.http_call_result.exception = RequestsExceptionTi... |
Handle SSL errors logging them if debug is on and ignoring them if disable_ssl_certificate_validation is set. | def sslErrors(self, ssl_errors):
"""
Handle SSL errors, logging them if debug is on and ignoring them
if disable_ssl_certificate_validation is set.
"""
if ssl_errors:
for v in ssl_errors:
self.msg_log("SSL Error: %s" % v.errorString())
if self.... |
Handle request to cancel HTTP call | def abort(self):
"""
Handle request to cancel HTTP call
"""
if (self.reply and self.reply.isRunning()):
self.on_abort = True
self.reply.abort() |
Return all the loaded layers. Filters by name ( optional ) first and then type ( optional ): param name: ( optional ) name of layer to return..: param type: ( optional ) The QgsMapLayer type of layer to return. Accepts a single value or a list of them: return: List of loaded layers. If name given will return all layers... | def mapLayers(name=None, types=None):
"""
Return all the loaded layers. Filters by name (optional) first and then type (optional)
:param name: (optional) name of layer to return..
:param type: (optional) The QgsMapLayer type of layer to return. Accepts a single value or a list of them
:return: List... |
Add one or several layers to the QGIS session and layer registry.: param layer: The layer object or list with layers to add the QGIS layer registry and session.: param loadInLegend: True if this layer should be added to the legend.: return: The added layer | def addLayer(layer, loadInLegend=True):
"""
Add one or several layers to the QGIS session and layer registry.
:param layer: The layer object or list with layers to add the QGIS layer registry and session.
:param loadInLegend: True if this layer should be added to the legend.
:return: The added laye... |
Tries to add a layer from layer object Same as the addLayer method but it does not ask for CRS regardless of current configuration in QGIS settings | def addLayerNoCrsDialog(layer, loadInLegend=True):
'''
Tries to add a layer from layer object
Same as the addLayer method, but it does not ask for CRS, regardless of current
configuration in QGIS settings
'''
settings = QSettings()
prjSetting = settings.value('/Projections/defaultBehaviour')... |
Creates a new vector layer | def newVectorLayer(filename, fields, geometryType, crs, encoding="utf-8"):
'''
Creates a new vector layer
:param filename: The filename to store the file. The extensions determines the type of file.
If extension is not among the supported ones, a shapefile will be created and the file will
get an a... |
Returns the layer from the current project with the passed name Raises WrongLayerNameException if no layer with that name is found If several layers with that name exist only the first one is returned | def layerFromName(name):
'''
Returns the layer from the current project with the passed name
Raises WrongLayerNameException if no layer with that name is found
If several layers with that name exist, only the first one is returned
'''
layers =_layerreg.mapLayers().values()
for layer in layer... |
Returns the layer from the current project with the passed source Raises WrongLayerSourceException if no layer with that source is found | def layerFromSource(source):
'''
Returns the layer from the current project with the passed source
Raises WrongLayerSourceException if no layer with that source is found
'''
layers =_layerreg.mapLayers().values()
for layer in layers:
if layer.source() == source:
return layer
... |
Tries to load a layer from the given file | def loadLayer(filename, name = None, provider=None):
'''
Tries to load a layer from the given file
:param filename: the path to the file to load.
:param name: the name to use for adding the layer to the current project.
If not passed or None, it will use the filename basename
'''
name = na... |
Tries to load a layer from the given file Same as the loadLayer method but it does not ask for CRS regardless of current configuration in QGIS settings | def loadLayerNoCrsDialog(filename, name=None, provider=None):
'''
Tries to load a layer from the given file
Same as the loadLayer method, but it does not ask for CRS, regardless of current
configuration in QGIS settings
'''
settings = QSettings()
prjSetting = settings.value('/Projections/def... |
Adds a open settings... menu to the plugin menu. This method should be called from the initGui () method of the plugin | def addSettingsMenu(menuName, parentMenuFunction=None):
'''
Adds a 'open settings...' menu to the plugin menu.
This method should be called from the initGui() method of the plugin
:param menuName: The name of the plugin menu in which the settings menu is to be added
:param parentMenuFunction: a fun... |
Opens a dialog to enter parameters. Parameters are passed as a list of Parameter objects Returns a dict with param names as keys and param values as values Returns None if the dialog was cancelled | def openParametersDialog(params, title=None):
'''
Opens a dialog to enter parameters.
Parameters are passed as a list of Parameter objects
Returns a dict with param names as keys and param values as values
Returns None if the dialog was cancelled
'''
QApplication.setOverrideCursor(QCursor(Qt... |
Rebuild search index. | def do_index_command(self, index, **options):
"""Rebuild search index."""
if options["interactive"]:
logger.warning("This will permanently delete the index '%s'.", index)
if not self._confirm_action():
logger.warning(
"Aborting rebuild of index... |
Run do_index_command on each specified index and log the output. | def handle(self, *args, **options):
"""Run do_index_command on each specified index and log the output."""
for index in options.pop("indexes"):
data = {}
try:
data = self.do_index_command(index, **options)
except TransportError as ex:
l... |
Creates a template. | def create(self, Name, Subject, HtmlBody=None, TextBody=None, Alias=None):
"""
Creates a template.
:param Name: Name of template
:param Subject: The content to use for the Subject when this template is used to send email.
:param HtmlBody: The content to use for the HtmlBody when... |
Returns simple console logger. | def get_logger(name, verbosity, stream):
"""
Returns simple console logger.
"""
logger = logging.getLogger(name)
logger.setLevel(
{0: DEFAULT_LOGGING_LEVEL, 1: logging.INFO, 2: logging.DEBUG}.get(min(2, verbosity), DEFAULT_LOGGING_LEVEL)
)
logger.handlers = []
handler = logging.S... |
Helper method for instantiating PostmarkClient from dict - like objects. | def from_config(cls, config, prefix="postmark_", is_uppercase=False):
"""
Helper method for instantiating PostmarkClient from dict-like objects.
"""
kwargs = {}
for arg in get_args(cls):
key = prefix + arg
if is_uppercase:
key = key.upper()... |
Split a container into n - sized chunks. | def chunks(container, n):
"""
Split a container into n-sized chunks.
"""
for i in range(0, len(container), n):
yield container[i : i + n] |
Helper to iterate over remote data via count & offset pagination. | def sizes(count, offset=0, max_chunk=500):
"""
Helper to iterate over remote data via count & offset pagination.
"""
if count is None:
chunk = max_chunk
while True:
yield chunk, offset
offset += chunk
else:
while count:
chunk = min(count, m... |
Constructs appropriate exception from list of responses and raises it. | def raise_for_response(self, responses):
"""
Constructs appropriate exception from list of responses and raises it.
"""
exception_messages = [self.client.format_exception_message(response) for response in responses]
if len(exception_messages) == 1:
message = exception... |
Converts list to string with comma separated values. For string is no - op. | def list_to_csv(value):
"""
Converts list to string with comma separated values. For string is no-op.
"""
if isinstance(value, (list, tuple, set)):
value = ",".join(value)
return value |
Converts incoming attachment into dictionary. | def prepare_attachments(attachment):
"""
Converts incoming attachment into dictionary.
"""
if isinstance(attachment, tuple):
result = {"Name": attachment[0], "Content": attachment[1], "ContentType": attachment[2]}
if len(attachment) == 4:
result["ContentID"] = attachment[3]
... |
Additionally encodes headers. | def as_dict(self):
"""
Additionally encodes headers.
:return:
"""
data = super(BaseEmail, self).as_dict()
data["Headers"] = [{"Name": name, "Value": value} for name, value in data["Headers"].items()]
for field in ("To", "Cc", "Bcc"):
if field in data:... |
Attaches given binary data. | def attach_binary(self, content, filename):
"""
Attaches given binary data.
:param bytes content: Binary data to be attached.
:param str filename:
:return: None.
"""
content_type = guess_content_type(filename)
payload = {"Name": filename, "Content": b64en... |
Instantiates Email instance from MIMEText instance. | def from_mime(cls, message, manager):
"""
Instantiates ``Email`` instance from ``MIMEText`` instance.
:param message: ``email.mime.text.MIMEText`` instance.
:param manager: :py:class:`EmailManager` instance.
:return: :py:class:`Email`
"""
text, html, attachments ... |
Converts all available emails to dictionaries. | def as_dict(self, **extra):
"""
Converts all available emails to dictionaries.
:return: List of dictionaries.
"""
return [self._construct_email(email, **extra) for email in self.emails] |
Converts incoming data to properly structured dictionary. | def _construct_email(self, email, **extra):
"""
Converts incoming data to properly structured dictionary.
"""
if isinstance(email, dict):
email = Email(manager=self._manager, **email)
elif isinstance(email, (MIMEText, MIMEMultipart)):
email = Email.from_mi... |
Sends email batch. | def send(self, **extra):
"""
Sends email batch.
:return: Information about sent emails.
:rtype: `list`
"""
emails = self.as_dict(**extra)
responses = [self._manager._send_batch(*batch) for batch in chunks(emails, self.MAX_SIZE)]
return sum(responses, []) |
Sends a single email. | def send(
self,
message=None,
From=None,
To=None,
Cc=None,
Bcc=None,
Subject=None,
Tag=None,
HtmlBody=None,
TextBody=None,
Metadata=None,
ReplyTo=None,
Headers=None,
TrackOpens=None,
TrackLinks="None"... |
Constructs: py: class: Email instance. | def Email(
self,
From,
To,
Cc=None,
Bcc=None,
Subject=None,
Tag=None,
HtmlBody=None,
TextBody=None,
Metadata=None,
ReplyTo=None,
Headers=None,
TrackOpens=None,
TrackLinks="None",
Attachments=None,
... |
Constructs: py: class: EmailTemplate instance. | def EmailTemplate(
self,
TemplateId,
TemplateModel,
From,
To,
TemplateAlias=None,
Cc=None,
Bcc=None,
Subject=None,
Tag=None,
ReplyTo=None,
Headers=None,
TrackOpens=None,
TrackLinks="None",
Attachments... |
Activates the bounce instance and updates it with the latest data. | def activate(self):
"""
Activates the bounce instance and updates it with the latest data.
:return: Activation status.
:rtype: `str`
"""
response = self._manager.activate(self.ID)
self._update(response["Bounce"])
return response["Message"] |
Returns many bounces. | def all(
self,
count=500,
offset=0,
type=None,
inactive=None,
emailFilter=None,
tag=None,
messageID=None,
fromdate=None,
todate=None,
):
"""
Returns many bounces.
:param int count: Number of bounces to return pe... |
Helper to support handy dictionaries merging on all Python versions. | def update_kwargs(self, kwargs, count, offset):
"""
Helper to support handy dictionaries merging on all Python versions.
"""
kwargs.update({self.count_key: count, self.offset_key: offset})
return kwargs |
Gets a brief overview of statistics for all of your outbound email. | def overview(self, tag=None, fromdate=None, todate=None):
"""
Gets a brief overview of statistics for all of your outbound email.
"""
return self.call("GET", "/stats/outbound", tag=tag, fromdate=fromdate, todate=todate) |
Gets a total count of emails you’ve sent out. | def sends(self, tag=None, fromdate=None, todate=None):
"""
Gets a total count of emails you’ve sent out.
"""
return self.call("GET", "/stats/outbound/sends", tag=tag, fromdate=fromdate, todate=todate) |
Gets total counts of emails you’ve sent out that have been returned as bounced. | def bounces(self, tag=None, fromdate=None, todate=None):
"""
Gets total counts of emails you’ve sent out that have been returned as bounced.
"""
return self.call("GET", "/stats/outbound/bounces", tag=tag, fromdate=fromdate, todate=todate) |
Gets a total count of recipients who have marked your email as spam. | def spam(self, tag=None, fromdate=None, todate=None):
"""
Gets a total count of recipients who have marked your email as spam.
"""
return self.call("GET", "/stats/outbound/spam", tag=tag, fromdate=fromdate, todate=todate) |
Gets a total count of emails you’ve sent with open tracking or link tracking enabled. | def tracked(self, tag=None, fromdate=None, todate=None):
"""
Gets a total count of emails you’ve sent with open tracking or link tracking enabled.
"""
return self.call("GET", "/stats/outbound/tracked", tag=tag, fromdate=fromdate, todate=todate) |
Gets total counts of recipients who opened your emails. This is only recorded when open tracking is enabled for that email. | def opens(self, tag=None, fromdate=None, todate=None):
"""
Gets total counts of recipients who opened your emails.
This is only recorded when open tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/opens", tag=tag, fromdate=fromdate, todate=todate) |
Gets an overview of the platforms used to open your emails. This is only recorded when open tracking is enabled for that email. | def opens_platforms(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the platforms used to open your emails.
This is only recorded when open tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/opens/platforms", tag=tag, fromdate=fr... |
Gets an overview of the email clients used to open your emails. This is only recorded when open tracking is enabled for that email. | def emailclients(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the email clients used to open your emails.
This is only recorded when open tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/opens/emailclients", tag=tag, fromdat... |
Gets the length of time that recipients read emails along with counts for each time. This is only recorded when open tracking is enabled for that email. Read time tracking stops at 20 seconds so any read times above that will appear in the 20s + field. | def readtimes(self, tag=None, fromdate=None, todate=None):
"""
Gets the length of time that recipients read emails along with counts for each time.
This is only recorded when open tracking is enabled for that email.
Read time tracking stops at 20 seconds, so any read times above that wil... |
Gets total counts of unique links that were clicked. | def clicks(self, tag=None, fromdate=None, todate=None):
"""
Gets total counts of unique links that were clicked.
"""
return self.call("GET", "/stats/outbound/clicks", tag=tag, fromdate=fromdate, todate=todate) |
Gets an overview of the browsers used to open links in your emails. This is only recorded when Link Tracking is enabled for that email. | def browserfamilies(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the browsers used to open links in your emails.
This is only recorded when Link Tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/clicks/browserfamilies", tag=t... |
Gets an overview of the browser platforms used to open your emails. This is only recorded when Link Tracking is enabled for that email. | def clicks_platforms(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of the browser platforms used to open your emails.
This is only recorded when Link Tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/clicks/platforms", tag=tag, f... |
Gets an overview of which part of the email links were clicked from ( HTML or Text ). This is only recorded when Link Tracking is enabled for that email. | def location(self, tag=None, fromdate=None, todate=None):
"""
Gets an overview of which part of the email links were clicked from (HTML or Text).
This is only recorded when Link Tracking is enabled for that email.
"""
return self.call("GET", "/stats/outbound/clicks/location", tag... |
Return the global line rate of the coverage report. If the filename file is given return the line rate of the file. | def line_rate(self, filename=None):
"""
Return the global line rate of the coverage report. If the
`filename` file is given, return the line rate of the file.
"""
if filename is None:
el = self.xml
else:
el = self._get_class_element_by_filename(fil... |
Return the global branch rate of the coverage report. If the filename file is given return the branch rate of the file. | def branch_rate(self, filename=None):
"""
Return the global branch rate of the coverage report. If the
`filename` file is given, return the branch rate of the file.
"""
if filename is None:
el = self.xml
else:
el = self._get_class_element_by_filena... |
Return a list of uncovered line numbers for each of the missed statements found for the file filename. | def missed_statements(self, filename):
"""
Return a list of uncovered line numbers for each of the missed
statements found for the file `filename`.
"""
el = self._get_class_element_by_filename(filename)
lines = el.xpath('./lines/line[@hits=0]')
return [int(l.attri... |
Return a list of tuples ( lineno status ) of all the lines found in the Cobertura report for the given file filename where lineno is the line number and status is coverage status of the line which can be either True ( line hit ) or False ( line miss ). | def line_statuses(self, filename):
"""
Return a list of tuples `(lineno, status)` of all the lines found in
the Cobertura report for the given file `filename` where `lineno` is
the line number and `status` is coverage status of the line which can
be either `True` (line hit) or `F... |
Return a list of extrapolated uncovered line numbers for the file filename according to Cobertura. line_statuses. | def missed_lines(self, filename):
"""
Return a list of extrapolated uncovered line numbers for the
file `filename` according to `Cobertura.line_statuses`.
"""
statuses = self.line_statuses(filename)
statuses = extrapolate_coverage(statuses)
return [lno for lno, st... |
Return a list of namedtuple Line for each line of code found in the source file with the given filename. | def file_source(self, filename):
"""
Return a list of namedtuple `Line` for each line of code found in the
source file with the given `filename`.
"""
lines = []
try:
with self.filesystem.open(filename) as f:
line_statuses = dict(self.line_statu... |
Return the total number of uncovered statements for the file filename. If filename is not given return the total number of uncovered statements for all files. | def total_misses(self, filename=None):
"""
Return the total number of uncovered statements for the file
`filename`. If `filename` is not given, return the total
number of uncovered statements for all files.
"""
if filename is not None:
return len(self.missed_s... |
Return the total number of covered statements for the file filename. If filename is not given return the total number of covered statements for all files. | def total_hits(self, filename=None):
"""
Return the total number of covered statements for the file
`filename`. If `filename` is not given, return the total
number of covered statements for all files.
"""
if filename is not None:
return len(self.hit_statements... |
Return the total number of statements for the file filename. If filename is not given return the total number of statements for all files. | def total_statements(self, filename=None):
"""
Return the total number of statements for the file
`filename`. If `filename` is not given, return the total
number of statements for all files.
"""
if filename is not None:
statements = self._get_lines_by_filename... |
Return the list of available files in the coverage report. | def files(self):
"""
Return the list of available files in the coverage report.
"""
# maybe replace with a trie at some point? see has_file FIXME
already_seen = set()
filenames = []
for el in self.xml.xpath("//class"):
filename = el.attrib['filename']... |
Return a list for source lines of file filename. | def source_lines(self, filename):
"""
Return a list for source lines of file `filename`.
"""
with self.filesystem.open(filename) as f:
return f.readlines() |
Return True if coverage of has improved False otherwise. | def has_better_coverage(self):
"""
Return `True` if coverage of has improved, `False` otherwise.
This does not ensure that all changes have been covered. If this is
what you want, use `CoberturaDiff.has_all_changes_covered()` instead.
"""
for filename in self.files():
... |
Return True if all changes have been covered False otherwise. | def has_all_changes_covered(self):
"""
Return `True` if all changes have been covered, `False` otherwise.
"""
for filename in self.files():
for hunk in self.file_source_hunks(filename):
for line in hunk:
if line.reason is None:
... |
Return the difference between self. cobertura2. <attr_name > ( filename ) and self. cobertura1. <attr_name > ( filename ). | def _diff_attr(self, attr_name, filename):
"""
Return the difference between
`self.cobertura2.<attr_name>(filename)` and
`self.cobertura1.<attr_name>(filename)`.
This generic method is meant to diff the count of methods that return
counts for a given file `filename`, e.g... |
Return a list of 2 - element tuples ( lineno is_new ) for the given file filename where lineno is a missed line number and is_new indicates whether the missed line was introduced ( True ) or removed ( False ). | def diff_missed_lines(self, filename):
"""
Return a list of 2-element tuples `(lineno, is_new)` for the given
file `filename` where `lineno` is a missed line number and `is_new`
indicates whether the missed line was introduced (True) or removed
(False).
"""
line_c... |
Return a list of namedtuple Line for each line of code found in the given file filename. | def file_source(self, filename):
"""
Return a list of namedtuple `Line` for each line of code found in the
given file `filename`.
"""
if self.cobertura1.has_file(filename) and \
self.cobertura1.filesystem.has_file(filename):
lines1 = self.cobertura1.s... |
Like CoberturaDiff. file_source but returns a list of line hunks of the lines that have changed for the given file filename. An empty list means that the file has no lines that have a change in coverage status. | def file_source_hunks(self, filename):
"""
Like `CoberturaDiff.file_source`, but returns a list of line hunks of
the lines that have changed for the given file `filename`. An empty
list means that the file has no lines that have a change in coverage
status.
"""
li... |
Flushes the queue periodically. | def monitor(self):
"""Flushes the queue periodically."""
while self.monitor_running.is_set():
if time.time() - self.last_flush > self.batch_time:
if not self.queue.empty():
logger.info("Queue Flush: time without flush exceeded")
self.fl... |
Add a list of data records to the record queue in the proper format. Convinience method that calls self. put_record for each element. | def put_records(self, records, partition_key=None):
"""Add a list of data records to the record queue in the proper format.
Convinience method that calls self.put_record for each element.
Parameters
----------
records : list
Lists of records to send.
partitio... |
Add data to the record queue in the proper format. | def put_record(self, data, partition_key=None):
"""Add data to the record queue in the proper format.
Parameters
----------
data : str
Data to send.
partition_key: str
Hash that determines which shard a given data record belongs to.
"""
#... |
Flushes the queue and waits for the executor to finish. | def close(self):
"""Flushes the queue and waits for the executor to finish."""
logger.info('Closing producer')
self.flush_queue()
self.monitor_running.clear()
self.pool.shutdown()
logger.info('Producer closed') |
Grab all the current records in the queue and send them. | def flush_queue(self):
"""Grab all the current records in the queue and send them."""
records = []
while not self.queue.empty() and len(records) < self.batch_size:
records.append(self.queue.get())
if records:
self.send_records(records)
self.last_flus... |
Send records to the Kinesis stream. | def send_records(self, records, attempt=0):
"""Send records to the Kinesis stream.
Falied records are sent again with an exponential backoff decay.
Parameters
----------
records : array
Array of formated records to send.
attempt: int
Number of ti... |
Assumes the list is sorted. | def rangify(number_list):
"""Assumes the list is sorted."""
if not number_list:
return number_list
ranges = []
range_start = prev_num = number_list[0]
for num in number_list[1:]:
if num != (prev_num + 1):
ranges.append((range_start, prev_num))
range_start = ... |
Given the following input: | def extrapolate_coverage(lines_w_status):
"""
Given the following input:
>>> lines_w_status = [
(1, True),
(4, True),
(7, False),
(9, False),
]
Return expanded lines with their extrapolated line status.
>>> extrapolate_coverage(lines_w_status) == [
(1, ... |
Return a dict { lineno1: lineno2 } which reconciles line numbers lineno1 of list lines1 to line numbers lineno2 of list lines2. Only lines that are common in both sets are present in the dict lines unique to one of the sets are omitted. | def reconcile_lines(lines1, lines2):
"""
Return a dict `{lineno1: lineno2}` which reconciles line numbers `lineno1`
of list `lines1` to line numbers `lineno2` of list `lines2`. Only lines
that are common in both sets are present in the dict, lines unique to one
of the sets are omitted.
"""
d... |
Return a list of line hunks given a list of lines lines. The number of context lines can be control with context which will return line hunks surrounded with context lines before and after the code change. | def hunkify_lines(lines, context=3):
"""
Return a list of line hunks given a list of lines `lines`. The number of
context lines can be control with `context` which will return line hunks
surrounded with `context` lines before and after the code change.
"""
# Find contiguous line changes
rang... |
show coverage summary of a Cobertura report | def show(cobertura_file, format, output, source, source_prefix):
"""show coverage summary of a Cobertura report"""
cobertura = Cobertura(cobertura_file, source=source)
Reporter = reporters[format]
reporter = Reporter(cobertura)
report = reporter.generate()
if not isinstance(report, bytes):
... |
compare coverage of two Cobertura reports | def diff(
cobertura_file1, cobertura_file2,
color, format, output, source1, source2,
source_prefix1, source_prefix2, source):
"""compare coverage of two Cobertura reports"""
cobertura1 = Cobertura(
cobertura_file1,
source=source1,
source_prefix=source_prefix1
... |
Yield a file - like object for file filename. | def open(self, filename):
"""
Yield a file-like object for file `filename`.
This function is a context manager.
"""
filename = self.real_filename(filename)
if not os.path.exists(filename):
raise self.FileNotFound(filename)
with codecs.open(filename,... |
Injecting message into topic. if _msg_content we inject it directly. if not we use all extra kwargs: param topic_name: name of the topic: param _msg_content: optional message content: param kwargs: each extra kwarg will be put int he message is structure matches: return: | def topic_inject(self, topic_name, _msg_content=None, **kwargs):
"""
Injecting message into topic. if _msg_content, we inject it directly. if not, we use all extra kwargs
:param topic_name: name of the topic
:param _msg_content: optional message content
:param kwargs: each extra ... |
Setting parameter. if _value we inject it directly. if not we use all extra kwargs: param topic_name: name of the topic: param _value: optional value: param kwargs: each extra kwarg will be put in the value if structure matches: return: | def param_set(self, param_name, _value=None, **kwargs):
"""
Setting parameter. if _value, we inject it directly. if not, we use all extra kwargs
:param topic_name: name of the topic
:param _value: optional value
:param kwargs: each extra kwarg will be put in the value if structur... |
runner | def run(self):
"""runner"""
# change version in code and changelog before running this
subprocess.check_call("git commit CHANGELOG.rst pyros/_version.py CHANGELOG.rst -m 'v{0}'".format(__version__), shell=True)
subprocess.check_call("git push", shell=True)
print("You should ver... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.