def getEventDetail(self, uri, format=None):
"""
Gets event detail information.
:type uri: str
:param uri: Event identifier as either a EMSC event unique identifier,
e.g. ``"19990817_0000001"`` or a QuakeML-formatted event URI, e.g.
``"quakeml:eu.emsc/event#19990817_0000001"``.
:type format: ``'list'``, ``'xml'`` or ``'catalog'``, optional
:param format: Format of returned results. Defaults to ``'xml'``.
:rtype: :class:`~obspy.core.event.Catalog`, list or str
:return: Method will return either an ObsPy
:class:`~obspy.core.event.Catalog` object, a list of event
dictionaries or a QuakeML string depending on the ``format``
keyword.
.. seealso:: http://www.seismicportal.eu/services/event/detail/info/
.. rubric:: Example
>>> from obspy.neries import Client
>>> client = Client()
>>> result = client.getEventDetail("19990817_0000001", 'list')
>>> len(result) # Number of calculated origins
12
>>> result[0] # Details about first calculated origin #doctest: +SKIP
{'author': u'EMSC', 'event_id': u'19990817_0000001',
'origin_id': 1465935, 'longitude': 29.972,
'datetime': UTCDateTime(1999, 8, 17, 0, 1, 35), 'depth': -10.0,
'magnitude': 6.7, 'magnitude_type': u'mw', 'latitude': 40.749}
"""
# deprecation warning if format is not set
if format is None:
msg = "The default setting format='xml' for obspy.neries." + \
"Client.getEventDetail() will be changed in the future to " + \
"format='catalog'. Please call this function with the " + \
"format keyword in order to hide this deprecation warning."
warnings.warn(msg, category=DeprecationWarning)
format = "xml"
# parse parameters
kwargs = {}
if format == 'list':
kwargs['format'] = 'json'
else:
kwargs['format'] = 'xml'
if str(uri).startswith('quakeml:'):
# QuakeML-formatted event URI
kwargs['uri'] = str(uri)
else:
# EMSC event unique identifier
kwargs['unid'] = str(uri)
# fetch data
data = self._fetch("/services/event/detail", **kwargs)
# format output
if format == "list":
return self._json2list(data.decode())
elif format == "catalog":
return readEvents(compatibility.BytesIO(data), 'QUAKEML')
else:
return data
def __str__(self):
ret = ("Network {id} {description}\n"
"\tStation Count: {selected}/{total} (Selected/Total)\n"
"\t{start_date} - {end_date}\n"
"\tAccess: {restricted} {alternate_code}{historical_code}\n")
ret = ret.format(
id=self.code,
description="(%s)" % self.description if self.description else "",
selected=self.selected_number_of_stations,
total=self.total_number_of_stations,
start_date=str(self.start_date),
end_date=str(self.end_date) if self.end_date else "",
restricted=self.restricted_status,
alternate_code="Alternate Code: %s " % self.alternate_code if
self.alternate_code else "",
historical_code="historical Code: %s " % self.historical_code if
self.historical_code else "")
contents = self.get_contents()
ret += "\tContains:\n"
ret += "\t\tStations (%i):\n" % len(contents["stations"])
ret += "\n".join(["\t\t\t%s" % _i for _i in contents["stations"]])
ret += "\n"
ret += "\t\tChannels (%i):\n" % len(contents["channels"])
ret += "\n".join(textwrap.wrap(", ".join(
contents["channels"]), initial_indent="\t\t\t",
subsequent_indent="\t\t\t", expand_tabs=False))
return ret
def test_object_implements_py2_unicode_method(self):
my_unicode_str = u'Unicode string: \u5b54\u5b50'
class A(object):
def __str__(self):
return my_unicode_str
a = A()
self.assertEqual(len(str(a)), 18)
if utils.PY2:
self.assertTrue(hasattr(a, '__unicode__'))
else:
self.assertFalse(hasattr(a, '__unicode__'))
self.assertEqual(str(a), my_unicode_str)
self.assertTrue(isinstance(str(a).encode('utf-8'), bytes))
if utils.PY2:
self.assertTrue(type(unicode(a)) == unicode)
self.assertEqual(unicode(a), my_unicode_str)
# Manual equivalent on Py2 without the decorator:
if not utils.PY3:
class B(object):
def __unicode__(self):
return u'Unicode string: \u5b54\u5b50'
def __str__(self):
return unicode(self).encode('utf-8')
b = B()
assert str(a) == str(b)
def update_single_item(item):
"""
Synchronize single item (movie or episode) with next-episode-net
:param item: video item
:type item: dict
"""
data = {
'user': {
'username': addon.getSetting('username'),
'hash': addon.getSetting('hash')
}}
if item['type'] == 'episode':
data['tvshows'] = [{
'thetvdb_id': get_tvdb_id(item['tvshowid']),
'season': str(item['season']),
'episode': str(item['episode']),
'watched': '1' if item['playcount'] else '0'
}]
elif item['type'] == 'movie':
data['movies'] = [{
'watched': '1' if item['playcount'] else '0'
}]
if 'tt' in item['imdbnumber']:
data['imdb_id'] = item['imdbnumber']
else:
data['imdb_id'] = item['uniqueid']['imdb']
log_data_sent(data)
send_data(data)
def _write_io_units(parent, obj):
sub = etree.SubElement(parent, "InputUnits")
etree.SubElement(sub, "Name").text = str(obj.input_units)
etree.SubElement(sub, "Description").text = str(obj.input_units_description)
sub = etree.SubElement(parent, "OutputUnits")
etree.SubElement(sub, "Name").text = str(obj.output_units)
etree.SubElement(sub, "Description").text = str(obj.output_units_description)
def origin__geo_interface__(self):
"""
__geo_interface__ method for GeoJSON-type GIS protocol
:return: dict of valid GeoJSON
Reference
---------
Python geo_interface specifications:
https://gist.github.com/sgillies/2217756
"""
time = None
update_time = None
coords = [self.longitude, self.latitude]
if self.depth is not None:
coords.append(self.depth)
if isinstance(self.time, UTCDateTime):
time = str(self.time)
coords.append(self.time.timestamp)
if self.creation_info and self.creation_info.creation_time is not None:
update_time = str(self.creation_info.creation_time)
point = {
"type": "Point",
"coordinates": coords,
"id": str(self.resource_id),
}
props = {
"time": time,
"updated": update_time,
}
return {"type": "Feature", "properties": props, "geometry": point}
def _order_totals(context):
"""
Add shipping/tax/discount/order types and totals to the template
context. Use the context's completed order object for email
receipts, or the cart object for checkout.
"""
fields = ["shipping_type", "shipping_total", "discount_total",
"tax_type", "tax_total"]
if "order" in context:
for field in fields + ["item_total"]:
context[field] = getattr(context["order"], field)
else:
context["item_total"] = context["request"].cart.total_price()
if context["item_total"] == 0:
# Ignore session if cart has no items, as cart may have
# expired sooner than the session.
context["tax_total"] = 0
context["discount_total"] = 0
context["shipping_total"] = 0
else:
for field in fields:
context[field] = context["request"].session.get(field, None)
context["order_total"] = context.get("item_total", None)
if context.get("shipping_total", None) is not None:
context["order_total"] += Decimal(str(context["shipping_total"]))
if context.get("discount_total", None) is not None:
context["order_total"] -= Decimal(str(context["discount_total"]))
if context.get("tax_total", None) is not None:
context["order_total"] += Decimal(str(context["tax_total"]))
context["stripe_key"] = settings.STRIPE_PUBLIC_KEY
context["s_currency"] = settings.STRIPE_CURRENCY
return context
def test_analysing_interface_dependencies(monkeypatch, task_workbench,
interface_dep_collector):
"""Test analysing the dependencies in an interface.
"""
runtime = {'test'}
interface = ('LinspaceLoopInterface', 'ecpy.LoopTask')
plugin = task_workbench.get_plugin('ecpy.tasks')
monkeypatch.setattr(plugin.get_interface_infos(interface), 'dependencies',
runtime)
dep = set()
errors = dict()
run = interface_dep_collector.analyse(task_workbench,
{'interface_id': str(interface)},
getitem, dep, errors)
assert run == runtime
assert interface in dep
assert not errors
dep.clear()
run = interface_dep_collector.analyse(task_workbench,
{'interface_id':
('__dummy__', 'LoopTask')},
getitem, dep, errors)
assert not run
assert not dep
assert str(('__dummy__', 'LoopTask')) in errors
def quote_from_bytes(bs, safe='/'):
"""Like quote(), but accepts a bytes object rather than a str, and does
not perform string-to-bytes encoding. It always returns an ASCII string.
quote_from_bytes(b'abc def\x3f') -> 'abc%20def%3f'
"""
if not isinstance(bs, (bytes, bytearray)):
raise TypeError("quote_from_bytes() expected bytes")
if not bs:
return str('')
### For Python-Future:
bs = bytes(bs)
###
if isinstance(safe, str):
# Normalize 'safe' by converting to bytes and removing non-ASCII chars
safe = str(safe).encode('ascii', 'ignore')
else:
### For Python-Future:
safe = bytes(safe)
###
safe = bytes([c for c in safe if c < 128])
if not bs.rstrip(_ALWAYS_SAFE_BYTES + safe):
return bs.decode()
try:
quoter = _safe_quoters[safe]
except KeyError:
_safe_quoters[safe] = quoter = Quoter(safe).__getitem__
return str('').join([quoter(char) for char in bs])
def __str__(self):
ret = (
"Channel '{id}', Location '{location}' {description}\n"
"\tTimerange: {start_date} - {end_date}\n"
"\tLatitude: {latitude:.2f}, Longitude: {longitude:.2f}, "
"Elevation: {elevation:.1f} m, Local Depth: {depth:.1f} m\n"
"{azimuth}"
"{dip}"
"{channel_types}"
"\tSampling Rate: {sampling_rate:.2f} Hz\n"
"\tSensor: {sensor}\n"
"{response}")\
.format(
id=self.code, location=self.location_code,
description="(%s)" % self.description
if self.description else "",
start_date=str(self.start_date),
end_date=str(self.end_date) if self.end_date else "--",
latitude=self.latitude, longitude=self.longitude,
elevation=self.elevation, depth=self.depth,
azimuth="\tAzimuth: %.2f degrees from north, clockwise\n" %
self.azimuth if self.azimuth is not None else "",
dip="\tDip: %.2f degrees down from horizontal\n" %
self.dip if self.dip is not None else "",
channel_types="\tChannel types: %s\n" % ", ".join(self.types)
if self.types else "",
sampling_rate=self.sample_rate, sensor=self.sensor.type,
response="\tResponse information available"
if self.response else "")
return ret
def testRDFURN(self):
"""Test RDFURN handling."""
# Make a url object
str_url = "aff4:/hunts/W:AAAAAAAA/Results"
url = rdfvalue.RDFURN(str_url, age=1)
self.assertEqual(url.age, 1)
self.assertEqual(url.Path(), "/hunts/W:AAAAAAAA/Results")
self.assertEqual(str(url), str_url)
self.assertEqual(url.scheme, "aff4")
# Test the Add() function
url = url.Add("some", age=2).Add("path", age=3)
self.assertEqual(url.age, 3)
self.assertEqual(url.Path(), "/hunts/W:AAAAAAAA/Results/some/path")
self.assertEqual(str(url), utils.Join(str_url, "some", "path"))
# Test that we can handle urns with a '?' and do not interpret them as
# a delimiter between url and parameter list.
str_url = "aff4:/C.0000000000000000/fs/os/c/regex.*?]&[+{}--"
url = rdfvalue.RDFURN(str_url, age=1)
self.assertEqual(url.Path(), str_url[5:])
# Some more special characters...
for path in ["aff4:/test/?#asd", "aff4:/test/#asd", "aff4:/test/?#"]:
self.assertEqual(path, str(rdfvalue.RDFURN(path)))
def get_api_base():
if not production:
api_base = str("https://sandbox-api.openpay.mx")
else:
api_base = str("https://api.openpay.mx")
return api_base
def migrate(self):
"""method that is called to migrate this migration"""
check = self.migration_required()
if check == False:
print("%s has already been migrated, skip it!" % self)
return None
print("Migrating %s" % self)
self.check_migration() # check the configuration of the Migration
connection = self.open_db_connection()
cursor = connection.cursor()
cursor.execute(self.query)
fields = [row[0] for row in cursor.description]
if check is None:
# update existing migrations
self.process_cursor_for_update(connection, cursor, fields)
self.update_tidestamp()
else:
# do the normal migration method
self.process_cursor(connection, cursor, fields)
if self.tidestamp_value:
AppliedMigration.objects.create(classname=str(self), tidestamp=self.tidestamp_value)
else:
AppliedMigration.objects.create(classname=str(self))
def testBasicParsingOldFormat(self):
"""Test we can parse a standard file."""
history_file = os.path.join(self.base_path, "parser_test", "History")
history = chrome_history.ChromeParser(open(history_file, "rb"))
entries = [x for x in history.Parse()]
try:
dt1 = datetime.datetime(1970, 1, 1)
dt1 += datetime.timedelta(microseconds=entries[0][0])
except (TypeError, ValueError):
dt1 = entries[0][0]
try:
dt2 = datetime.datetime(1970, 1, 1)
dt2 += datetime.timedelta(microseconds=entries[-1][0])
except (TypeError, ValueError):
dt2 = entries[-1][0]
# Check that our results are properly time ordered
time_results = [x[0] for x in entries]
self.assertEqual(time_results, sorted(time_results))
self.assertEqual(str(dt1), "2011-04-07 12:03:11")
self.assertEqual(entries[0][2], "http://start.ubuntu.com/10.04/Google/")
self.assertEqual(str(dt2), "2011-05-23 08:37:27.061516")
self.assertStartsWith(
entries[-1][2], "https://chrome.google.com/webs"
"tore/detail/mfjkgbjaikamkkojmak"
"jclmkianficch")
self.assertLen(entries, 71)
def __init__(self, uri=None, page_size=None, shortcuts=None,
arrows=None, snippets=None, use_unicode=None, *args, **kwargs):
"""Constructs a new EmailSettingsGeneral object with the given arguments.
Args:
uri: string (optional) The uri of this object for HTTP requests.
page_size: int (optional) The number of conversations to be shown per page.
shortcuts: Boolean (optional) Whether to enable keyboard shortcuts.
arrows: Boolean (optional) Whether to display arrow-shaped personal
indicators next to email sent specifically to the user.
snippets: Boolean (optional) Whether to display snippets of the messages
in the inbox and when searching.
use_unicode: Boolean (optional) Whether to use UTF-8 (unicode) encoding
for all outgoing messages.
args: The other parameters to pass to gdata.entry.GDEntry constructor.
kwargs: The other parameters to pass to gdata.entry.GDEntry constructor.
"""
super(EmailSettingsGeneral, self).__init__(*args, **kwargs)
if uri:
self.uri = uri
if page_size is not None:
self.page_size = str(page_size)
if shortcuts is not None:
self.shortcuts = str(shortcuts)
if arrows is not None:
self.arrows = str(arrows)
if snippets is not None:
self.snippets = str(snippets)
if use_unicode is not None:
self.use_unicode = str(use_unicode)
def save_form_data(self, instance, data):
"""
The ``KeywordsWidget`` field will return data as a string of
comma separated IDs for the ``Keyword`` model - convert these
into actual ``AssignedKeyword`` instances. Also delete
``Keyword`` instances if their last related ``AssignedKeyword``
instance is being removed.
"""
from mezzanine.generic.models import AssignedKeyword, Keyword
related_manager = getattr(instance, self.name)
# Get a list of Keyword IDs being removed.
old_ids = [str(a.keyword_id) for a in related_manager.all()]
new_ids = data.split(",")
removed_ids = set(old_ids) - set(new_ids)
# Remove current AssignedKeyword instances.
related_manager.all().delete()
# Convert the data into AssignedKeyword instances.
if data:
data = [AssignedKeyword(keyword_id=i) for i in new_ids]
# Remove Keyword instances than no longer have a
# related AssignedKeyword instance.
existing = AssignedKeyword.objects.filter(keyword__id__in=removed_ids)
existing_ids = set([str(a.keyword_id) for a in existing])
unused_ids = removed_ids - existing_ids
Keyword.objects.filter(id__in=unused_ids).delete()
super(KeywordsField, self).save_form_data(instance, data)
def testBasicParsing(self):
"""Test we can parse a standard file."""
history_file = os.path.join(self.base_path, "parser_test", "History2")
history = chrome_history.ChromeParser(open(history_file, "rb"))
entries = [x for x in history.Parse()]
try:
dt1 = datetime.datetime(1970, 1, 1)
dt1 += datetime.timedelta(microseconds=entries[0][0])
except (TypeError, ValueError):
dt1 = entries[0][0]
try:
dt2 = datetime.datetime(1970, 1, 1)
dt2 += datetime.timedelta(microseconds=entries[-1][0])
except (TypeError, ValueError):
dt2 = entries[-1][0]
# Check that our results are properly time ordered
time_results = [x[0] for x in entries]
self.assertEqual(time_results, sorted(time_results))
self.assertEqual(str(dt1), "2013-05-03 15:11:26.556635")
self.assertStartsWith(entries[0][2],
"https://www.google.ch/search?q=why+you+shouldn")
self.assertEqual(str(dt2), "2013-05-03 15:11:39.763984")
self.assertStartsWith(entries[-1][2], "http://www.test.ch/")
self.assertLen(entries, 4)
def start(self, n):
self.context["cores"] = self.cores
if self.mem:
if self.memtype == "rss":
self.context["mem"] = "#$ -l rss=%sM".format(
int(float(self.mem) * 1024 / self.cores)
)
else:
self.context["mem"] = "#$ -l mem_free=%sM".format(
int(float(self.mem) * 1024)
)
else:
self.context["mem"] = ""
if self.queue:
self.context["queue"] = "#$ -q %s" % self.queue
else:
self.context["queue"] = ""
self.context["tag"] = self.tag if self.tag else "bcbio"
self.context["pename"] = str(self.pename)
self.context["resources"] = "\n".join([
_prep_sge_resource(r)
for r in str(self.resources).split(";")
if r.strip()
])
self.context["exports"] = _local_environment_exports()
return super(BcbioSGEEngineSetLauncher, self).start(n)
def thumbnails(html):
"""
Given a HTML string, converts paths in img tags to thumbnail
paths, using Mezzanine's ``thumbnail`` template tag. Used as
one of the default values in the ``RICHTEXT_FILTERS`` setting.
"""
from django.conf import settings
from bs4 import BeautifulSoup
from mezzanine.core.templatetags.mezzanine_tags import thumbnail
# If MEDIA_URL isn't in the HTML string, there aren't any
# images to replace, so bail early.
if settings.MEDIA_URL.lower() not in html.lower():
return html
dom = BeautifulSoup(html, "html.parser")
for img in dom.findAll("img"):
src = img.get("src", "")
src_in_media = src.lower().startswith(settings.MEDIA_URL.lower())
width = img.get("width")
height = img.get("height")
if src_in_media and str(width).isdigit() and str(height).isdigit():
img["src"] = settings.MEDIA_URL + thumbnail(src, width, height)
# BS adds closing br tags, which the browser interprets as br tags.
return str(dom).replace("</br>", "")
def _HandleRelational(self, args):
requests_and_responses = data_store.REL_DB.ReadAllFlowRequestsAndResponses(
str(args.client_id), str(args.flow_id))
result = ApiListFlowRequestsResult()
stop = None
if args.count:
stop = args.offset + args.count
for request, response_dict in itertools.islice(requests_and_responses,
args.offset, stop):
client_urn = args.client_id.ToClientURN()
request_state = rdf_flow_runner.RequestState(
client_id=client_urn,
id=request.request_id,
next_state=request.next_state,
session_id=client_urn.Add("flows").Add(str(request.flow_id)))
api_request = ApiFlowRequest(
request_id=str(request.request_id), request_state=request_state)
if response_dict:
responses = [
response_dict[i].AsLegacyGrrMessage() for i in sorted(response_dict)
]
for r in responses:
r.ClearPayload()
api_request.responses = responses
result.items.append(api_request)
return result
def Handle(self, args, token=None):
if data_store.RelationalDBEnabled():
count = args.count or db.MAX_COUNT
logs = data_store.REL_DB.ReadFlowLogEntries(
str(args.client_id), str(args.flow_id), args.offset, count,
args.filter)
total_count = data_store.REL_DB.CountFlowLogEntries(
str(args.client_id), str(args.flow_id))
return ApiListFlowLogsResult(
items=[
ApiFlowLog().InitFromFlowLogEntry(log, str(args.flow_id))
for log in logs
],
total_count=total_count)
else:
flow_urn = args.flow_id.ResolveClientFlowURN(args.client_id, token=token)
logs_collection = flow.GRRFlow.LogCollectionForFID(flow_urn)
result = api_call_handler_utils.FilterCollection(logs_collection,
args.offset, args.count,
args.filter)
return ApiListFlowLogsResult(
items=[ApiFlowLog().InitFromFlowLog(x) for x in result],
total_count=len(logs_collection))
def str_value(v, encoding='utf-8', bool_int=True, none='NULL'):
import datetime
import decimal
if callable(v):
v = v()
if isinstance(v, datetime.datetime):
return v.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(v, datetime.date):
return v.strftime('%Y-%m-%d')
elif isinstance(v, datetime.time):
return v.strftime('%H:%M:%S')
elif isinstance(v, decimal.Decimal):
return str(v)
elif isinstance(v, str):
return v.encode(encoding)
elif v is None:
return none
elif isinstance(v, bool):
if bool_int:
if v:
return '1'
else:
return '0'
else:
return str(v)
else:
return str(v)
def test_initUTCDateTime(self):
dt = UTCDateTime(year=2008, month=1, day=1)
self.assertEqual(str(dt), "2008-01-01T00:00:00.000000Z")
dt = UTCDateTime(year=2008, julday=1, hour=12, microsecond=5000)
self.assertEqual(str(dt), "2008-01-01T12:00:00.005000Z")
# without parameters returns current date time
dt = UTCDateTime()
def _unpack_value(value, prefix='', whitelist=None, blacklist=None):
"""
Unpack values from a data structure and convert to string. Call
the corresponding functions for dict or iterables or use simple
string conversion for scalar variables.
Parameters
----------
value : dict, iterable, scalar variable
Value to be unpacked.
prefix : str, optional
Prefix to preprend to resulting string. Defaults to empty
string.
"""
try:
return _generate_string_from_dict(value,
blacklist=blacklist,
whitelist=whitelist,
prefix=prefix + 'd')
except AttributeError:
# not a dict
try:
return prefix + _generate_string_from_iterable(value, prefix='i')
except TypeError:
# not an iterable
if isinstance(value, float):
return prefix + str(_save_convert_float_to_int(value))
else:
return prefix + str(value)
def test_collect_interface_dependencies(task_workbench):
"""Test collecting the dependencies found in an interface.
"""
runtime = ['test']
interface = ('LinspaceLoopInterface', 'LoopTask')
plugin = task_workbench.get_plugin('ecpy.tasks')
plugin.get_interface_infos(interface).dependencies = runtime
dep = defaultdict(dict)
errors = defaultdict(dict)
run = collect_interface(task_workbench,
{'interface_class': str(interface)},
getitem, dep, errors)
assert run == runtime
assert INTERFACE_DEP_TYPE in dep
assert interface in dep[INTERFACE_DEP_TYPE]
assert not errors
dep.clear()
run = collect_interface(task_workbench,
{'interface_class': ('__dummy__', 'LoopTask')},
getitem, dep, errors)
assert not run
assert not dep
assert INTERFACE_DEP_TYPE in errors
assert str(('__dummy__', 'LoopTask')) in errors[INTERFACE_DEP_TYPE]
def __repr__(self):
if PY2 and isinstance(self.value, unicode):
val = str(self.value) # make it a newstr to remove the u prefix
else:
val = self.value
return '<%s: %s=%s>' % (self.__class__.__name__,
str(self.key), repr(val))
def OutputString(self, attrs=None):
# Build up our result
#
result = []
append = result.append
# First, the key=value pair
append("%s=%s" % (self.key, self.coded_value))
# Now add any defined attributes
if attrs is None:
attrs = self._reserved
items = sorted(self.items())
for key, value in items:
if value == "":
continue
if key not in attrs:
continue
if key == "expires" and isinstance(value, int):
append("%s=%s" % (self._reserved[key], _getdate(value)))
elif key == "max-age" and isinstance(value, int):
append("%s=%d" % (self._reserved[key], value))
elif key == "secure":
append(str(self._reserved[key]))
elif key == "httponly":
append(str(self._reserved[key]))
else:
append("%s=%s" % (self._reserved[key], value))
# Return the result
return _semispacejoin(result)
def UpdateCell(self, row, col, inputValue, key, wksht_id='default'):
"""Updates an existing cell.
Args:
row: int The row the cell to be editted is in
col: int The column the cell to be editted is in
inputValue: str the new value of the cell
key: str The key of the spreadsheet in which this cell resides.
wksht_id: str The ID of the worksheet which holds this cell.
Returns:
The updated cell entry
"""
row = str(row)
col = str(col)
# make the new cell
new_cell = gdata.spreadsheet.Cell(row=row, col=col, inputValue=inputValue)
# get the edit uri and PUT
cell = 'R%sC%s' % (row, col)
entry = self.GetCellsFeed(key, wksht_id, cell)
for a_link in entry.link:
if a_link.rel == 'edit':
entry.cell = new_cell
return self.Put(entry, a_link.href,
converter=gdata.spreadsheet.SpreadsheetsCellFromString)
def _order_totals(context):
"""
Add ``item_total``, ``shipping_total``, ``discount_total``, ``tax_total``,
and ``order_total`` to the template context. Use the order object for
email receipts, or the cart object for checkout.
"""
if "order" in context:
for f in ("item_total", "shipping_total", "discount_total",
"tax_total"):
context[f] = getattr(context["order"], f)
else:
context["item_total"] = context["request"].cart.total_price()
if context["item_total"] == 0:
# Ignore session if cart has no items, as cart may have
# expired sooner than the session.
context["tax_total"] = context["discount_total"] = \
context["shipping_total"] = 0
else:
for f in ("shipping_type", "shipping_total", "discount_total",
"tax_type", "tax_total"):
context[f] = context["request"].session.get(f, None)
context["order_total"] = context.get("item_total", None)
if context.get("shipping_total", None) is not None:
context["order_total"] += Decimal(str(context["shipping_total"]))
if context.get("discount_total", None) is not None:
context["order_total"] -= Decimal(str(context["discount_total"]))
if context.get("tax_total", None) is not None:
context["order_total"] += Decimal(str(context["tax_total"]))
return context
def hexdump(data, linesize):
r"""
Turns bytes into a unicode string of the format:
::
>>> print(hexdump(b'0' * 100, 16))
hexundump(\"\"\"
0000 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 0000000000000000
0010 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 0000000000000000
0020 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 0000000000000000
0030 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 0000000000000000
0040 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 0000000000000000
0050 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 30 0000000000000000
0060 30 30 30 30 0000
\"\"\")
"""
if len(data) < 16**4:
fmt = "%%04X %%-%ds %%s" % (3*linesize-1,)
elif len(data) < 16**8:
fmt = "%%08X %%-%ds %%s" % (3*linesize-1,)
else:
raise ValueError("hexdump cannot process more than 16**8 or 4294967296 bytes")
prettylines = []
for i in range(0, len(data), linesize):
line = data[i:i+linesize]
hextext = " ".join(HEXPRINT[b] for b in iterateints(line))
rawtext = "".join(PRINTABLE[b] for b in iterateints(line))
prettylines.append(fmt % (i, str(hextext), str(rawtext)))
return "\n".join(prettylines)
def test_string(self):
d = b'\x01\x02\x03abc123\xff\xfe'
t = xmlrpclib.Binary(d)
self.assertEqual(str(t), str(d, "latin-1"))
def plot_optimization(record, record_g0, num=7, fname=None, title=None,
figsize=None, **kwargs):
fig = plt.figure(figsize=figsize)
if num > 1:
n = (num + 1) // 2
gs = gridspec.GridSpec(n, n)
ax = plt.subplot(gs[1:, 0:-1])
share = None
else:
ax = fig.add_subplot(111)
if title:
ax.annotate(title, (0, 1), (5, -5), 'axes fraction', 'offset points',
ha='left', va='top')
err, g0 = zip(*record_g0)
if not np.all(np.isinf(err)):
ax.loglog(g0, err, 'xk')
# best value is plotted blue
ax.loglog(g0[-1], err[-1], 'xb', mew=2)
# infinite values are plotted with red crosses
if np.inf in err:
g0_inf = [g0_ for (err_, g0_) in record_g0 if err_ == np.inf]
err_inf = np.mean(ax.get_ylim())
ax.loglog(g0_inf, err_inf * np.ones(len(g0_inf)), 'xr')
for i in range(len(record)):
if record[i][0] == np.inf:
record[i] = (err_inf,) + record[i][1:]
if num > 1:
for i, rec in enumerate(record):
err, g0, b, W, _, _ = rec
if i < n:
gsp = gs[0, i]
l = str(i + 1)
elif i < num - 1:
gsp = gs[i - n + 1, -1]
l = str(i + 1)
else:
gsp = gs[n - 1, -1]
l = 'best'
ax2 = plt.subplot(gsp, sharex=share, sharey=share)
plot_lstsq(rec, ax=ax2)
ax2.annotate(l, (0, 1), (5, -5), 'axes fraction',
'offset points', ha='left', va='top')
l2 = 'g$_0$=%.1e\nb=%.1e' % (g0, b)
l2 = l2 + '\nW%s=%.1e' % ('$_1$' * (len(W) > 1), W[0])
ax2.annotate(l2, (1, 1), (-5, -5), 'axes fraction',
'offset points', ha='right', va='top',
size='xx-small')
if l != 'best':
ax.annotate(l, (g0, err), (5, 5), 'data', 'offset points',
ha='left', va='bottom')
if i == 0:
share = ax2
yl = (r'$\ln \frac{E_{\mathrm{obs}\,ij}}{G_{ij}B_jR_i}$')
if len(W) == 1:
yl = (r'$\ln \frac{E_{\mathrm{obs}\,i}}{G_iR_i}$')
ax2.set_ylabel(yl)
plt.setp(ax2.get_xticklabels(), visible=False)
elif l == 'best':
ax2.set_xlabel(r'time ($\mathrm{s}$)')
plt.setp(ax2.get_yticklabels(), visible=False)
else:
plt.setp(ax2.get_xticklabels(), visible=False)
plt.setp(ax2.get_yticklabels(), visible=False)
ax2.locator_params(axis='y', nbins=4)
ax2.locator_params(axis='x', nbins=3)
ax.set_xlabel(r'g$_0$ ($\mathrm{m}^{-1}$)')
# yl = (r'error $\mathrm{rms}\left(\ln\frac{E_{\mathrm{obs}, ij}}'
# r'{E_{\mathrm{mod}, ij}}\right)$')
ax.set_ylabel(r'misfit $\epsilon$')
_savefig(fig, fname=fname, **kwargs)
def __str__(self):
return str(self.label)
def __str__(self):
return str(self.title)
def testKnowledgeBaseMultipleProvidesNoDict(self):
with self.assertRaises(RuntimeError) as context:
self._RunKBIFlow(["TooManyProvides"])
self.assertIn("multiple provides clauses", str(context.exception))
def testKnowledgeBaseNoProvides(self):
with self.assertRaises(RuntimeError) as context:
self._RunKBIFlow(["NoProvides"])
self.assertIn("does not have a provide", str(context.exception))
def stylable_items_for_result(cl, result, form):
"""
Return an iterator which returns all columns to display in the list.
This method is based on items_for_result(), yet completely refactored.
"""
first = True
pk = cl.lookup_opts.pk.attname
# Read any custom properties
list_column_classes = getattr(cl.model_admin, 'list_column_classes', {})
# figure out which field to indent
mptt_indent_field = _get_mptt_indent_field(cl, result)
# Parse all fields to display
for field_name in cl.list_display:
row_attr = ''
# This is all standard stuff, refactored to separate methods.
result_repr, row_classes = stylable_column_repr(cl, result, field_name)
if force_text(result_repr) == '':
result_repr = mark_safe(' ')
# Custom stuff, select row classes
if field_name == mptt_indent_field:
level = getattr(result, result._mptt_meta.level_attr)
row_attr += ' style="padding-left:%spx"' % (
5 + MPTT_ADMIN_LEVEL_INDENT * level)
column_class = list_column_classes.get(field_name)
if column_class:
row_classes.append(column_class)
if row_classes:
row_attr += ' class="%s"' % ' '.join(row_classes)
# Add the link tag to the first field, or use list_display_links if it's defined.
if (first and not cl.list_display_links
) or field_name in cl.list_display_links:
table_tag = ('th' if first else 'td')
first = False
url = cl.url_for_result(result)
link_attr = ''
if cl.is_popup:
# Convert the pk to something that can be used in Javascript.
# Problem cases are long ints (23L) and non-ASCII strings.
if cl.to_field:
attr = str(cl.to_field)
else:
attr = pk
value = result.serializable_value(attr)
result_id = repr(force_text(value))[1:]
link_attr += ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id
yield mark_safe(u'<%s%s><a href="%s"%s>%s</a></%s>' %
(table_tag, row_attr, url, link_attr,
conditional_escape(result_repr), table_tag))
else:
# By default the fields come from ModelAdmin.list_editable,
# but if we pull the fields out of the form instead,
# custom ModelAdmin instances can provide fields on a per request basis
if form and field_name in form.fields:
bf = form[field_name]
result_repr = mark_safe(force_text(bf.errors) + force_text(bf))
else:
result_repr = conditional_escape(result_repr)
yield mark_safe(u'<td%s>%s</td>' % (row_attr, result_repr))
if form:
yield mark_safe(u'<td>%s</td>' %
force_text(form[cl.model._meta.pk.name]))
def test_datetime_datetime(self):
d = datetime.datetime(2007,1,2,3,4,5)
t = xmlrpclib.DateTime(d)
self.assertEqual(str(t), '20070102T03:04:05')
def test_time_tuple(self):
d = (2007,6,9,10,38,50,5,160,0)
t = xmlrpclib.DateTime(d)
self.assertEqual(str(t), '20070609T10:38:50')
def test_default(self):
t = xmlrpclib.Binary()
self.assertEqual(str(t), '')
def thumbnail(image_url,
width,
height,
upscale=True,
quality=95,
left=.5,
top=.5,
padding=False,
padding_color="#fff",
rotate=False):
"""
Given the URL to an image, resizes the image using the given width
and height on the first time it is requested, and returns the URL
to the new resized image. If width or height are zero then original
ratio is maintained. When ``upscale`` is False, images smaller than
the given size will not be grown to fill that size. The given width
and height thus act as maximum dimensions.
"""
if not image_url:
return ""
try:
from PIL import Image, ImageFile, ImageOps
except ImportError:
return ""
image_url = unquote(str(image_url)).split("?")[0]
if image_url.startswith(settings.MEDIA_URL):
image_url = image_url.replace(settings.MEDIA_URL, "", 1)
image_dir, image_name = os.path.split(image_url)
image_prefix, image_ext = os.path.splitext(image_name)
filetype = {".png": "PNG", ".gif": "GIF"}.get(image_ext, "JPEG")
thumb_name = "%s-%sx%s" % (image_prefix, width, height)
if not upscale:
thumb_name += "-no-upscale"
if left != .5 or top != .5:
left = min(1, max(0, left))
top = min(1, max(0, top))
thumb_name = "%s-%sx%s" % (thumb_name, left, top)
thumb_name += "-padded-%s" % padding_color if padding else ""
thumb_name = "%s%s" % (thumb_name, image_ext)
# `image_name` is used here for the directory path, as each image
# requires its own sub-directory using its own name - this is so
# we can consistently delete all thumbnails for an individual
# image, which is something we do in filebrowser when a new image
# is written, allowing us to purge any previously generated
# thumbnails that may match a new image name.
thumb_dir = os.path.join(settings.MEDIA_ROOT, image_dir,
settings.THUMBNAILS_DIR_NAME, image_name)
if not os.path.exists(thumb_dir):
try:
os.makedirs(thumb_dir)
except OSError:
pass
thumb_path = os.path.join(thumb_dir, thumb_name)
thumb_url = "%s/%s/%s" % (settings.THUMBNAILS_DIR_NAME,
quote(image_name.encode("utf-8")),
quote(thumb_name.encode("utf-8")))
image_url_path = os.path.dirname(image_url)
if image_url_path:
thumb_url = "%s/%s" % (image_url_path, thumb_url)
try:
thumb_exists = os.path.exists(thumb_path)
except UnicodeEncodeError:
# The image that was saved to a filesystem with utf-8 support,
# but somehow the locale has changed and the filesystem does not
# support utf-8.
from mezzanine.core.exceptions import FileSystemEncodingChanged
raise FileSystemEncodingChanged()
if thumb_exists:
# Thumbnail exists, don't generate it.
return thumb_url
elif not default_storage.exists(image_url):
# Requested image does not exist, just return its URL.
return image_url
f = default_storage.open(image_url)
try:
image = Image.open(f)
except:
# Invalid image format.
return image_url
image_info = image.info
to_width = int(width)
to_height = int(height)
from_width = image.size[0]
from_height = image.size[1]
if rotate and from_width < from_height:
t2 = to_width
to_width = to_height
to_height = t2
if not upscale:
to_width = min(to_width, from_width)
to_height = min(to_height, from_height)
# Set dimensions.
if to_width == 0:
to_width = from_width * to_height // from_height
elif to_height == 0:
to_height = from_height * to_width // from_width
if image.mode not in ("P", "L", "RGBA"):
try:
image = image.convert("RGBA")
except:
return image_url
# Required for progressive jpgs.
ImageFile.MAXBLOCK = 2 * (max(image.size)**2)
# Padding.
if padding and to_width and to_height:
from_ratio = float(from_width) / from_height
to_ratio = float(to_width) / to_height
pad_size = None
if to_ratio < from_ratio:
pad_height = int(to_height * (float(from_width) / to_width))
pad_size = (from_width, pad_height)
pad_top = (pad_height - from_height) // 2
pad_left = 0
elif to_ratio > from_ratio:
pad_width = int(to_width * (float(from_height) / to_height))
pad_size = (pad_width, from_height)
pad_top = 0
pad_left = (pad_width - from_width) // 2
if pad_size is not None:
pad_container = Image.new("RGBA", pad_size, padding_color)
pad_container.paste(image, (pad_left, pad_top))
image = pad_container
# Create the thumbnail.
to_size = (to_width, to_height)
to_pos = (left, top)
try:
image = ImageOps.fit(image, to_size, Image.ANTIALIAS, 0, to_pos)
image = image.save(thumb_path, filetype, quality=quality, **image_info)
# Push a remote copy of the thumbnail if MEDIA_URL is
# absolute.
if "://" in settings.MEDIA_URL:
with open(thumb_path, "rb") as f:
default_storage.save(thumb_url, File(f))
except Exception:
# If an error occurred, a corrupted image may have been saved,
# so remove it, otherwise the check for it existing will just
# return the corrupted image next time it's requested.
try:
os.remove(thumb_path)
except Exception:
pass
return image_url
return thumb_url
def test_time_struct(self):
d = time.localtime(1181399930.036952)
t = xmlrpclib.DateTime(d)
self.assertEqual(str(t), time.strftime("%Y%m%dT%H:%M:%S", d))
def anon_url(*url):
"""
Return a URL string consisting of the Anonymous redirect URL and an arbitrary number of values appended.
"""
return '' if None in url else '%s%s' % (plexpy.CONFIG.ANON_REDIRECT, ''.join(str(s) for s in url))
def test_repr(self):
f = xmlrpclib.Fault(42, 'Test Fault')
self.assertEqual(repr(f), "<Fault 42: 'Test Fault'>")
self.assertEqual(repr(f), str(f))
def _get_recently_added(self, media_type=None):
from plexpy.notification_handler import format_group_index
pms_connect = pmsconnect.PmsConnect()
recently_added = []
done = False
start = 0
while not done:
recent_items = pms_connect.get_recently_added_details(start=str(start), count='10', media_type=media_type)
filtered_items = [i for i in recent_items['recently_added']
if self.start_time < helpers.cast_to_int(i['added_at'])]
if len(filtered_items) < 10:
done = True
else:
start += 10
recently_added.extend(filtered_items)
if media_type in ('movie', 'other_video'):
movie_list = []
for item in recently_added:
# Filter included libraries
if item['section_id'] not in self.config['incl_libraries']:
continue
if self.start_time < helpers.cast_to_int(item['added_at']) < self.end_time:
movie_list.append(item)
recently_added = movie_list
if media_type == 'show':
shows_list = []
show_rating_keys = []
for item in recently_added:
# Filter included libraries
if item['section_id'] not in self.config['incl_libraries']:
continue
if item['media_type'] == 'show':
show_rating_key = item['rating_key']
elif item['media_type'] == 'season':
show_rating_key = item['parent_rating_key']
elif item['media_type'] == 'episode':
show_rating_key = item['grandparent_rating_key']
if show_rating_key in show_rating_keys:
continue
show_metadata = pms_connect.get_metadata_details(show_rating_key, media_info=False)
children = pms_connect.get_item_children(show_rating_key, media_type=media_type, get_grandchildren=True)
filtered_children = [i for i in children['children_list']
if self.start_time < helpers.cast_to_int(i['added_at']) < self.end_time]
filtered_children.sort(key=lambda x: helpers.cast_to_int(x['parent_media_index']))
if not filtered_children:
continue
seasons = []
for (index, title), children in groupby(filtered_children,
key=lambda x: (x['parent_media_index'], x['parent_title'])):
episodes = list(children)
num, num00 = format_group_index([helpers.cast_to_int(d['media_index']) for d in episodes])
seasons.append({'media_index': index,
'title': title,
'episode_range': num00,
'episode_count': len(episodes),
'episode': episodes})
num, num00 = format_group_index([helpers.cast_to_int(d['media_index']) for d in seasons])
show_metadata['season_range'] = num00
show_metadata['season_count'] = len(seasons)
show_metadata['season'] = seasons
shows_list.append(show_metadata)
show_rating_keys.append(show_rating_key)
recently_added = shows_list
if media_type == 'artist':
artists_list = []
artist_rating_keys = []
for item in recently_added:
# Filter included libraries
if item['section_id'] not in self.config['incl_libraries']:
continue
if item['media_type'] == 'artist':
artist_rating_key = item['rating_key']
elif item['media_type'] == 'album':
artist_rating_key = item['parent_rating_key']
elif item['media_type'] == 'track':
artist_rating_key = item['grandparent_rating_key']
if artist_rating_key in artist_rating_keys:
continue
artist_metadata = pms_connect.get_metadata_details(artist_rating_key, media_info=False)
children = pms_connect.get_item_children(artist_rating_key, media_type=media_type)
filtered_children = [i for i in children['children_list']
if self.start_time < helpers.cast_to_int(i['added_at']) < self.end_time]
filtered_children.sort(key=lambda x: x['added_at'])
if not filtered_children:
continue
albums = []
for a in filtered_children:
album_metadata = pms_connect.get_metadata_details(a['rating_key'], media_info=False)
album_metadata['track_count'] = helpers.cast_to_int(album_metadata['children_count'])
albums.append(album_metadata)
artist_metadata['album_count'] = len(albums)
artist_metadata['album'] = albums
artists_list.append(artist_metadata)
artist_rating_keys.append(artist_rating_key)
recently_added = artists_list
return recently_added
def convert_to_unicode(input_string):
if isinstance(input_string, str):
return input_string
else:
return str(input_string, encoding='utf8', errors='replace')
def test_pack(self):
writekey = b"\x01" * 16
fingerprint = b"\x02" * 32
n = uri.WriteableSSKFileURI(writekey, fingerprint)
u1 = uri.DirectoryURI(n)
self.failIf(u1.is_readonly())
self.failUnless(u1.is_mutable())
self.failUnless(IURI.providedBy(u1))
self.failIf(IFileURI.providedBy(u1))
self.failUnless(IDirnodeURI.providedBy(u1))
self.failUnless("DirectoryURI" in str(u1))
u1_filenode = u1.get_filenode_cap()
self.failUnless(u1_filenode.is_mutable())
self.failIf(u1_filenode.is_readonly())
u2 = uri.from_string(u1.to_string())
self.failUnlessReallyEqual(u1.to_string(), u2.to_string())
self.failIf(u2.is_readonly())
self.failUnless(u2.is_mutable())
self.failUnless(IURI.providedBy(u2))
self.failIf(IFileURI.providedBy(u2))
self.failUnless(IDirnodeURI.providedBy(u2))
u2i = uri.from_string(u1.to_string(), deep_immutable=True)
self.failUnless(isinstance(u2i, uri.UnknownURI))
u3 = u2.get_readonly()
self.failUnless(u3.is_readonly())
self.failUnless(u3.is_mutable())
self.failUnless(IURI.providedBy(u3))
self.failIf(IFileURI.providedBy(u3))
self.failUnless(IDirnodeURI.providedBy(u3))
u3i = uri.from_string(u2.to_string(), deep_immutable=True)
self.failUnless(isinstance(u3i, uri.UnknownURI))
u3n = u3._filenode_uri
self.failUnless(u3n.is_readonly())
self.failUnless(u3n.is_mutable())
u3_filenode = u3.get_filenode_cap()
self.failUnless(u3_filenode.is_mutable())
self.failUnless(u3_filenode.is_readonly())
u3a = uri.from_string(u3.to_string())
self.failUnlessIdentical(u3a, u3a.get_readonly())
u4 = uri.ReadonlyDirectoryURI(u2._filenode_uri.get_readonly())
self.failUnlessReallyEqual(u4.to_string(), u3.to_string())
self.failUnless(u4.is_readonly())
self.failUnless(u4.is_mutable())
self.failUnless(IURI.providedBy(u4))
self.failIf(IFileURI.providedBy(u4))
self.failUnless(IDirnodeURI.providedBy(u4))
u4_verifier = u4.get_verify_cap()
u4_verifier_filenode = u4_verifier.get_filenode_cap()
self.failUnless(isinstance(u4_verifier_filenode, uri.SSKVerifierURI))
verifiers = [u1.get_verify_cap(), u2.get_verify_cap(),
u3.get_verify_cap(), u4.get_verify_cap(),
uri.DirectoryURIVerifier(n.get_verify_cap()),
]
for v in verifiers:
self.failUnless(IVerifierURI.providedBy(v))
self.failUnlessReallyEqual(v._filenode_uri,
u1.get_verify_cap()._filenode_uri)
def retrieve_data(self):
from plexpy.notification_handler import get_img_info, set_hash_image_info
if not self.config['incl_libraries']:
logger.warn("Tautulli Newsletters :: Failed to retrieve %s newsletter data: no libraries selected." % self.NAME)
media_types = set()
for s in self._get_sections():
if str(s['section_id']) in self.config['incl_libraries']:
if s['section_type'] == 'movie' and s['agent'] == 'com.plexapp.agents.none':
media_types.add('other_video')
else:
media_types.add(s['section_type'])
recently_added = {}
for media_type in media_types:
if media_type not in recently_added:
recently_added[media_type] = self._get_recently_added(media_type)
movies = recently_added.get('movie', [])
shows = recently_added.get('show', [])
artists = recently_added.get('artist', [])
albums = [a for artist in artists for a in artist['album']]
other_video = recently_added.get('other_video', [])
if self.is_preview or helpers.get_img_service(include_self=True) == 'self-hosted':
for item in movies + shows + albums + other_video:
if item['media_type'] == 'album':
height = 150
fallback = 'cover'
else:
height = 225
fallback = 'poster'
item['thumb_hash'] = set_hash_image_info(
img=item['thumb'], width=150, height=height, fallback=fallback)
if item['art']:
item['art_hash'] = set_hash_image_info(
img=item['art'], width=500, height=280,
opacity=25, background='282828', blur=3, fallback='art')
else:
item['art_hash'] = ''
item['thumb_url'] = ''
item['art_url'] = ''
item['poster_url'] = item['thumb_url'] # Keep for backwards compatibility
elif helpers.get_img_service():
# Upload posters and art to image hosting service
for item in movies + shows + albums + other_video:
if item['media_type'] == 'album':
height = 150
fallback = 'cover'
else:
height = 225
fallback = 'poster'
img_info = get_img_info(
img=item['thumb'], rating_key=item['rating_key'], title=item['title'],
width=150, height=height, fallback=fallback)
item['thumb_url'] = img_info.get('img_url') or common.ONLINE_POSTER_THUMB
img_info = get_img_info(
img=item['art'], rating_key=item['rating_key'], title=item['title'],
width=500, height=280, opacity=25, background='282828', blur=3, fallback='art')
item['art_url'] = img_info.get('img_url')
item['thumb_hash'] = ''
item['art_hash'] = ''
item['poster_url'] = item['thumb_url'] # Keep for backwards compatibility
else:
for item in movies + shows + albums + other_video:
item['thumb_hash'] = ''
item['art_hash'] = ''
item['thumb_url'] = ''
item['art_url'] = ''
item['poster_url'] = item['thumb_url'] # Keep for backwards compatibility
self.data['recently_added'] = recently_added
return self.data
def in_menu_template(self, template_name):
if self.in_menus is not None:
for i, l, t in settings.PAGE_MENU_TEMPLATES:
if not str(i) in self.in_menus and t == template_name:
return False
return True
def set_newsletter_config(newsletter_id=None, agent_id=None, **kwargs):
if str(agent_id).isdigit():
agent_id = int(agent_id)
else:
logger.error("Tautulli Newsletters :: Unable to set existing newsletter: invalid agent_id %s."
% agent_id)
return False
agent = next((a for a in available_newsletter_agents() if a['id'] == agent_id), None)
if not agent:
logger.error("Tautulli Newsletters :: Unable to retrieve existing newsletter agent: invalid agent_id %s."
% agent_id)
return False
config_prefix = 'newsletter_config_'
email_config_prefix = 'newsletter_email_'
newsletter_config = {k[len(config_prefix):]: kwargs.pop(k)
for k in list(kwargs.keys()) if k.startswith(config_prefix)}
email_config = {k[len(email_config_prefix):]: kwargs.pop(k)
for k in list(kwargs.keys()) if k.startswith(email_config_prefix)}
for cfg, val in email_config.items():
# Check for a password config keys and a blank password from the HTML form
if 'password' in cfg and val == ' ':
# Get the previous password so we don't overwrite it with a blank value
old_newsletter_config = get_newsletter_config(newsletter_id=newsletter_id)
email_config[cfg] = old_newsletter_config['email_config'][cfg]
subject = kwargs.pop('subject')
body = kwargs.pop('body')
message = kwargs.pop('message')
agent_class = get_agent_class(agent_id=agent['id'],
config=newsletter_config, email_config=email_config,
subject=subject, body=body, message=message)
keys = {'id': newsletter_id}
values = {'agent_id': agent['id'],
'agent_name': agent['name'],
'agent_label': agent['label'],
'id_name': kwargs.get('id_name', ''),
'friendly_name': kwargs.get('friendly_name', ''),
'newsletter_config': json.dumps(agent_class.config),
'email_config': json.dumps(agent_class.email_config),
'subject': agent_class.subject,
'body': agent_class.body,
'message': agent_class.message,
'cron': kwargs.get('cron'),
'active': kwargs.get('active')
}
db = database.MonitorDatabase()
try:
db.upsert(table_name='newsletters', key_dict=keys, value_dict=values)
logger.info("Tautulli Newsletters :: Updated newsletter agent: %s (newsletter_id %s)."
% (agent['label'], newsletter_id))
newsletter_handler.schedule_newsletters(newsletter_id=newsletter_id)
blacklist_logger()
return True
except Exception as e:
logger.warn("Tautulli Newsletters :: Unable to update newsletter agent: %s." % e)
return False
def get_payload(self, i=None, decode=False):
"""Return a reference to the payload.
The payload will either be a list object or a string. If you mutate
the list object, you modify the message's payload in place. Optional
i returns that index into the payload.
Optional decode is a flag indicating whether the payload should be
decoded or not, according to the Content-Transfer-Encoding header
(default is False).
When True and the message is not a multipart, the payload will be
decoded if this header's value is `quoted-printable' or `base64'. If
some other encoding is used, or the header is missing, or if the
payload has bogus data (i.e. bogus base64 or uuencoded data), the
payload is returned as-is.
If the message is a multipart and the decode flag is True, then None
is returned.
"""
# Here is the logic table for this code, based on the email5.0.0 code:
# i decode is_multipart result
# ------ ------ ------------ ------------------------------
# None True True None
# i True True None
# None False True _payload (a list)
# i False True _payload element i (a Message)
# i False False error (not a list)
# i True False error (not a list)
# None False False _payload
# None True False _payload decoded (bytes)
# Note that Barry planned to factor out the 'decode' case, but that
# isn't so easy now that we handle the 8 bit data, which needs to be
# converted in both the decode and non-decode path.
if self.is_multipart():
if decode:
return None
if i is None:
return self._payload
else:
return self._payload[i]
# For backward compatibility, Use isinstance and this error message
# instead of the more logical is_multipart test.
if i is not None and not isinstance(self._payload, list):
raise TypeError('Expected list, got %s' % type(self._payload))
payload = self._payload
# cte might be a Header, so for now stringify it.
cte = str(self.get('content-transfer-encoding', '')).lower()
# payload may be bytes here.
if isinstance(payload, str):
payload = str(
payload) # for Python-Future, so surrogateescape works
if utils._has_surrogates(payload):
bpayload = payload.encode('ascii', 'surrogateescape')
if not decode:
try:
payload = bpayload.decode(
self.get_param('charset', 'ascii'), 'replace')
except LookupError:
payload = bpayload.decode('ascii', 'replace')
elif decode:
try:
bpayload = payload.encode('ascii')
except UnicodeError:
# This won't happen for RFC compliant messages (messages
# containing only ASCII codepoints in the unicode input).
# If it does happen, turn the string into bytes in a way
# guaranteed not to fail.
bpayload = payload.encode('raw-unicode-escape')
if not decode:
return payload
if cte == 'quoted-printable':
return utils._qdecode(bpayload)
elif cte == 'base64':
# XXX: this is a bit of a hack; decode_b should probably be factored
# out somewhere, but I haven't figured out where yet.
value, defects = decode_b(b''.join(bpayload.splitlines()))
for defect in defects:
self.policy.handle_defect(self, defect)
return value
elif cte in ('x-uuencode', 'uuencode', 'uue', 'x-uue'):
in_file = BytesIO(bpayload)
out_file = BytesIO()
try:
uu.decode(in_file, out_file, quiet=True)
return out_file.getvalue()
except uu.Error:
# Some decoding problem
return bpayload
if isinstance(payload, str):
return bpayload
return payload
def test_pack(self):
u = uri.WriteableSSKFileURI(self.writekey, self.fingerprint)
self.failUnlessReallyEqual(u.writekey, self.writekey)
self.failUnlessReallyEqual(u.fingerprint, self.fingerprint)
self.failIf(u.is_readonly())
self.failUnless(u.is_mutable())
self.failUnless(IURI.providedBy(u))
self.failUnless(IMutableFileURI.providedBy(u))
self.failIf(IDirnodeURI.providedBy(u))
self.failUnless("WriteableSSKFileURI" in str(u))
u2 = uri.from_string(u.to_string())
self.failUnlessReallyEqual(u2.writekey, self.writekey)
self.failUnlessReallyEqual(u2.fingerprint, self.fingerprint)
self.failIf(u2.is_readonly())
self.failUnless(u2.is_mutable())
self.failUnless(IURI.providedBy(u2))
self.failUnless(IMutableFileURI.providedBy(u2))
self.failIf(IDirnodeURI.providedBy(u2))
u2i = uri.from_string(u.to_string(), deep_immutable=True)
self.failUnless(isinstance(u2i, uri.UnknownURI), u2i)
u2ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u.to_string())
self.failUnless(isinstance(u2ro, uri.UnknownURI), u2ro)
u2imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u.to_string())
self.failUnless(isinstance(u2imm, uri.UnknownURI), u2imm)
u3 = u2.get_readonly()
readkey = hashutil.ssk_readkey_hash(self.writekey)
self.failUnlessReallyEqual(u3.fingerprint, self.fingerprint)
self.failUnlessReallyEqual(u3.readkey, readkey)
self.failUnless(u3.is_readonly())
self.failUnless(u3.is_mutable())
self.failUnless(IURI.providedBy(u3))
self.failUnless(IMutableFileURI.providedBy(u3))
self.failIf(IDirnodeURI.providedBy(u3))
u3i = uri.from_string(u3.to_string(), deep_immutable=True)
self.failUnless(isinstance(u3i, uri.UnknownURI), u3i)
u3ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u3.to_string())
self.failUnlessReallyEqual(u3.to_string(), u3ro.to_string())
u3imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u3.to_string())
self.failUnless(isinstance(u3imm, uri.UnknownURI), u3imm)
u4 = uri.ReadonlySSKFileURI(readkey, self.fingerprint)
self.failUnlessReallyEqual(u4.fingerprint, self.fingerprint)
self.failUnlessReallyEqual(u4.readkey, readkey)
self.failUnless(u4.is_readonly())
self.failUnless(u4.is_mutable())
self.failUnless(IURI.providedBy(u4))
self.failUnless(IMutableFileURI.providedBy(u4))
self.failIf(IDirnodeURI.providedBy(u4))
u4i = uri.from_string(u4.to_string(), deep_immutable=True)
self.failUnless(isinstance(u4i, uri.UnknownURI), u4i)
u4ro = uri.from_string(uri.ALLEGED_READONLY_PREFIX + u4.to_string())
self.failUnlessReallyEqual(u4.to_string(), u4ro.to_string())
u4imm = uri.from_string(uri.ALLEGED_IMMUTABLE_PREFIX + u4.to_string())
self.failUnless(isinstance(u4imm, uri.UnknownURI), u4imm)
u4a = uri.from_string(u4.to_string())
self.failUnlessReallyEqual(u4a, u4)
self.failUnless("ReadonlySSKFileURI" in str(u4a))
self.failUnlessIdentical(u4a.get_readonly(), u4a)
u5 = u4.get_verify_cap()
self.failUnless(IVerifierURI.providedBy(u5))
self.failUnlessReallyEqual(u5.get_storage_index(), u.get_storage_index())
u7 = u.get_verify_cap()
self.failUnless(IVerifierURI.providedBy(u7))
self.failUnlessReallyEqual(u7.get_storage_index(), u.get_storage_index())
def is_onlyws(self):
return self._initial_size == 0 and (not self or str(self).isspace())
def testRDFStruct(self):
tested = TestStruct()
# cant set integers for string attributes.
self.assertRaises(type_info.TypeValueError, setattr, tested, "foobar",
1)
# This is a string so a string assignment is good:
tested.foobar = "Hello"
self.assertEqual(tested.foobar, "Hello")
# This field must be another TestStruct instance..
self.assertRaises(ValueError, setattr, tested, "nested", "foo")
# Its ok to assign a compatible semantic protobuf.
tested.nested = TestStruct(foobar="nested_foo")
# Not OK to use the wrong semantic type.
self.assertRaises(ValueError, setattr, tested, "nested",
PartialTest1(int=1))
# Not OK to assign a serialized string - even if it is for the right type -
# since there is no type checking.
serialized = TestStruct(foobar="nested_foo").SerializeToString()
self.assertRaises(ValueError, setattr, tested, "nested", serialized)
# Nested accessors.
self.assertEqual(tested.nested.foobar, "nested_foo")
# Test repeated elements:
# Empty list is ok:
tested.repeated = []
self.assertEqual(tested.repeated, [])
tested.repeated = ["string"]
self.assertEqual(tested.repeated, ["string"])
self.assertRaises(type_info.TypeValueError, setattr, tested,
"repeated", [1, 2, 3])
# Coercing on assignment. This field is an RDFURN:
tested.urn = "www.example.com"
self.assertIsInstance(tested.urn, rdfvalue.RDFURN)
self.assertEqual(tested.urn, rdfvalue.RDFURN("www.example.com"))
# Test enums.
self.assertEqual(tested.type, 3)
self.assertEqual(tested.type.name, "THIRD")
tested.type = "FIRST"
self.assertEqual(tested.type, 1)
# Check that string assignments are case-insensitive.
tested.type = "second"
self.assertEqual(tested.type, 2)
tested.type = "ThIrD"
self.assertEqual(tested.type, 3)
# Non-valid types are rejected.
self.assertRaises(type_info.TypeValueError, setattr, tested, "type",
"Foo")
# Strings of digits should be accepted.
tested.type = "2"
self.assertEqual(tested.type, 2)
# unicode strings should be treated the same way.
tested.type = u"2"
self.assertEqual(tested.type, 2)
# Out of range values are permitted and preserved through serialization.
tested.type = 4
self.assertEqual(tested.type, 4)
serialized_type = str(tested.type).encode("utf-8")
tested.type = 1
tested.type = serialized_type
self.assertEqual(tested.type, 4)
def _make_checker_results(self, smap):
self._monitor.raise_if_cancelled()
healthy = True
report = []
summary = []
vmap = smap.make_versionmap()
recoverable = smap.recoverable_versions()
unrecoverable = smap.unrecoverable_versions()
if recoverable:
report.append("Recoverable Versions: " + "/".join([
"%d*%s" % (len(vmap[v]), smap.summarize_version(v))
for v in recoverable
]))
if unrecoverable:
report.append("Unrecoverable Versions: " + "/".join([
"%d*%s" % (len(vmap[v]), smap.summarize_version(v))
for v in unrecoverable
]))
if smap.unrecoverable_versions():
healthy = False
summary.append("some versions are unrecoverable")
report.append("Unhealthy: some versions are unrecoverable")
if len(recoverable) == 0:
healthy = False
summary.append("no versions are recoverable")
report.append("Unhealthy: no versions are recoverable")
if len(recoverable) > 1:
healthy = False
summary.append("multiple versions are recoverable")
report.append("Unhealthy: there are multiple recoverable versions")
if recoverable:
best_version = smap.best_recoverable_version()
report.append("Best Recoverable Version: " +
smap.summarize_version(best_version))
counters = self._count_shares(smap, best_version)
s = counters["count-shares-good"]
k = counters["count-shares-needed"]
N = counters["count-shares-expected"]
if s < N:
healthy = False
report.append("Unhealthy: best version has only %d shares "
"(encoding is %d-of-%d)" % (s, k, N))
summary.append("%d shares (enc %d-of-%d)" % (s, k, N))
elif unrecoverable:
healthy = False
# find a k and N from somewhere
first = list(unrecoverable)[0]
# not exactly the best version, but that doesn't matter too much
counters = self._count_shares(smap, first)
else:
# couldn't find anything at all
counters = {
"count-shares-good": 0,
"count-shares-needed": 3, # arbitrary defaults
"count-shares-expected": 10,
"count-good-share-hosts": 0,
"count-wrong-shares": 0,
}
corrupt_share_locators = []
problems = []
if self.bad_shares:
report.append("Corrupt Shares:")
summary.append("Corrupt Shares:")
for (server, shnum, f) in sorted(self.bad_shares, key=id):
serverid = server.get_serverid()
locator = (server, self._storage_index, shnum)
corrupt_share_locators.append(locator)
s = "%s-sh%d" % (server.get_name(), shnum)
if f.check(CorruptShareError):
ft = f.value.reason
else:
ft = str(f)
report.append(" %s: %s" % (s, ft))
summary.append(s)
p = (serverid, self._storage_index, shnum, f)
problems.append(p)
msg = ("CorruptShareError during mutable verify, "
"serverid=%(serverid)s, si=%(si)s, shnum=%(shnum)d, "
"where=%(where)s")
log.msg(format=msg,
serverid=server.get_name(),
si=base32.b2a(self._storage_index),
shnum=shnum,
where=ft,
level=log.WEIRD,
umid="EkK8QA")
sharemap = dictutil.DictOfSets()
for verinfo in vmap:
for (shnum, server, timestamp) in vmap[verinfo]:
shareid = "%s-sh%d" % (smap.summarize_version(verinfo), shnum)
sharemap.add(shareid, server)
if healthy:
summary = "Healthy"
else:
summary = "Unhealthy: " + " ".join(summary)
count_happiness = servers_of_happiness(sharemap)
cr = CheckResults(
from_string(self._node.get_uri()),
self._storage_index,
healthy=healthy,
recoverable=bool(recoverable),
count_happiness=count_happiness,
count_shares_needed=counters["count-shares-needed"],
count_shares_expected=counters["count-shares-expected"],
count_shares_good=counters["count-shares-good"],
count_good_share_hosts=counters["count-good-share-hosts"],
count_recoverable_versions=len(recoverable),
count_unrecoverable_versions=len(unrecoverable),
servers_responding=list(smap.get_reachable_servers()),
sharemap=sharemap,
count_wrong_shares=counters["count-wrong-shares"],
list_corrupt_shares=corrupt_share_locators,
count_corrupt_shares=len(corrupt_share_locators),
list_incompatible_shares=[],
count_incompatible_shares=0,
summary=summary,
report=report,
share_problems=problems,
servermap=smap.copy())
return cr
def decode_header(header):
"""Decode a message header value without converting charset.
Returns a list of (string, charset) pairs containing each of the decoded
parts of the header. Charset is None for non-encoded parts of the header,
otherwise a lower-case string containing the name of the character set
specified in the encoded string.
header may be a string that may or may not contain RFC2047 encoded words,
or it may be a Header object.
An email.errors.HeaderParseError may be raised when certain decoding error
occurs (e.g. a base64 decoding exception).
"""
# If it is a Header object, we can just return the encoded chunks.
if hasattr(header, '_chunks'):
return [(_charset._encode(string, str(charset)), str(charset))
for string, charset in header._chunks]
# If no encoding, just return the header with no charset.
if not ecre.search(header):
return [(header, None)]
# First step is to parse all the encoded parts into triplets of the form
# (encoded_string, encoding, charset). For unencoded strings, the last
# two parts will be None.
words = []
for line in header.splitlines():
parts = ecre.split(line)
first = True
while parts:
unencoded = parts.pop(0)
if first:
unencoded = unencoded.lstrip()
first = False
if unencoded:
words.append((unencoded, None, None))
if parts:
charset = parts.pop(0).lower()
encoding = parts.pop(0).lower()
encoded = parts.pop(0)
words.append((encoded, encoding, charset))
# Now loop over words and remove words that consist of whitespace
# between two encoded strings.
import sys
droplist = []
for n, w in enumerate(words):
if n > 1 and w[1] and words[n - 2][1] and words[n - 1][0].isspace():
droplist.append(n - 1)
for d in reversed(droplist):
del words[d]
# The next step is to decode each encoded word by applying the reverse
# base64 or quopri transformation. decoded_words is now a list of the
# form (decoded_word, charset).
decoded_words = []
for encoded_string, encoding, charset in words:
if encoding is None:
# This is an unencoded word.
decoded_words.append((encoded_string, charset))
elif encoding == 'q':
word = header_decode(encoded_string)
decoded_words.append((word, charset))
elif encoding == 'b':
paderr = len(
encoded_string) % 4 # Postel's law: add missing padding
if paderr:
encoded_string += '==='[:4 - paderr]
try:
word = base64mime.decode(encoded_string)
except binascii.Error:
raise HeaderParseError('Base64 decoding error')
else:
decoded_words.append((word, charset))
else:
raise AssertionError('Unexpected encoding: ' + encoding)
# Now convert all words to bytes and collapse consecutive runs of
# similarly encoded words.
collapsed = []
last_word = last_charset = None
for word, charset in decoded_words:
if isinstance(word, str):
word = bytes(word, 'raw-unicode-escape')
if last_word is None:
last_word = word
last_charset = charset
elif charset != last_charset:
collapsed.append((last_word, last_charset))
last_word = word
last_charset = charset
elif last_charset is None:
last_word += BSPACE + word
else:
last_word += word
collapsed.append((last_word, last_charset))
return collapsed
def testCSVPluginWithValuesOfSameType(self):
responses = []
for i in range(10):
responses.append(
rdf_client_fs.StatEntry(
pathspec=rdf_paths.PathSpec(path="/foo/bar/%d" % i,
pathtype="OS"),
st_mode=33184, # octal = 100640 => u=rw,g=r,o= => -rw-r-----
st_ino=1063090,
st_dev=64512,
st_nlink=1 + i,
st_uid=139592,
st_gid=5000,
st_size=0,
st_atime=1336469177,
st_mtime=1336129892,
st_ctime=1336129892))
zip_fd, prefix = self.ProcessValuesToZip(
{rdf_client_fs.StatEntry: responses})
self.assertEqual(
set(zip_fd.namelist()),
set([
"%s/MANIFEST" % prefix,
"%s/ExportedFile/from_StatEntry.csv" % prefix
]))
parsed_manifest = yaml.load(zip_fd.read("%s/MANIFEST" % prefix))
self.assertEqual(parsed_manifest,
{"export_stats": {
"StatEntry": {
"ExportedFile": 10
}
}})
with zip_fd.open("%s/ExportedFile/from_StatEntry.csv" %
prefix) as filedesc:
content = filedesc.read().decode("utf-8")
parsed_output = list(csv.DictReader(io.StringIO(content)))
self.assertLen(parsed_output, 10)
for i in range(10):
# Make sure metadata is filled in.
self.assertEqual(parsed_output[i]["metadata.client_urn"],
"aff4:/%s" % self.client_id)
self.assertEqual(parsed_output[i]["metadata.hostname"],
"Host-0.example.com")
self.assertEqual(parsed_output[i]["metadata.mac_address"],
"aabbccddee00\nbbccddeeff00")
self.assertEqual(parsed_output[i]["metadata.source_urn"],
self.results_urn)
self.assertEqual(
parsed_output[i]["metadata.hardware_info.bios_version"],
"Bios-Version-0")
self.assertEqual(parsed_output[i]["urn"],
"aff4:/%s/fs/os/foo/bar/%d" % (self.client_id, i))
self.assertEqual(parsed_output[i]["st_mode"], "-rw-r-----")
self.assertEqual(parsed_output[i]["st_ino"], "1063090")
self.assertEqual(parsed_output[i]["st_dev"], "64512")
self.assertEqual(parsed_output[i]["st_nlink"], str(1 + i))
self.assertEqual(parsed_output[i]["st_uid"], "139592")
self.assertEqual(parsed_output[i]["st_gid"], "5000")
self.assertEqual(parsed_output[i]["st_size"], "0")
self.assertEqual(parsed_output[i]["st_atime"],
"2012-05-08 09:26:17")
self.assertEqual(parsed_output[i]["st_mtime"],
"2012-05-04 11:11:32")
self.assertEqual(parsed_output[i]["st_ctime"],
"2012-05-04 11:11:32")
self.assertEqual(parsed_output[i]["st_blksize"], "0")
self.assertEqual(parsed_output[i]["st_rdev"], "0")
self.assertEqual(parsed_output[i]["symlink"], "")
def __eq__(self, other):
# other may be a Header or a string. Both are fine so coerce
# ourselves to a unicode (of the unencoded header value), swap the
# args and do another comparison.
return other == str(self)
def __init__(self,
form,
request,
formentry_model=FormEntry,
fieldentry_model=FieldEntry,
*args,
**kwargs):
"""
Iterate through the fields of the ``forms.models.Form`` instance and
create the form fields required to control including the field in
the export (with a checkbox) or filtering the field which differs
across field types. User a list of checkboxes when a fixed set of
choices can be chosen from, a pair of date fields for date ranges,
and for all other types provide a textbox for text search.
"""
self.form = form
self.request = request
self.formentry_model = formentry_model
self.fieldentry_model = fieldentry_model
self.form_fields = form.fields.all()
self.entry_time_name = str(
self.formentry_model._meta.get_field("entry_time").verbose_name)
super(EntriesForm, self).__init__(*args, **kwargs)
for field in self.form_fields:
field_key = "field_%s" % field.id
# Checkbox for including in export.
self.fields["%s_export" % field_key] = forms.BooleanField(
label=field.label, initial=True, required=False)
if field.is_a(*fields.CHOICES):
# A fixed set of choices to filter by.
if field.is_a(fields.CHECKBOX):
choices = ((True, _("Checked")), (False, _("Not checked")))
else:
choices = field.get_choices()
contains_field = forms.MultipleChoiceField(
label=" ",
choices=choices,
widget=forms.CheckboxSelectMultiple(),
required=False)
self.fields["%s_filter" % field_key] = choice_filter_field
self.fields["%s_contains" % field_key] = contains_field
elif field.is_a(*fields.MULTIPLE):
# A fixed set of choices to filter by, with multiple
# possible values in the entry field.
contains_field = forms.MultipleChoiceField(
label=" ",
choices=field.get_choices(),
widget=forms.CheckboxSelectMultiple(),
required=False)
self.fields["%s_filter" % field_key] = multiple_filter_field
self.fields["%s_contains" % field_key] = contains_field
elif field.is_a(*fields.DATES):
# A date range to filter by.
self.fields["%s_filter" % field_key] = date_filter_field
self.fields["%s_from" % field_key] = forms.DateField(
label=" ", widget=SelectDateWidget(), required=False)
self.fields["%s_to" % field_key] = forms.DateField(
label=_("and"), widget=SelectDateWidget(), required=False)
else:
# Text box for search term to filter by.
contains_field = forms.CharField(label=" ", required=False)
self.fields["%s_filter" % field_key] = text_filter_field
self.fields["%s_contains" % field_key] = contains_field
# Add ``FormEntry.entry_time`` as a field.
field_key = "field_0"
label = self.formentry_model._meta.get_field("entry_time").verbose_name
self.fields["%s_export" % field_key] = forms.BooleanField(
initial=True, label=label, required=False)
self.fields["%s_filter" % field_key] = date_filter_field
self.fields["%s_from" % field_key] = forms.DateField(
label=" ", widget=SelectDateWidget(), required=False)
self.fields["%s_to" % field_key] = forms.DateField(
label=_("and"), widget=SelectDateWidget(), required=False)
from distutils import sysconfig
from obspy import UTCDateTime
import ctypes as C
import doctest
import numpy as np
import os
import platform
import warnings
# Import shared libgse2
# create library names
lib_names = [
# python3.3 platform specific library name
'libgse2_%s_%s_py%s.cpython-%sm' %
(platform.system(), platform.architecture()[0], ''.join([
str(i) for i in platform.python_version_tuple()[:2]
]), ''.join([str(i) for i in platform.python_version_tuple()[:2]])),
# platform specific library name
'libgse2_%s_%s_py%s' %
(platform.system(), platform.architecture()[0], ''.join(
[str(i) for i in platform.python_version_tuple()[:2]])),
# fallback for pre-packaged libraries
'libgse2'
]
# get default file extension for shared objects
lib_extension, = sysconfig.get_config_vars('SO')
# initialize library
for lib_name in lib_names:
try:
clibgse2 = C.CDLL(
os.path.join(os.path.dirname(__file__), os.pardir, 'lib',