input
stringlengths 2.65k
237k
| output
stringclasses 1
value |
|---|---|
# Copyright (c) 2016 Presslabs SRL
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from datetime import datetime, timedelta
from decimal import Decimal
from annoying.fields import JSONField
from django_fsm import FSMField, transition, TransitionNotAllowed, post_transition
from model_utils import Choices
from django.apps import apps
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from django.core.exceptions import ValidationError, NON_FIELD_ERRORS
from django.urls import reverse
from django.core.validators import MinValueValidator
from django.db import models
from django.db import transaction as db_transaction
from django.db.models import Max, ForeignKey, F
from django.template.loader import select_template
from django.utils import timezone
from django.utils.encoding import python_2_unicode_compatible, force_text
from django.utils.text import slugify
from django.utils.translation import ugettext_lazy as _
from django.utils.module_loading import import_string
from silver.currencies import CurrencyConverter, RateNotFound
from silver.models.billing_entities import Customer, Provider
from silver.models.documents.entries import DocumentEntry
from silver.models.documents.pdf import PDF
from silver.utils.international import currencies
_storage = getattr(settings, 'SILVER_DOCUMENT_STORAGE', None)
if _storage:
_storage_klass = import_string(_storage[0])
_storage = _storage_klass(*_storage[1], **_storage[2])
PAYMENT_DUE_DAYS = getattr(settings, 'SILVER_DEFAULT_DUE_DAYS', 5)
logger = logging.getLogger(__name__)
def documents_pdf_path(document, filename):
path = '{prefix}{company}/{doc_name}/{date}/{filename}'.format(
company=slugify(force_text(
document.provider.company or document.provider.name)),
date=document.issue_date.strftime('%Y/%m'),
doc_name=('%ss' % document.__class__.__name__).lower(),
prefix=getattr(settings, 'SILVER_DOCUMENT_PREFIX', ''),
filename=filename)
return path
class BillingDocumentQuerySet(models.QuerySet):
def due_this_month(self):
return self.filter(
state=BillingDocumentBase.STATES.ISSUED,
due_date__gte=timezone.now().date().replace(day=1)
)
def due_today(self):
return self.filter(
state=BillingDocumentBase.STATES.ISSUED,
due_date__exact=timezone.now().date()
)
def overdue(self):
return self.filter(
state=BillingDocumentBase.STATES.ISSUED,
due_date__lt=timezone.now().date()
)
def overdue_since_last_month(self):
return self.filter(
state=BillingDocumentBase.STATES.ISSUED,
due_date__lt=timezone.now().date().replace(day=1)
)
class BillingDocumentManager(models.Manager):
def get_queryset(self):
return super(BillingDocumentManager, self).get_queryset() \
.select_related('customer', 'provider',
'related_document')
def get_billing_documents_kinds():
return ((subclass.__name__.lower(), subclass.__name__)
for subclass in BillingDocumentBase.__subclasses__())
@python_2_unicode_compatible
class BillingDocumentBase(models.Model):
objects = BillingDocumentManager.from_queryset(BillingDocumentQuerySet)()
class STATES(object):
DRAFT = 'draft'
ISSUED = 'issued'
PAID = 'paid'
CANCELED = 'canceled'
STATE_CHOICES = Choices(
(STATES.DRAFT, _('Draft')),
(STATES.ISSUED, _('Issued')),
(STATES.PAID, _('Paid')),
(STATES.CANCELED, _('Canceled'))
)
kind = models.CharField(get_billing_documents_kinds, max_length=8, db_index=True)
related_document = models.ForeignKey('self', blank=True, null=True,
related_name='reverse_related_document', on_delete=models.CASCADE)
series = models.CharField(max_length=20, blank=True, null=True,
db_index=True)
number = models.IntegerField(blank=True, null=True, db_index=True)
customer = models.ForeignKey('Customer', on_delete=models.CASCADE)
provider = models.ForeignKey('Provider', on_delete=models.CASCADE)
archived_customer = JSONField(default=dict, null=True, blank=True)
archived_provider = JSONField(default=dict, null=True, blank=True)
due_date = models.DateField(null=True, blank=True)
issue_date = models.DateField(null=True, blank=True, db_index=True)
paid_date = models.DateField(null=True, blank=True)
cancel_date = models.DateField(null=True, blank=True)
sales_tax_percent = models.DecimalField(max_digits=4, decimal_places=2,
validators=[MinValueValidator(0.0)],
null=True, blank=True)
sales_tax_name = models.CharField(max_length=64, blank=True, null=True)
currency = models.CharField(
choices=currencies, max_length=4, default='USD',
help_text='The currency used for billing.'
)
transaction_currency = models.CharField(
choices=currencies, max_length=4,
help_text='The currency used when making a transaction.'
)
transaction_xe_rate = models.DecimalField(
max_digits=16, decimal_places=4, null=True, blank=True,
help_text='Currency exchange rate from document currency to '
'transaction_currency.'
)
transaction_xe_date = models.DateField(
null=True, blank=True,
help_text='Date of the transaction exchange rate.'
)
pdf = ForeignKey(PDF, null=True, on_delete=models.CASCADE)
state = FSMField(choices=STATE_CHOICES, max_length=10, default=STATES.DRAFT,
verbose_name="State",
help_text='The state the invoice is in.')
_total = models.DecimalField(max_digits=19, decimal_places=2,
null=True, blank=True)
_total_in_transaction_currency = models.DecimalField(max_digits=19,
decimal_places=2,
null=True, blank=True)
_last_state = None
_document_entries = None
class Meta:
unique_together = ('kind', 'provider', 'series', 'number')
ordering = ('-issue_date', 'series', '-number')
def __init__(self, *args, **kwargs):
super(BillingDocumentBase, self).__init__(*args, **kwargs)
if not self.kind:
self.kind = self.__class__.__name__.lower()
else:
for subclass in BillingDocumentBase.__subclasses__():
if subclass.__name__.lower() == self.kind:
self.__class__ = subclass
self._last_state = self.state
def _get_entries(self):
if not self._document_entries:
self._document_entries = getattr(self, self.kind + '_entries').all()
return self._document_entries
def compute_total_in_transaction_currency(self):
return sum([Decimal(entry.total_in_transaction_currency)
for entry in self._get_entries()])
def compute_total(self):
return sum([Decimal(entry.total)
for entry in self._get_entries()])
def mark_for_generation(self):
self.pdf.mark_as_dirty()
def _issue(self, issue_date=None, due_date=None):
if issue_date:
self.issue_date = datetime.strptime(issue_date, '%Y-%m-%d').date()
elif not self.issue_date and not issue_date:
self.issue_date = timezone.now().date()
if not self.transaction_xe_rate:
if not self.transaction_xe_date:
self.transaction_xe_date = self.issue_date
try:
xe_rate = CurrencyConverter.convert(1, self.currency,
self.transaction_currency,
self.transaction_xe_date)
except RateNotFound:
raise TransitionNotAllowed('Couldn\'t automatically obtain an '
'exchange rate.')
self.transaction_xe_rate = xe_rate
if due_date:
self.due_date = datetime.strptime(due_date, '%Y-%m-%d').date()
elif not self.due_date and not due_date:
delta = timedelta(days=PAYMENT_DUE_DAYS)
self.due_date = timezone.now().date() + delta
if not self.sales_tax_name:
self.sales_tax_name = self.customer.sales_tax_name
if not self.sales_tax_percent:
self.sales_tax_percent = self.customer.sales_tax_percent
if not self.number:
self.number = self._generate_number()
self.archived_customer = self.customer.get_archivable_field_values()
self._total = self.compute_total()
self._total_in_transaction_currency = self.compute_total_in_transaction_currency()
@transition(field=state, source=STATES.DRAFT, target=STATES.ISSUED)
def issue(self, issue_date=None, due_date=None):
self._issue(issue_date=issue_date, due_date=due_date)
def _pay(self, paid_date=None):
if paid_date:
self.paid_date = datetime.strptime(paid_date, '%Y-%m-%d').date()
if not self.paid_date and not paid_date:
self.paid_date = timezone.now().date()
@transition(field=state, source=STATES.ISSUED, target=STATES.PAID)
def pay(self, paid_date=None):
self._pay(paid_date=paid_date)
def _cancel(self, cancel_date=None):
if cancel_date:
self.cancel_date = datetime.strptime(cancel_date, '%Y-%m-%d').date()
if not self.cancel_date and not cancel_date:
self.cancel_date = timezone.now().date()
@transition(field=state, source=STATES.ISSUED, target=STATES.CANCELED)
def cancel(self, cancel_date=None):
self._cancel(cancel_date=cancel_date)
def sync_related_document_state(self):
if self.related_document and self.state != self.related_document.state:
state_transition_map = {
BillingDocumentBase.STATES.ISSUED: 'issue',
BillingDocumentBase.STATES.CANCELED: 'cancel',
BillingDocumentBase.STATES.PAID: 'pay'
}
transition_name = state_transition_map[self.state]
bound_transition_method = getattr(self.related_document, transition_name)
bound_transition_method()
def clone_into_draft(self):
copied_fields = {
'customer': self.customer,
'provider': self.provider,
'currency': self.currency,
'sales_tax_percent': self.sales_tax_percent,
'sales_tax_name': self.sales_tax_name
}
clone = self.__class__._default_manager.create(**copied_fields)
clone.state = self.STATES.DRAFT
# clone entries too
for entry in self._entries:
entry_clone = entry.clone()
document_type_name = self.__class__.__name__.lower()
setattr(entry_clone, document_type_name, clone)
entry_clone.save()
clone.save()
return clone
def clean(self):
super(BillingDocumentBase, self).clean()
# The only change that is allowed if the document is in issued state
# is the state chage from issued to paid
# !! TODO: If _last_state == 'issued' and self.state == 'paid' || 'canceled'
# it should also be checked that the other fields are the same bc.
# right now a document can be in issued state and someone could
# send a request which contains the state = 'paid' and also send
# other changed fields and the request would be accepted bc. only
# the state is verified.
if self._last_state == self.STATES.ISSUED and\
self.state not in [self.STATES.PAID, self.STATES.CANCELED]:
msg = 'You cannot edit the document once it is in issued state.'
raise ValidationError({NON_FIELD_ERRORS: msg})
if self._last_state == self.STATES.CANCELED:
msg = 'You cannot edit the document once it is in canceled state.'
raise ValidationError({NON_FIELD_ERRORS: msg})
# If it's in paid state => don't allow any changes
if self._last_state == self.STATES.PAID:
msg = 'You cannot edit the document once it is in paid state.'
raise ValidationError({NON_FIELD_ERRORS: msg})
if self.transactions.exclude(currency=self.transaction_currency).exists():
message = 'There are unfinished transactions of this document that use a ' \
'different currency.'
raise ValidationError({'transaction_currency': message})
def save(self, *args, **kwargs):
if not self.transaction_currency:
self.transaction_currency = self.customer.currency or self.currency
if not self.series:
self.series = self.default_series
# Generate the number
if not self.number and self.state != BillingDocumentBase.STATES.DRAFT:
self.number = self._generate_number()
# Add tax info
if not self.sales_tax_name:
self.sales_tax_name = self.customer.sales_tax_name
if not self.sales_tax_percent:
self.sales_tax_percent = self.customer.sales_tax_percent
self._last_state = self.state
with db_transaction.atomic():
# Create pdf object
if not self.pdf and self.state != self.STATES.DRAFT:
self.pdf = PDF.objects.create(upload_path=self.get_pdf_upload_path(), dirty=1)
super(BillingDocumentBase, self).save(*args, **kwargs)
def _generate_number(self, default_starting_number=1):
"""Generates the number for a proforma/invoice."""
default_starting_number = max(default_starting_number, 1)
documents = self.__class__._default_manager.filter(
provider=self.provider, series=self.series
)
if not documents.exists():
# An invoice/proforma with this provider and series does not exist
if self.series == self.default_series:
return self._starting_number
else:
return default_starting_number
else:
# An invoice with this provider and series already exists
max_existing_number = documents.aggregate(
Max('number')
)['number__max']
if max_existing_number:
if self._starting_number and self.series == self.default_series:
return max(max_existing_number + 1, self._starting_number)
else:
return max_existing_number + 1
else:
return default_starting_number
def series_number(self):
if self.series:
if self.number:
return "%s-%d" % (self.series, self.number)
else:
return "%s-draft-id:%d" % (self.series, self.pk)
else:
return "draft-id:%d" % self.pk
series_number.short_description = 'Number'
series_number = property(series_number)
def __str__(self):
return '%s %s => %s [%.2f %s]' % (self.series_number,
self.provider.billing_name,
self.customer.billing_name,
self.total, self.currency)
@property
def updateable_fields(self):
return ['customer', 'provider', 'due_date', 'issue_date', 'paid_date',
'cancel_date', 'sales_tax_percent', 'sales_tax_name',
'currency']
@property
def admin_change_url(self):
url_base = 'admin:{app_label}_{klass}_change'.format(
app_label=self._meta.app_label,
klass=self.__class__.__name__.lower())
url = reverse(url_base, args=(self.pk,))
return '<a href="{url}">{display_series}</a>'.format(
url=url, display_series=self.series_number)
@property
def _entries(self):
# entries iterator which replaces the invoice/proforma from the DB with
# self. We need this in generate_pdf so that the data in PDF has the
# lastest state for the document. Without this we get in template:
#
# invoice.issue_date != entry.invoice.issue_date
#
# which is obviously false.
document_type_name = self.__class__.__name__ # Invoice or Proforma
kwargs = {document_type_name.lower(): self}
entries = DocumentEntry.objects.filter(**kwargs)
for entry in entries:
if document_type_name.lower() == 'invoice':
entry.invoice = self
if document_type_name.lower() == 'proforma':
entry.proforma = self
yield(entry)
def get_template_context(self, state=None):
customer = Customer(**self.archived_customer)
provider = Provider(**self.archived_provider)
if state is None:
state = self.state
return {
'document': self,
'provider': provider,
'customer': customer,
'entries': self._entries,
'state': state
}
def get_template(self, | |
The most general expression for the conductivity is given by the Kubo formula
.. math::
\\sigma(q,\\omega)=\\frac{ie^2\\omega}{q^2}\\chi^0(q,\\omega).
where :math:`\\chi^0` is the Polarizibility. If ``q`` is nonzero, this form is used.
However, it is common to use a simpler limiting cases of this expression.
The local conductivity (called when ``q==0``) is the one which is most familiar
and it relates the surface current to the electric field linearly
.. math::
\\mathbf K(\\omega)=\\sigma(\\omega)\\mathbf E
It can be found from the nonlocal conductivity by taking the limit :math:`\\lim_{q\\to 0}\\sigma(q,\\omega)=\\sigma(\\omega)`
and takes the form :math:`\\sigma(\\omega)=\\sigma_{intra}(\\omega)+\\sigma_{inter}(\\omega)`,
where the intraband and interband components are given by
.. math::
\\sigma_{intra}(\\omega) = \\frac{2ie^2k_BT}{\\pi\\hbar^2(\\omega+i\\gamma)}\\ln\\left [ 2 \\cosh \\frac{E_F}{2k_BT} \\right ]
and
.. math::
\\sigma_{inter}(\\omega) = \\frac{e^2}{4\\hbar}\\left [ H(\\hbar\\omega/2) + \\frac{4i}{\\pi}\\hbar ( \\omega +i \\gamma )\\int_0^\\infty \\frac{H( \\epsilon )-H(\\hbar\\omega /2)}{\\hbar^2(\\omega +i\\gamma )^2-4\\epsilon^2} d\\epsilon\\right ]
where
.. math::
H(\\epsilon) = f(-\\epsilon)-f(\\epsilon) = \\frac{\\sinh(\\epsilon/k_BT)}{\\cosh(E_F/k_BT) + \\cosh(\\epsilon/k_BT)}
For ``T=0`` these expressions reduce to
.. math::
\\sigma_{intra}(\\omega) = \\frac{ie^2E_F}{\\pi\\hbar^2(\\omega+i\\gamma)}
.. math::
\\sigma_{inter}(\\omega) = \\frac{e^2}{4\\hbar}\\left [ \\Theta(\\hbar\\omega - 2E_F) + \\frac{i}{\\pi} \\ln\\left [\\frac{2E_F-\\hbar\\omega}{2E_F+\\hbar\\omega} \\right ] \\right ]
References
----------
[1] <NAME>. (2017).
From Classical to Quantum Plasmonics in Three and Two Dimensions (Cham: Springer International Publishing).
http://link.springer.com/10.1007/978-3-319-48562-1
'''
# Local case
if np.all(q) == 0:
if T!=0:
intra_pre = 4 * _c.sigma_0 * (2*1j*sc.k*T) / (sc.pi*sc.hbar)
inter_pre = _c.sigma_0
### Intraband Contribution ###
# Using np.logaddexp() avoids the large cosh in ln( cosh(1/T) )
x = FermiLevel / (2*sc.k*T)
intra = lambda w: intra_pre * ( 1 / (w + 1j*gamma) ) * np.logaddexp(x,-x)
### Interband Contribution ###
H = lambda energy: sd.FermiDirac(-energy-FermiLevel,T) - sd.FermiDirac(energy-FermiLevel,T)
integrand = lambda energy,w: ( H(energy) - H(sc.hbar*w/2) ) / (sc.hbar**2 * (w + 1j*gamma)**2 - 4 * energy**2)
def integral(w):
result = np.empty_like(w,dtype=complex)
for i, frequency in np.ndenumerate(w):
integrand_re = lambda e: np.real(integrand(e,frequency))
integrand_im = lambda e: np.imag(integrand(e,frequency))
result[i] =( integrate.quad(integrand_re,0,10*FermiLevel,points=(FermiLevel/sc.hbar,2*FermiLevel/sc.hbar))[0]
+ 1j*integrate.quad(integrand_im,0,10*FermiLevel,points=(FermiLevel/sc.hbar,2*FermiLevel/sc.hbar))[0] )
return result
inter = lambda w: inter_pre * ( H(sc.hbar * w / 2) +
(4*1j/sc.pi) * sc.hbar*(w + 1j*gamma)*integral(w) )
conductivity= intra(omega) + inter(omega)
if T==0:
intra = lambda w: 1j*_c.sigma_0 * 4*FermiLevel / (sc.pi*sc.hbar* (w + 1j*gamma))
inter = lambda w: _c.sigma_0 * ( np.heaviside(sc.hbar*w - 2*FermiLevel,0.5) +
(1j/sc.pi) * np.log(np.abs((2*FermiLevel-sc.hbar*w)/(2*FermiLevel+sc.hbar*w))))
conductivity = intra(omega) + inter(omega)
# Nonlocal case
else:
if T==0:
conductivity = 1j*sc.elementary_charge**2 * (omega / q**2) * Polarizibility(q,omega,gamma,FermiLevel,T)
else:
pass
return conductivity
def OpticalConductivityMatrix(q,omega,gamma, FermiLevel,T):
'''
Returns the conductivity matrix of monolayer graphene.
Parameters
----------
q: array-like, rad/m
Wavenumber
omega: array-like, rad/s
Angular frequency
FermiLevel: scalar, J
the Fermi energy
gamma: scalar, rad/s
scattering rate
T: scalar, K
Temperature
Returns
----------
sigma_matrix: 2x2 numpy array, conductivity of monolayer graphene
'''
conductivity_matrix = np.array([[ScalarOpticalConductivity(q,omega,gamma,FermiLevel,T),0],
[0,ScalarOpticalConductivity(q,omega,gamma,FermiLevel,T)]])
return conductivity_matrix
def Permittivity(q, omega,FermiLevel,T, gamma,epsR,model=None):
'''
Returns the in-plane permittivity of graphene.
Parameters
----------
q: array-like, rad/m
Wavenumber
omega: array-like, rad/s
Angular frequency
epsR: scalar, unitless
background relative permittivity
Notes
-----
Permittivity relates to the scalar optical conductivity through the expression
.. math::
\\epsilon(q, \\omega) = \\epsilon_0 + \\frac{i\\sigma(q,\\omega)}{\\omega}
At :math:`\\omega=0`, we can use the expression found in Ref. 2,
.. math::
\\epsilon(q) = \\kappa^* + \\frac{2\\pi e^2}{\\kappa q}\\Pi^+(q)
References
----------
[1] “Lumerical: Modeling Methodology.” n.d. Accessed April 1, 2019.
https://apps.lumerical.com/other_application_graphene_simulation_tips.html.
[2] <NAME>., and <NAME>. (2007).
Dielectric function, screening, and plasmons in two-dimensional graphene.
Phys. Rev. B 75, 205418. https://link.aps.org/doi/10.1103/PhysRevB.75.205418.
'''
if model=='Lumerical:Falkovsky':
'''
Use eqn 10 of Ref 1
'''
x1 = sc.elementary_charge
x2 = sc.hbar
x3 = FermiLevel
x4 = _c.vF
x5 = Mobility(T,mu0,mu0T) # mobility at the new temperature
x6 = epsR
x7 = _c.thickness # 3.4 angstroms by default
x8 = sc.epsilon_0
prefactor = x1**2*x3 / ( sc.pi * x2**2)
denominator = omega**2 + ( x1*x4**2 / (x5*x3) )**2
term1 = - prefactor*(omega*x8*x7)**(-1) * omega / denominator
term2 = 1j*prefactor * (x1*x4**2 / (omega*x5*x3*x8*x7)) / denominator
eps = x6 + term1 + term2
return sc.epsilon_0*eps
elif np.all(omega==0):
pass
else:
eps = 1 + 1j*ScalarOpticalConductivity(q,omega,gamma,FermiLevel,T,model)/(omega*sc.epsilon_0)
return eps
def FresnelReflection(q,omega,gamma,FermiLevel,T,eps1,eps2,polarization):
'''
The Fresnel Reflection coefficients of light incident from above (medium 1, eps1).
Equation 5.4 of Ref 1
Parameters
----------
q: array-like, rad/m
Wavenumber at which to evaluate FresnelReflection.
In-plane momentum of incident light.
omega: array-like, rad/s
Angular frequency of incident light.
eps1: scalar, unitless
Permittivity in upper half-space
eps2: scalar, unitless
Permittivity in lower half-space
polarization: string
's'/'TE' or 'p'/'TM' for s- or p-polarization.
Examples
--------
Plot the TM polarized Fresnel Reflection coefficient. This will highlight the plasmon.
Replicates Fig. 5.2 in Ref [1].
.. plot::
>>> import matplotlib.pyplot as plt
>>> import matplotlib.cm as cm
>>> from graphenemodeling.graphene import monolayer as mlg
>>> from scipy.constants import elementary_charge, hbar
>>> eV = elementary_charge
>>> FermiLevel = 0.4 * eV
>>> gamma = 0.012 * eV / hbar
>>> kF = mlg.FermiWavenumber(FermiLevel,model='LowEnergy')
>>> q = np.linspace(1e-2,3,num=200) * kF
>>> w = np.linspace(1e-2,3,num=200) * FermiLevel / hbar
>>> fresnelTM = mlg.FresnelReflection(q,w[:,np.newaxis],gamma,FermiLevel,T=0,
... eps1=1,eps2=1,
... polarization='TM')
>>> fig, ax = plt.subplots(figsize=(6,6))
>>> ax.imshow(-np.imag(fresnelTM),
... extent=(q[0]/kF,q[-1]/kF,hbar*w[0]/FermiLevel,hbar*w[-1]/FermiLevel),
... origin='lower',aspect='auto',cmap=cm.hot,vmin=-16,vmax=0)
>>> ax.set_xlabel('$q/k_F$')
>>> ax.set_ylabel('$\\hbar\\omega/E_F$')
>>> ax.set_ylim(0,3)
>>> ax.set_xlim(0,3)
>>> fig.suptitle('Fresnel Reflection Coefficient (TM)')
>>> plt.show()
References
----------
[1] <NAME>. (2017).
From Classical to Quantum Plasmonics in Three and Two Dimensions (Cham: Springer International Publishing).
http://link.springer.com/10.1007/978-3-319-48562-1.
'''
kperp1, kperp2 = np.sqrt(eps1*(omega/sc.speed_of_light)**2 - q**2 + 1e-9*1j), np.sqrt(eps2*(omega/sc.speed_of_light)**2 - q**2 + 1e-9*1j)
sigma = ScalarOpticalConductivity(q,omega,gamma,FermiLevel,T)
if polarization=='p' or polarization=='TM':
numerator = eps2*kperp1 - eps1*kperp2 + ( sigma*kperp1*kperp2 / (sc.epsilon_0*omega) )
denominator = eps2*kperp1 + eps1*kperp2 + ( sigma*kperp1*kperp2 / (sc.epsilon_0*omega) )
if polarization=='s' or polarization=='TE':
numerator = kperp1 - kperp2 - sc.mu_0*omega*sigma
denominator = kperp1 + kperp2 + sc.mu_0*omega*sigma
return numerator / denominator
def LocalDensityOfStates(d,omega,gamma,FermiLevel,T):
'''
The LDOS a distance d above a plane of graphene.
Eqn 44 of SM of Ref 1
Assuning plane in vauum for now.
References
-----------
[1] Miller et al. 2017
'''
k0 = (omega/sc.speed_of_light)
ldos0 = k0**2 / (2*sc.pi**2*sc.speed_of_light) # Free space LDOS
integral = np.empty_like(d)
for i, d0 in np.ndenumerate(d):
k0w = (omega/sc.speed_of_light)
Im_rp = lambda q: np.imag( FresnelReflection(q,omega,gamma,FermiLevel,T,1,1,'p') )
integrand = lambda q: (q**2/k0w**3)*Im_rp(q)*np.exp(-2*q*d0)
a,b = 1e-3, np.abs(_c.K) # Increasing this bound does not lead to more convergence
q_plasmon=InversePlasmonDispersion(omega,gamma,FermiLevel,1,1,T,model='nonlocal')
integral[i] = integrate.quad(integrand,a,b,
points=(q_plasmon),limit=100)[0]
return ldos0 * integral
#####################
# Phonon Properties #
#####################
def PhononSelfEnergy():
pass
##############
# Plasmonics #
##############
def PlasmonDispersion(q,gamma,FermiLevel,eps1,eps2,T,model):
'''
Returns the nonretarded plasmon dispersion relations E(q) for a surface
plasmon in an infinite sheet of graphene sandwiched between two
dielectrics eps1 and eps2.
All values returned are assumed to be at zero temperature with no loss (gamma).
Parameters
----------
q: array-like, rad/m
Wavenumber of the plasmon
eps1: scalar, unitless
Permittivity in upper half-space
eps2: scalar, unitless
Permittivity in lower half-space
model: string
'intra' for intraband dispersion,
'local' uses the intraband + interband constributions to the conductivity, and
'nonlocal' for fully nonlocal conductivity.
Returns
-------
omega: array-like
Frequency of the plasmon with wavenumber q
Notes
-----
``model=='intra'`` uses
.. math::
\\omega = \\frac{1}{\\hbar}\\sqrt{\\frac{e^2\\epsilon_F}{2\\pi\\epsilon_0\\bar\\epsilon}q}
``model=='local'`` uses
.. math::
1-\\frac{i\\text{Im}[\\sigma(q,\\omega)]}{2i\\epsilon_0\\bar\\epsilon\\omega}=0
and finally, ``model=='nonlocal'`` uses
.. math::
1 - \\frac{\\sigma(q,\\omega)q}{2i\\epsilon_0\\bar\\epsilon\\omega} = 0
Examples
--------
Plot the three expressions for the dispersion relation. Replicates Fig. 5.2 in Ref. [1].
.. plot::
>>> from graphenemodeling.graphene import monolayer as mlg
>>> from scipy.constants import elementary_charge, hbar
>>> eV = elementary_charge
>>> gamma=0.012 * eV / hbar
>>> eF = 0.4*eV
>>> kF = mlg.FermiWavenumber(eF,model='LowEnergy')
>>> q = np.linspace(1e-3,3,num=200) * kF
>>> disp_intra = mlg.PlasmonDispersion(q,gamma,eF,eps1=1,eps2=1,T=0,model='intra')
>>> disp_local = mlg.PlasmonDispersion(q,gamma,eF,eps1=1,eps2=1,T=0,model='local')
>>> disp_nonlocal = mlg.PlasmonDispersion(q,gamma,eF,eps1=1,eps2=1,T=0,model='nonlocal')
>>> fig, ax = plt.subplots(figsize=(6,6))
>>> ax.plot(q/kF,hbar*disp_intra/eF,'--',label='Intraband')
<...
>>> ax.plot(q/kF,hbar*disp_local/eF,'r-.',label='Local')
<...
>>> ax.plot(q[:190]/kF,hbar*disp_nonlocal[:190]/eF,'g',label='Nonlocal')
<...
>>> ax.plot(q/kF,q/kF,color='gray',linestyle='--')
<...
>>> ax.set_xlabel('$q/k_F$')
>>> ax.set_ylabel('$\\hbar\\omega/E_F$')
>>> ax.set_xlim(0,3)
>>> ax.set_ylim(0,3)
>>> plt.legend()
>>> plt.show()
Plot dispersion relation with a lower half-space permittivity of :math:`\\epsilon=4`` (an approximation for hexagonal boron nitride).
Replicates Fig. 1d in Ref. [2].
.. plot::
>>> from graphenemodeling.graphene import monolayer as mlg
>>> from scipy.constants import elementary_charge, hbar
>>> eV = elementary_charge
>>> gamma=0.012 * eV / hbar
>>> eF = 0.4*eV
>>> kF | |
input, its input regularizer is from dw1.
conv = self.GetConv('conv1')
gamma = self.GetGammaAbsValue('conv1')
# The effective size for dw can be computed from its gamma, and
# the loss may be computed as follows:
# gamma_dw = self.GetGammaAbsValue('dw1')
# expected_loss = _coeff(conv) * (
# gamma.sum() * (gamma_dw > 0.45).sum() + gamma_dw.sum() *
# (gamma > 0.45).sum())
# However, since dw cannot change shape because its input doesn't have a
# regularizer, the real loss we expect should be:
expected_loss = _coeff(conv) * (gamma.sum() * NUM_CHANNELS)
self.assertNear(expected_loss, self.loss([conv]), expected_loss * 1e-5)
# Dw2 depthwise convolution is connected to conv2 (grouped regularizer).
conv = self.GetConv('conv2')
gamma_conv = self.GetGammaAbsValue('conv2')
dw = self.GetConv('dw2')
gamma_dw = self.GetGammaAbsValue('dw2')
gamma = np.maximum(gamma_dw, gamma_conv).sum()
expected_loss = _coeff(conv) * (gamma * 3 + (gamma > 0.45).sum() * 0)
self.assertNear(expected_loss, self.loss([conv]), expected_loss * 1e-5)
expected_loss = _coeff(dw) * gamma * 2
self.assertNear(expected_loss, self.loss([dw]), expected_loss * 1e-5)
class GammaFlopLossWithDepthwiseConvNoBatchNormTest(
tf.test.TestCase, GammaFlopLossWithDepthwiseConvTestBase):
"""Test flop_regularizer for un-batchnormed depthwise convolutions.
This test is used to confirm that when depthwise convolution is not BNed, it
will not be considered towards the regularizer, but it will be counted towards
the cost.
This design choice is for backward compatibility for users who did not
regularize depthwise convolutions. However, the cost will be reported
regardless in order to be faithful to the real computation complexity.
"""
def setUp(self):
self._depthwise_use_batchnorm = False
super(GammaFlopLossWithDepthwiseConvNoBatchNormTest, self).setUp()
self.BuildWithBatchNorm()
with self.cached_session():
self.Init()
def GetSession(self):
return self.cached_session()
def testCost(self):
# Dw1 has NUM_CHANNELS inputs (from the image).
conv = self.GetConv('dw1')
self.assertEqual(_coeff(conv) * 3, self.cost([conv]))
# Conv1 has 7 gammas above 0.45, and 3 inputs (from dw1).
conv = self.GetConv('conv1')
self.assertEqual(_coeff(conv) * 7 * 3, self.cost([conv]))
# Conv2 has 11 active outputs and NUM_CHANNELS inputs (from the image).
conv = self.GetConv('conv2')
self.assertEqual(_coeff(conv) * 11 * NUM_CHANNELS, self.cost([conv]))
# Dw2 has 11 inputs (pass-through from the Conv2).
conv = self.GetConv('dw2')
self.assertEqual(_coeff(conv) * 11, self.cost([conv]))
# Conv3 has 10 gammas above 0.45, and 7 + 11 inputs from conv1 and dw2.
conv = self.GetConv('conv3')
self.assertEqual(_coeff(conv) * 10 * 18, self.cost([conv]))
def testRegularizer(self):
# Dw1 depthwise convolution is connected to the input (no regularizer).
conv = self.GetConv('dw1')
expected_loss = 0.0
self.assertNear(expected_loss, self.loss([conv]), expected_loss * 1e-5)
# Conv1 takes Dw1 as input, but it's not affected by dw1 because depthwise
# is not BNed.
conv = self.GetConv('conv1')
gamma = self.GetGammaAbsValue('conv1')
expected_loss = _coeff(conv) * (gamma.sum() * NUM_CHANNELS)
self.assertNear(expected_loss, self.loss([conv]), expected_loss * 1e-5)
# Dw2 depthwise convolution is connected to conv2 (pass through).
dw = self.GetConv('dw2')
gamma = self.GetGammaAbsValue('conv2')
expected_loss = _coeff(dw) * gamma.sum() * 2
self.assertNear(expected_loss, self.loss([dw]), expected_loss * 1e-5)
class GammaFlopResidualConnectionsLossTest(tf.test.TestCase):
"""Tests flop_regularizer for a network with residual connections."""
def setUp(self):
super(GammaFlopResidualConnectionsLossTest, self).setUp()
tf.set_random_seed(7)
self._threshold = 0.6
def BuildModel(self, resnet_fn, block_fn):
# We use this model as a test case because the slim.nets.resnet module is
# used in some production.
#
# The model looks as follows:
#
# Image --> unit_1/shortcut
# Image --> unit_1/conv1 --> unit_1/conv2 --> unit_1/conv3
#
# unit_1/shortcut + unit_1/conv3 --> unit_1 (residual connection)
#
# unit_1 --> unit_2/conv1 -> unit_2/conv2 --> unit_2/conv3
#
# unit_1 + unit_2/conv3 --> unit_2 (residual connection)
#
# In between, there are strided convolutions and pooling ops, but these
# should not affect the regularizer.
blocks = [
block_fn('block1', base_depth=7, num_units=2, stride=2),
]
image = tf.constant(0.0, shape=[1, 2, 2, NUM_CHANNELS])
net = resnet_fn(
image, blocks, include_root_block=False, is_training=False)[0]
net = tf.reduce_mean(net, axis=(1, 2))
return slim.layers.fully_connected(net, 23, scope='FC')
def BuildGraphWithBatchNorm(self, resnet_fn, block_fn):
params = {
'trainable': True,
'normalizer_fn': slim.batch_norm,
'normalizer_params': {
'scale': True
}
}
with slim.arg_scope([slim.layers.conv2d, slim.layers.separable_conv2d],
**params):
self.net = self.BuildModel(resnet_fn, block_fn)
def InitGamma(self):
assignments = []
gammas = {}
for v in tf.global_variables():
if v.op.name.endswith('/gamma'):
assignments.append(v.assign(tf.random_uniform(v.shape)))
gammas[v.op.name] = v
with self.cached_session() as s:
s.run(assignments)
self._gammas = s.run(gammas)
def GetGamma(self, short_name):
tokens = short_name.split('/')
name = ('resnet_v1/block1/' + tokens[0] + '/bottleneck_v1/' + tokens[1] +
'/BatchNorm/gamma')
return self._gammas[name]
def GetOp(self, short_name):
if short_name == 'FC':
return tf.get_default_graph().get_operation_by_name('FC/MatMul')
tokens = short_name.split('/')
name = ('resnet_v1/block1/' + tokens[0] + '/bottleneck_v1/' + tokens[1] +
'/Conv2D')
return tf.get_default_graph().get_operation_by_name(name)
def NumAlive(self, short_name):
return np.sum(self.GetGamma(short_name) > self._threshold)
def GetCoeff(self, short_name):
return _coeff(self.GetOp(short_name))
def testCost(self):
self.BuildGraphWithBatchNorm(resnet_v1.resnet_v1, resnet_v1.resnet_v1_block)
self.InitGamma()
res_alive = np.logical_or(
np.logical_or(
self.GetGamma('unit_1/shortcut') > self._threshold,
self.GetGamma('unit_1/conv3') > self._threshold),
self.GetGamma('unit_2/conv3') > self._threshold)
self.gamma_flop_reg = flop_regularizer.GammaFlopsRegularizer(
[self.net.op], self._threshold)
expected = {}
expected['unit_1/shortcut'] = (
self.GetCoeff('unit_1/shortcut') * np.sum(res_alive) * NUM_CHANNELS)
expected['unit_1/conv1'] = (
self.GetCoeff('unit_1/conv1') * self.NumAlive('unit_1/conv1') *
NUM_CHANNELS)
expected['unit_1/conv2'] = (
self.GetCoeff('unit_1/conv2') * self.NumAlive('unit_1/conv2') *
self.NumAlive('unit_1/conv1'))
expected['unit_1/conv3'] = (
self.GetCoeff('unit_1/conv3') * np.sum(res_alive) *
self.NumAlive('unit_1/conv2'))
expected['unit_2/conv1'] = (
self.GetCoeff('unit_2/conv1') * self.NumAlive('unit_2/conv1') *
np.sum(res_alive))
expected['unit_2/conv2'] = (
self.GetCoeff('unit_2/conv2') * self.NumAlive('unit_2/conv2') *
self.NumAlive('unit_2/conv1'))
expected['unit_2/conv3'] = (
self.GetCoeff('unit_2/conv3') * np.sum(res_alive) *
self.NumAlive('unit_2/conv2'))
expected['FC'] = 2.0 * np.sum(res_alive) * 23.0
# TODO(e1): Is there a way to use Parametrized Tests to make this more
# elegant?
with self.cached_session():
for short_name in expected:
cost = self.gamma_flop_reg.get_cost([self.GetOp(short_name)]).eval()
self.assertEqual(expected[short_name], cost)
self.assertEqual(
sum(expected.values()),
self.gamma_flop_reg.get_cost().eval())
class GroupLassoFlopRegTest(tf.test.TestCase):
def assertNearRelatively(self, expected, actual):
self.assertNear(expected, actual, expected * 1e-6)
def testFlopRegularizer(self):
tf.reset_default_graph()
tf.set_random_seed(7907)
with slim.arg_scope(
[slim.layers.conv2d, slim.layers.conv2d_transpose],
weights_initializer=tf.random_normal_initializer):
# Our test model is:
#
# -> conv1 --+
# / |--[concat]
# image --> conv2 --+
# \
# -> convt
#
# (the model has two "outputs", convt and concat).
#
image = tf.constant(0.0, shape=[1, 17, 19, NUM_CHANNELS])
conv1 = slim.layers.conv2d(
image, 13, [7, 5], padding='SAME', scope='conv1')
conv2 = slim.layers.conv2d(
image, 23, [1, 1], padding='SAME', scope='conv2')
self.concat = tf.concat([conv1, conv2], 3)
self.convt = slim.layers.conv2d_transpose(
image, 29, [7, 5], stride=3, padding='SAME', scope='convt')
self.name_to_var = {v.op.name: v for v in tf.global_variables()}
with self.cached_session():
tf.global_variables_initializer().run()
threshold = 1.0
flop_reg = flop_regularizer.GroupLassoFlopsRegularizer(
[self.concat.op, self.convt.op], threshold=threshold, l1_fraction=0)
with self.cached_session() as s:
evaluated_vars = s.run(self.name_to_var)
def group_norm(weights, axis=(0, 1, 2)): # pylint: disable=invalid-name
return np.sqrt(np.mean(weights**2, axis=axis))
reg_vectors = {
'conv1': group_norm(evaluated_vars['conv1/weights'], (0, 1, 2)),
'conv2': group_norm(evaluated_vars['conv2/weights'], (0, 1, 2)),
'convt': group_norm(evaluated_vars['convt/weights'], (0, 1, 3))
}
num_alive = {k: np.sum(r > threshold) for k, r in reg_vectors.items()}
total_outputs = (
reg_vectors['conv1'].shape[0] + reg_vectors['conv2'].shape[0])
total_alive_outputs = sum(num_alive.values())
assert total_alive_outputs > 0, (
'All outputs are dead - test is trivial. Decrease the threshold.')
assert total_alive_outputs < total_outputs, (
'All outputs are alive - test is trivial. Increase the threshold.')
coeff1 = _coeff(_get_op('conv1/Conv2D'))
coeff2 = _coeff(_get_op('conv2/Conv2D'))
coefft = _coeff(_get_op('convt/conv2d_transpose'))
expected_flop_cost = NUM_CHANNELS * (
coeff1 * num_alive['conv1'] + coeff2 * num_alive['conv2'] +
coefft * num_alive['convt'])
expected_reg_term = NUM_CHANNELS * (
coeff1 * np.sum(reg_vectors['conv1']) + coeff2 * np.sum(
reg_vectors['conv2']) + coefft * np.sum(reg_vectors['convt']))
with self.cached_session():
self.assertEqual(
round(expected_flop_cost), round(flop_reg.get_cost().eval()))
self.assertNearRelatively(expected_reg_term,
flop_reg.get_regularization_term().eval())
def testFlopRegularizerWithMatMul(self):
"""Test the MatMul op regularizer with FLOP network regularizer.
Set up a two layer fully connected network.
"""
tf.reset_default_graph()
tf.set_random_seed(1234)
# Create the variables, and corresponding values.
x = tf.constant(1.0, shape=[2, 6], name='x', dtype=tf.float32)
w = tf.get_variable('w', shape=(6, 4), dtype=tf.float32)
b = tf.get_variable('b', shape=(4), dtype=tf.float32)
w2 = tf.get_variable('w2', shape=(4, 1), dtype=tf.float32)
b2 = tf.get_variable('b2', shape=(1), dtype=tf.float32)
w_value = np.arange(24).reshape((6, 4)).astype('float32')
b_value = np.arange(4).reshape(4).astype('float32')
w2_value = np.arange(21, 25).reshape((4, 1)).astype('float32')
b2_value = np.arange(1).astype('float32')
# Build the test network model.
net = tf.nn.relu(tf.matmul(x, w, name='matmul1') + b)
output = tf.nn.relu(tf.matmul(net, w2, name='matmul2') + b2)
# Assign values to network parameters.
with self.cached_session() as session:
session.run([
w.assign(w_value),
b.assign(b_value),
w2.assign(w2_value),
b2.assign(b2_value)
])
# Create FLOPs network regularizer.
threshold = 32.0
flop_reg = flop_regularizer.GroupLassoFlopsRegularizer([output.op],
threshold, 0)
# Compute expected regularization vector and alive vector.
def group_norm(weights, axis=(0, 1, 2)): # pylint: disable=invalid-name
return np.sqrt(np.mean(weights**2, axis=axis))
expected_reg_vector1 = group_norm(w_value, axis=(0,))
expected_reg_vector2 = group_norm(w2_value, axis=(0,))
# Since the threshold is 32, and the L2 norm of columns in matrix w is
# (29.66479301, 31.71750259, 33.82307053, 35.97220993). Thus, the alive
# vector for w should be (0, 0, 1, 1). The alive vector is [1] since the L2
# norm for w2_value is 45.055521 > 32.
# Compute the expected FLOPs cost and expected regularization term.
matmul1_live_input = 6
matmul1_live_output = sum(expected_reg_vector1 > threshold)
matmul2_live_output = sum(expected_reg_vector2 > threshold)
expected_flop_cost = (
_coeff(_get_op('matmul1')) * matmul1_live_input * matmul1_live_output +
_coeff(_get_op('matmul2')) * matmul1_live_output * matmul2_live_output)
regularizer1 = np.sum(expected_reg_vector1)
regularizer2 = np.sum(expected_reg_vector2)
expected_reg_term = | |
import re
import os
import logging
from copy import deepcopy
from .exceptions import InterpolationError
from .backends import YAMLBackend, SopsYAMLBackend, JSONBackend
from .util import LookupDict, sym_lookup
function = re.compile(r'''%\{(scope|hiera|lookup|literal|alias)\(['"](?:::|)([^"']*)["']\)\}''')
interpolate = re.compile(r'''%\{(?:::|)([^\}]*)\}''')
rformat = re.compile(r'''%{(?:::|)([a-zA-Z_-|\d]+)}''')
LOGGER = logging.getLogger(__name__)
class Merge(object):
def __init__(self, typ, deep=False):
self.typ = typ
self.deep = deep
if typ == dict:
self.value = LookupDict()
else:
self.value = typ()
def merge_value(self, value):
if isinstance(self.value, list):
self.value += list(value)
elif isinstance(self.value, set):
self.value = self.value | set(value)
elif isinstance(self.value, dict):
if self.deep:
self.value = self.deep_merge(self.value, value)
else:
for k, v in value.items():
if k not in self.value:
self.value[k] = v
elif isinstance(self.value, str):
self.value = value
else:
raise TypeError("Cannot handle merge_value of type %s", type(self.value))
def deep_merge(self, a, b):
'''recursively merges dicts. not just simple a['key'] = b['key'], if
both a and bhave a key who's value is a dict then dict_merge is called
on both values and the result stored in the returned dictionary.'''
if not isinstance(b, dict):
return b
result = deepcopy(a)
for k, v in b.items():
if k in result and isinstance(result[k], dict):
result[k] = self.deep_merge(result[k], v)
elif k in result and isinstance(result[k], list):
if isinstance(v, list):
v = [_ for _ in v if _ not in result[k]]
result[k] += deepcopy(v)
else:
result[k].append(v)
else:
result[k] = deepcopy(v)
return result
class ScopedHiera(object):
def __init__(self, hiera, context={}):
self.hiera = hiera
self.context = context
def has(self, key, **kwargs):
kwargs.update(self.context)
return self.hiera.has(key, **kwargs)
def get(self, key, default=None, merge=None, merge_deep=False, throw=False, context={}, **kwargs):
new_context = {}
new_context.update(self.context)
new_context.update(context)
new_context.update(kwargs)
return self.hiera.get(key, default, merge, merge_deep, throw, new_context)
def __getattr__(self, name):
if hasattr(self.hiera, name):
return getattr(self.hiera, name)
raise AttributeError
class Hiera(object):
"""
The Hiera object represents a first-class interaction between Python and
Hiera data. It takes a base-hiera config YAML file, and exposes methods
to retrieve and fully resolve Hiera data.
# XXX fix doc, this can be a dict
:param base_config: The Hiera base configuration: file path, file-like object, or dict
:param backends: A list of backends to use for loading, by default this is
YAMLBackend, SopsYAMLBackend and JSONBackend
:param context: Any dictionary of format/context variables to default for the
liftime of this instance.
:param kwargs: Any additional kwargs will be added to the context
"""
def __init__(self, base_config, backends=None, base_path=None, context={}, **kwargs):
self.base_config = base_config
self.context = context
self.context.update(kwargs)
self.cache = {}
self.paths = []
self.load(backends or [YAMLBackend, SopsYAMLBackend, JSONBackend])
def load(self, backends, base_path=None):
"""
This function loads the base Hiera configuration, attempting to parse and
build state based on it. This will raise exceptions if the loading process
fails due to invalid configuration.
"""
# If we don't have a file-like object, attempt to open as a file path
if type(self.base_config) is dict:
self.base = self.base_config
if base_path is None:
self.base_path = os.getcwd()
else:
self.base_path = base_path
else:
if not hasattr(self.base_config, 'read'):
self.base_path = os.path.dirname(self.base_config)
self.base_config = open(self.base_config)
else:
self.base_path = os.getcwd()
# Load our base YAML configuration
self.base = YAMLBackend.load_ordered(self.base_config)
if not self.base:
raise Exception("Failed to parse base Hiera configuration")
# Load all backends
self.backends = {}
for backend in sym_lookup(self.base, 'backends'):
obj = [i for i in backends if i.NAME == backend]
if not len(obj):
raise Exception("Invalid Backend: `{}`".format(backend))
self.backends[backend] = obj[0](self, sym_lookup(self.base, backend))
# Make sure we have at least a single backend
if not len(self.backends):
raise Exception("No backends could be loaded")
hierarchy = sym_lookup(self.base, 'hierarchy')
if hierarchy is None:
raise Exception("Invalid Base Hiera Config: missing hierarchy key")
self.hierarchy = []
# Load our heirarchy
for path in hierarchy:
self.hierarchy.append(rformat.sub("{\g<1>}", path, count=0))
# Load our backends
for backend in list(self.backends.values()):
backend.datadir = rformat.sub("{\g<1>}", backend.datadir, count=0)
# Now pre-load/cache a bunch of global stuff. If context vars where provided
# in the constructor, we'll also load those files into the cache.
self.get(None)
def load_directory(self, path, backend=None):
"""
Walks an entire directory and attempts to load all relevant data files
based on our backends. Optionally can only load for one backend.
"""
for root, dirs, files in os.walk(path):
for f in files:
backend = backend or self.backends.get(':{}'.format(os.path.splitext(f)[-1]))
if backend:
yield self.load_file(os.path.join(root, f), backend)
def load_file(self, path, backend, ignore_cache=False):
"""
Attempts to load a file for a specific backend, caching the result.
"""
if path not in self.cache or ignore_cache:
try:
self.cache[path] = backend.load(backend.read_file(path))
except Exception as e:
raise Exception("Failed to load file {}: `{}`".format(path, e))
return path
def can_resolve(self, s):
"""
Returns true if any resolving or interpolation can be done on the provided
string
"""
if (isinstance(s, str) or isinstance(s, str)) and (function.findall(s) or interpolate.findall(s)):
return True
return False
def resolve_function(self, s, paths, context, merge):
"""
Attempts to fully resolve a hiera function call within a value. This includes
interpolation for relevant calls.
"""
calls = function.findall(s)
# If this is an alias, just replace it (doesn't require interpolation)
if len(calls) == 1 and calls[0][0] == 'alias':
if function.sub("", s) != "":
raise Exception("Alias can not be used for string interpolation: `{}`".format(s))
try:
value = self.get_key(calls[0][1], paths, context, merge)
return value
except KeyError as e:
raise InterpolationError("Alias lookup failed: key '{}' does not exist".format(calls[0][1]))
# Iterate over all function calls and string interpolate their resolved values
for call, arg in calls:
if call == 'hiera' or call == 'lookup':
replace = self.get_key(arg, paths, context, merge)
elif call == 'scope':
replace = context.get(arg)
elif call == 'literal':
replace = arg
elif call == 'alias':
raise Exception("Invalid alias function call: `{}`".format(s))
if not replace:
raise Exception("Could not resolve value for function call: `{}`".format(s))
if isinstance(replace, str):
# Replace only the current function call with our resolved value
s = function.sub(replace, s, 1)
elif call == 'scope':
s = replace
else:
raise Exception("Resolved value is not a string for function call: `{}`".format(s))
return s
def resolve_interpolates(self, s, context):
"""
Attempts to resolve context-based string interpolation
"""
interps = interpolate.findall(s)
for i in interps:
# XXX - should this throw an error, interpolate to an empty string, or be configurable?
# what does ruby hiera do?
s = interpolate.sub((context.get(i) or ''), s, 1)
return s
def resolve(self, s, paths, context, merge):
"""
Fully resolves an object, including function and interpolation based resolving.
"""
if isinstance(s, dict):
return self.resolve_dict(s, paths, context, merge)
elif isinstance(s, list):
return list(self.resolve_list(s, paths, context, merge))
elif not self.can_resolve(s):
return s
base = self.resolve_function(s, paths, context, merge)
# If we can string interpolate the result, lets do that
if isinstance(base, str):
base = self.resolve_interpolates(base, context)
return base
def resolve_dict(self, obj, paths, context, merge):
"""
Recursively and completely resolves all Hiera interoplates/functions
within a dictionary.
"""
new_obj = LookupDict()
for k, v in obj.items():
new_obj[k] = self.resolve(v, paths, context, merge)
return new_obj
def resolve_list(self, obj, paths, context, merge):
for item in obj:
yield self.resolve(item, paths, context, merge)
def get_key(self, key, paths, context, merge):
"""
Get the value of a key within hiera, resolving if required
"""
merges = {}
for path in paths:
if self.cache[path] is not None and key is not None:
cache = None
try:
cache = self.cache[path].lookup(key)
except KeyError as e:
pass
if cache is not None:
if merge and not key in merges:
merges[key] = Merge(merge.typ, merge.deep)
value = self.resolve(cache, paths, context, (merges[key] if merge and merge.deep else merge))
if merge and merges[key]:
merges[key].merge_value(value)
else:
return value
if merge and key in merges and merges[key].value is not None:
return merges[key].value
else:
if key!= None and len(key.split('.')) > 1:
LOGGER.error("Lookup key: '{}' not found. Make sure you are providing this key in YAML configuration.".format(key))
raise KeyError(key)
def scoped(self, context={}, **kwargs):
context.update(kwargs)
return ScopedHiera(self, context)
def has(self, key, **kwargs):
"""
Returns true if the key exists in hiera, false otherwise
"""
try:
self.get(key, throw=True, **kwargs)
return True
except KeyError:
return False
def get(self, key, default=None, merge=None, merge_deep=False, throw=False, context={}, **kwargs):
"""
Attempts to retrieve a hiera variable by fully resolving its location.
:param key: They Hiera key to retrieve
:param default: If the Hiera key is not found, return this value
| |
<gh_stars>0
import itertools
import hashlib
import pypipegraph as ppg
import numpy as np
import pandas as pd
from pandas import DataFrame
from mbf_genomics import DelayedDataFrame
from mbf_qualitycontrol import register_qc, qc_disabled
from mbf_genomics.util import parse_a_or_c_to_anno
from mbf_genomics.annotator import Annotator
from typing import List, Dict, Tuple, Any
from pypipegraph import Job
import dppd
import dppd_plotnine # noqa: F401
dp, X = dppd.dppd()
# import pypipegraph as ppg
class ComparisonAnnotator(Annotator):
def __init__(
self,
comparisons,
group_a,
group_b,
comparison_strategy,
laplace_offset=1 / 1e6,
other_groups_for_variance=[],
):
"""Create a comparison (a - b)"""
self.comparisons = comparisons
if hasattr(comparison_strategy, "__call__"):
self.comparison_strategy = comparison_strategy()
else:
self.comparison_strategy = comparison_strategy
if isinstance(
self.comparison_strategy.columns, str
): # pragma: no cover definsive
raise ValueError(
"ComparisonStrategy %s had a string as columns, must be a list"
% self.comparison_strategy
)
self.comp = (group_a, group_b)
self.other_groups_for_variance = other_groups_for_variance
self.columns = []
self.column_lookup = {}
for col in sorted(self.comparison_strategy.columns):
cn = self.name_column(col)
self.columns.append(cn)
self.column_lookup[col] = cn
self.laplace_offset = laplace_offset
self.result_dir = self.comparisons.result_dir / f"{group_a}_vs_{group_b}"
self.result_dir.mkdir(exist_ok=True, parents=True)
self._check_comparison_groups(group_a, group_b)
if len(self.columns[0]) >= 60:
self.cache_name = (
"Comp %s" % hashlib.md5(self.columns[0].encode("utf-8")).hexdigest()
)
try:
self.vid = self._build_vid()
except AttributeError: # the sample annotators don't have a vid
pass
def _build_vid(self):
a = set()
b = set()
all_columns = True
for s in self.comparisons.groups_to_samples[self.comp[0]]:
if s[0] is not None:
a.add(s[0].vid)
all_columns = False
for s in self.comparisons.groups_to_samples[self.comp[1]]:
if s[0] is not None:
b.add(s[0].vid)
all_columns = False
if a or b:
return sorted(a) + ["vs"] + sorted(b)
elif all_columns:
raise AttributeError("No vids - as expected")
def name_column(self, col):
if self.comparison_strategy.supports_other_samples:
supports_other_samples = ",Other=%s" % bool(self.other_groups_for_variance)
else:
supports_other_samples = ""
return f"Comp. {self.comp[0]} - {self.comp[1]} {col} ({self.comparison_strategy.name}{supports_other_samples})"
def __getitem__(self, itm):
"""look up the full column name from log2FC, p, FDR, etc"""
return self.column_lookup[itm]
def filter(self, filter_definition, new_name=None, sheet_name=None):
"""Turn a filter definition [(column, operator, threshold)...]
into a filtered genes object.
Example:
comp.filter(genes, '2x', [
('FDR', '<=', 0.05) # a name from our comparison strategy - inspect column_lookup to list
('log2FC', '|>', 1), #absolute
...
(anno, '>=', 50),
((anno, 1), '>=', 50), # for the second column of the annotator
((anno, 'columnX'), '>=', 50), # for the second column of the annotator
('annotator_columnX', '=>' 50), # search for an annotator with that column. Use if exactly one, complain otherwise
]
"""
lookup = self.column_lookup.copy()
for c in self.columns:
lookup[c] = c
subset_relevant_columns = set(lookup.values())
subset_relevant_columns.update(self.sample_columns(self.comp[0]))
subset_relevant_columns.update(self.sample_columns(self.comp[1]))
for g in self.other_groups_for_variance:
subset_relevant_columns.update(self.sample_columns(g))
further_filters = []
add_direction = False
thresholds = {}
filter_str = []
for column, op, threshold in sorted(filter_definition):
if op == "==":
oop = "＝"
elif op == ">":
oop = "＞"
elif op == "<":
oop = "＜"
elif op == ">=":
oop = "≥"
elif op == "<=":
oop = "≤"
elif op == "|>":
oop = "|＞"
elif op == "|<":
oop = "|＜"
elif op == "|>=":
oop = "|≥"
elif op == "|<=":
oop = "|≤"
else:
oop = op
filter_str.append(f"{column}_{oop}_{threshold:.2f}")
subset_relevant_columns.add(lookup[column])
if column == "log2FC":
if "|" in op:
add_direction = True
thresholds[column] = threshold
if new_name is None:
filter_str = "__".join(filter_str)
new_name = f"Filtered_{self.comparison_strategy.name}_{self.comp[0]}-{self.comp[1]}_{filter_str}"
if "log2FC" in lookup:
further_filters.append(("logFC", lookup["log2FC"], 2, thresholds.get('log2FC', 0)))
if add_direction:
further_filters.append(("Direction", lookup["log2FC"], 1, 0))
for x in ["p", "FDR"]: # less than
if x in lookup:
further_filters.append((x, lookup[x], 5, thresholds.get(x, 1)))
for x in ["minExpression"]: # min of columns > x
if x in lookup:
further_filters.append((x, [lookup[x]], 4, thresholds.get(x, 0)))
# we need the filter func for the plotting, so we do it ourselves
filter_func, annos = self.comparisons.ddf.definition_to_function(
filter_definition, lookup
)
kwargs = {}
if hasattr(self, "vid"):
kwargs["vid"] = self.vid
res = self.comparisons.ddf.filter(
new_name,
filter_func,
annotators=annos,
column_lookup=lookup,
result_dir=self.result_dir / new_name,
sheet_name=sheet_name,
**kwargs,
)
if not qc_disabled():
if "p" in self.comparison_strategy.columns:
self.register_qc_volcano(self.comparisons.ddf, res, filter_func)
# self.register_qc_ma_plot(self.comparisons.ddf, res, filter_func)
res.plot_columns = self.samples()
res.venn_annotator = self
res.subset_relevant_columns = subset_relevant_columns
res.further_filter_columns = further_filters
return res
def calc(self, df):
columns_a = list(self.sample_columns(self.comp[0]))
columns_b = list(self.sample_columns(self.comp[1]))
columns_other = {}
for g in self.other_groups_for_variance:
columns_other[g] = self.sample_columns(g)
comp = self.comparison_strategy.compare(
df, columns_a, columns_b, columns_other, self.laplace_offset,
)
res = {}
for col in sorted(self.comparison_strategy.columns):
res[self.name_column(col)] = comp[col]
return pd.DataFrame(res)
def dep_annos(self):
"""Return other annotators"""
res = []
for generator in [self.samples(), self.other_samples()]:
for k in generator:
a = parse_a_or_c_to_anno(k)
if a is not None:
res.append(a)
return res
def deps(self, ddf):
from mbf_genomics.util import freeze
sample_info = []
for ac in self.samples():
group = self.comparisons.sample_column_to_group[ac[1]]
sample_info.append(
(group, ac[0].get_cache_name() if ac[0] is not None else "None", ac[1])
)
sample_info.sort()
parameters = freeze(
[
(
# self.comparison_strategy.__class__.__name__ , handled by column name
sample_info,
# self.comp, # his handled by column name
self.laplace_offset,
)
]
)
res = [ppg.ParameterInvariant(self.get_cache_name(), parameters)]
res.extend(getattr(self.comparison_strategy, "deps", lambda: [])())
return res
def samples(self):
"""Return anno, column for samples used"""
for x in list(self.comp) + self.other_groups_for_variance:
for s in self.comparisons.groups_to_samples[x]:
yield s
def other_samples(self):
"""Return anno, column for additional samples used for variance"""
for x in self.other_groups_for_variance:
for s in self.comparisons.groups_to_samples[x]:
yield s
def sample_columns(self, group):
for s in self.comparisons.groups_to_samples[group]:
yield s[1]
def _check_comparison_groups(self, *groups):
for x in groups:
if x not in self.comparisons.groups_to_samples:
raise ValueError(f"Comparison group {x} not found")
if (
len(self.comparisons.groups_to_samples[x])
< self.comparison_strategy.min_sample_count
):
raise ValueError(
"Too few samples in %s for %s" % (x, self.comparison_strategy.name)
)
def register_qc_volcano(self, genes, filtered=None, filter_func=None):
"""perform a volcano plot
"""
if filtered is None:
output_filename = genes.result_dir / "volcano.png"
else:
output_filename = filtered.result_dir / "volcano.png"
def plot(output_filename):
df = (
dp(genes.df)
.mutate(
significant=filter_func(genes.df)
if filter_func is not None
else "tbd."
)
.pd
)
no_sig_lower = (df["significant"] & (df[self["log2FC"]] < 0)).sum()
no_sig_higher = (df["significant"] & (df[self["log2FC"]] > 0)).sum()
(
dp(df)
.p9()
.scale_color_many_categories(name="regulated", shift=3)
.scale_y_continuous(
name="p",
trans=dp.reverse_transform("log10"),
labels=lambda xs: ["%.2g" % x for x in xs],
)
.add_vline(xintercept=1, _color="blue")
.add_vline(xintercept=-1, _color="blue")
.add_hline(yintercept=0.05, _color="blue")
.add_rect( # shade 'simply' significant regions
xmin="xmin",
xmax="xmax",
ymin="ymin",
ymax="ymax",
_fill="lightgrey",
data=pd.DataFrame(
{
"xmin": [-np.inf, 1],
"xmax": [-1, np.inf],
"ymin": [0, 0],
"ymax": [0.05, 0.05],
}
),
_alpha=0.8,
)
.add_scatter(self["log2FC"], self["p"], color="significant")
.title(f"# regulated down/ up: {no_sig_lower} / {no_sig_higher}")
# .coord_trans(x="reverse", y="reverse") #broken as of 2019-01-31
.render(output_filename, width=8, height=6, dpi=300)
)
return register_qc(
ppg.FileGeneratingJob(output_filename, plot).depends_on(
genes.add_annotator(self),
ppg.FunctionInvariant(
str(output_filename) + "_filter_func", filter_func
),
)
)
def register_qc_ma_plot(self, genes, filtered, filter_func):
"""perform an MA plot - not a straight annotator.register_qc function,
but called by .filter
"""
output_filename = filtered.result_dir / "ma_plot.png"
def plot(output_filename):
from statsmodels.nonparametric.smoothers_lowess import lowess
print(genes.df.columns)
print(list(self.sample_columns(self.comp[0])))
print(list(self.sample_columns(self.comp[1])))
df = genes.df[
list(self.sample_columns(self.comp[0]))
+ list(self.sample_columns(self.comp[1]))
]
df = df.assign(significant=filter_func(genes.df))
pdf = []
loes_pdfs = []
# Todo: how many times can you over0lopt this?
for a, b in itertools.combinations(
[x for x in df.columns if not "significant" == x], 2
):
np_a = np.log2(df[a] + self.laplace_offset)
np_b = np.log2(df[b] + self.laplace_offset)
A = (np_a + np_b) / 2
M = np_a - np_b
local_pdf = pd.DataFrame(
{
"A": A,
"M": M,
"a": self.comparisons.get_plot_name(a),
"b": self.comparisons.get_plot_name(b),
"significant": df["significant"],
}
).sort_values("M")
chosen = np.zeros(len(local_pdf), bool)
chosen[:500] = True
chosen[-500:] = True
chosen[np.random.randint(0, len(chosen), 1000)] = True
pdf.append(local_pdf)
fitted = lowess(M, A, is_sorted=False)
loes_pdfs.append(
pd.DataFrame(
{
"a": self.comparisons.get_plot_name(a),
"b": self.comparisons.get_plot_name(b),
"A": fitted[:, 0],
"M": fitted[:, 1],
}
)
)
pdf = pd.concat(pdf)
pdf = pdf.assign(ab=[a + ":" + b for (a, b) in zip(pdf["a"], pdf["b"])])
loes_pdf = pd.concat(loes_pdfs)
loes_pdf = loes_pdf.assign(
ab=[a + ":" + b for (a, b) in zip(loes_pdf["a"], loes_pdf["b"])]
)
(
dp(pdf)
.p9()
.theme_bw(10)
.add_hline(yintercept=0, _color="lightblue")
.add_hline(yintercept=1, _color="lightblue")
.add_hline(yintercept=-1, _color="lightblue")
.scale_color_many_categories(name="significant", shift=3)
.add_point("A", "M", color="significant", _size=1, _alpha=0.3)
.add_line("A", "M", _color="blue", data=loes_pdf)
.facet_wrap(["ab"])
.title(f"MA {filtered.name}\n{self.comparisons.find_variable_name()}")
.render(output_filename, width=8, height=6)
)
return register_qc(
ppg.FileGeneratingJob(output_filename, plot)
.depends_on(genes.add_annotator(self))
.depends_on(self.comparisons.deps)
)
class ComparisonAnnotatorMulti(ComparisonAnnotator):
"""
Annotator for multi-factor comparison.
Based on a main factor and a list of multiple other factor, this
creates an annotator that annotates DEG analysis results for a multi-factor
design. Interaction terms may be specified as a list of tuples which may be
empty.
if an empty interactions list is provided, the analysis just controls
for different levels of other_factors and report the main effect.
Parameters
----------
name : str
Annotator name, used for cache names and test of uniqueness.
comparisons : Comparisons
Comparisons instance containing the groups to be analyzed.
main_factor | |
(" + str(authenticators.messageData[1]) + ")", 400
return json.dumps(authenticators.messageData)
'''
PATH: /im/as/authenticator
N/A ACTIONS: POST, PUT, PATCH, DELETE
'''
def post_as_authenticator(self):
return "NOT AVAILABLE", 405
def put_as_authenticator(self):
return "NOT AVAILABLE", 405
def patch_as_authenticator(self):
return "NOT AVAILABLE", 405
def delete_as_authenticator(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/authenticator/{authenticatorId}
ACTION: GET
DESCRIPTION: Return "True" if a required autheticator is
a available, or "False" if it is not.
ARGUMENT: --
RETURN: - 200 (HTTP) + Boolean [1]
- Integer error code (HTTP)
'''
def get_as_a_authenticatorId(self, authenticatorId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_a_authId", authenticatorId), "AS", "IM")
authenticators = self.__asIr.sendMessage(request)
if type(authenticators.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING AUTHENTICATOR INSTANCE OPERATION (" + str(authenticators.messageData[1]) + ")", 400
return json.dumps(authenticators.messageData)
'''
PATH: /im/as/authenticator/{authenticatorId}
N/A ACTIONS: POST, PUT, PATCH, DELETE
'''
def post_as_a_authenticatorId(self):
return "NOT AVAILABLE", 405
def put_as_a_authenticatorId(self):
return "NOT AVAILABLE", 405
def patch_as_a_authenticatorId(self):
return "NOT AVAILABLE", 405
def delete_as_a_authenticatorId(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/running_authenticator
ACTION: GET
DESCRIPTION: Retrieve the currently running authenticator agent
in the access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + String [1]
- Integer error code (HTTP)
'''
def get_as_running_authenticator(self):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_running_auth", None), "AS", "IM")
authenticators = self.__asIr.sendMessage(request)
if type(authenticators.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING AUTHENTICATOR INSTANCE OPERATION (" + str(authenticators.messageData[1]) + ")", 400
return json.dumps(authenticators.messageData)
'''
PATH: /im/as/running_authenticator
N/A ACTIONS: POST, PUT, PATCH, DELETE
'''
def post_as_running_authenticator(self):
return "NOT AVAILABLE", 405
def put_as_running_authenticator(self):
return "NOT AVAILABLE", 405
def patch_as_running_authenticator(self):
return "NOT AVAILABLE", 405
def delete_as_running_authenticator(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/running_authenticator/{authenticatorId}
ACTION: GET
DESCRIPTION: Return "True" if a required authenticator is
running, or "False" if it is not.
ARGUMENT: --
RETURN: - 200 (HTTP) + String [1]
- Integer error code (HTTP)
'''
def get_as_ra_authenticatorId(self, authenticatorId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_ra_authId", authenticatorId), "AS", "IM")
authenticators = self.__asIr.sendMessage(request)
if type(authenticators.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING AUTHENTICATOR INSTANCE OPERATION (" + str(authenticators.messageData[1]) + ")", 400
return json.dumps(authenticators.messageData)
'''
PATH: /im/as/running_authenticator/{authenticatorId}
ACTION: POST
DESCRIPTION: Retrieve the required authenticator and execute
it in the access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + String [1]
- Integer error code (HTTP)
'''
def post_as_ra_authenticatorId(self, authenticatorId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "post_as_ra_authId", authenticatorId), "AS", "IM")
authenticators = self.__asIr.sendMessage(request)
if type(authenticators.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING AUTHENTICATOR INSTANCE OPERATION (" + str(authenticators.messageData[1]) + ")", 400
return json.dumps(authenticators.messageData)
'''
PATH: /im/as/running_authenticator/{authenticatorId}
N/A ACTIONS: PUT, PATCH, DELETE
'''
def put_as_ra_authenticatorId(self):
return "NOT AVAILABLE", 405
def patch_as_ra_authenticatorId(self):
return "NOT AVAILABLE", 405
def delete_as_ra_authenticatorId(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/user
ACTION: GET
DESCRIPTION: Retrieve all the available users in the
access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibUserInstance [0..N]
- Integer error code (HTTP)
'''
def get_as_user(self):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_user", None), "AS", "IM")
users = self.__asIr.sendMessage(request)
if type(users.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING USER INSTANCE OPERATION (" + str(users.messageData[1]) + ")", 400
return json.dumps([u.toDictionary() for u in users.messageData])
'''
PATH: /im/as/user
ACTION: POST
DESCRIPTION: Send a new user to be saved in the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibUserInstance [1]
- Integer error code (HTTP)
'''
def post_as_user(self, vibUserInstance):
try:
vibUserInstance = VibModels.VibUserInstance().fromDictionary(json.loads(vibUserInstance))
except Exception as e:
return "ERROR CODE #0 (AS): INVALID USER INSTANCE PROVIDED (" + str(e) + ")", 400
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "post_as_user", vibUserInstance), "AS", "IM")
user = self.__asIr.sendMessage(request)
if type(user.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING USER INSTANCE OPERATION (" + str(user.messageData[1]) + ")", 400
return json.dumps(user.messageData.toDictionary())
'''
PATH: /im/as/user
N/A ACTIONS: PUT, PATCH, DELETE
'''
def put_as_user(self):
return "NOT AVAILABLE", 405
def patch_as_user(self):
return "NOT AVAILABLE", 405
def delete_as_user(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/user/{userId}
ACTION: GET
DESCRIPTION: Retrieve a particular user from the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibUserInstance [1]
- Integer error code (HTTP)
'''
def get_as_u_userId(self, userId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_u_userId", userId), "AS", "IM")
user = self.__asIr.sendMessage(request)
if type(user.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING USER INSTANCE OPERATION (" + str(user.messageData[1]) + ")", 400
return json.dumps(user.messageData.toDictionary())
'''
PATH: /im/as/user/{userId}
ACTION: PATCH
DESCRIPTION: Update a particular user from the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibUserInstance [1]
- Integer error code (HTTP)
'''
def patch_as_u_userId(self, userId, vibUserInstance):
try:
vibUserInstance = VibModels.VibUserInstance().fromDictionary(json.loads(vibUserInstance))
if userId != vibUserInstance.userId:
return "ERROR CODE #0 (AS): INVALID USER INSTANCE PROVIDED (" + str(userId) + " != " + str(vibUserInstance.userId) + ")", 400
except Exception as e:
return "ERROR CODE #0 (AS): INVALID USER INSTANCE PROVIDED (" + str(e) + ")", 400
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "patch_as_u_userId", vibUserInstance), "AS", "IM")
user = self.__asIr.sendMessage(request)
if type(user.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING USER INSTANCE OPERATION (" + str(user.messageData[1]) + ")", 400
return json.dumps(user.messageData.toDictionary())
'''
PATH: /im/as/user/{userId}
ACTION: DELETE
DESCRIPTION: DELETE a particular user from the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibUserInstance [1]
- Integer error code (HTTP)
'''
def delete_as_u_userId(self, userId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "delete_as_u_userId", userId), "AS", "IM")
user = self.__asIr.sendMessage(request)
if type(user.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING USER INSTANCE OPERATION (" + str(user.messageData[1]) + ")", 400
return json.dumps(user.messageData.toDictionary())
'''
PATH: /im/as/user/{userId}
N/A ACTIONS: POST, PUT
'''
def post_as_u_userId(self):
return "NOT AVAILABLE", 405
def put_as_u_userId(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/credential
ACTION: GET
DESCRIPTION: Retrieve all the available credentials in the
access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibCredentialInstance [0..N]
- Integer error code (HTTP)
'''
def get_as_credential(self):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_credential", None), "AS", "IM")
credentials = self.__asIr.sendMessage(request)
if type(credentials.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING CREDENTIAL INSTANCE OPERATION (" + str(credentials.messageData[1]) + ")", 400
return json.dumps([c.toDictionary() for c in credentials.messageData])
'''
PATH: /im/as/credential
ACTION: POST
DESCRIPTION: Send a new credential to be saved in the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibCredentialInstance [1]
- Integer error code (HTTP)
'''
def post_as_credential(self, vibCredentialInstance):
try:
vibCredentialInstance = VibModels.VibCredentialInstance().fromDictionary(json.loads(vibCredentialInstance))
except:
return "ERROR CODE #0 (AS): INVALID CREDENTIAL INSTANCE PROVIDED", 400
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "post_as_credential", vibCredentialInstance), "AS", "IM")
credential = self.__asIr.sendMessage(request)
if type(credential.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING CREDENTIAL OPERATION (" + str(credential.messageData[1]) + ")", 400
return json.dumps(credential.messageData.toDictionary())
'''
PATH: /im/as/credential
N/A ACTIONS: PUT, PATCH, DELETE
'''
def put_as_credential(self):
return "NOT AVAILABLE", 405
def patch_as_credential(self):
return "NOT AVAILABLE", 405
def delete_as_credential(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/credential/{userId}/{vnfId}
ACTION: GET
DESCRIPTION: Retrieve a particular credential from the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibCredentialInstance [1]
- Integer error code (HTTP)
'''
def get_as_c_credentialId(self, userId, vnfId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_c_credentialId", (userId, vnfId)), "AS", "IM")
credential = self.__asIr.sendMessage(request)
if type(credential.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING CREDENTIAL INSTANCE OPERATION (" + str(credential.messageData[1]) + ")", 400
return json.dumps(credential.messageData.toDictionary())
'''
PATH: /im/as/credential/{userId}/{vnfId}
ACTION: DELETE
DESCRIPTION: Delete a particular credential from the access
subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibCredentialInstance [1]
- Integer error code (HTTP)
'''
def delete_as_c_credentialId(self, userId, vnfId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "delete_as_c_credentialId", (userId, vnfId)), "AS", "IM")
credential = self.__asIr.sendMessage(request)
if type(credential.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING MONITORING AGENT INSTANCE OPERATION (" + str(credential.messageData[1]) + ")", 400
return json.dumps(credential.messageData.toDictionary())
'''
PATH: /im/as/credential/{userId}/{vnfId}
N/A ACTIONS: POST, PUT, PATCH
'''
def post_as_c_credentialId(self):
return "NOT AVAILABLE", 405
def put_as_c_credentialId(self):
return "NOT AVAILABLE", 405
def patch_as_c_credentialId(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/credential/user/{userId}
ACTION: GET
DESCRIPTION: Retrieve the credentials of a particular
user from the access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibCredentialInstance [0..N]
- Integer error code (HTTP)
'''
def get_as_c_userId(self, userId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_c_userId", userId), "AS", "IM")
credentials = self.__asIr.sendMessage(request)
if type(credentials.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING CREDENTIAL INSTANCE OPERATION (" + str(credentials.messageData[1]) + ")", 400
return json.dumps([c.toDictionary() for c in credentials.messageData])
'''
PATH: /im/as/credential/user/{userId}
N/A ACTIONS: POST, PUT, PATCH, DELETE
'''
def post_as_c_userId(self):
return "NOT AVAILABLE", 405
def put_as_c_userId(self):
return "NOT AVAILABLE", 405
def patch_as_c_userId(self):
return "NOT AVAILABLE", 405
def delete_as_c_userId(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/credential/vnf/{vnfId}
ACTION: GET
DESCRIPTION: Retrieve the credentials of a particular
vnf from the access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + VibCredentialInstance [0..N]
- Integer error code (HTTP)
'''
def get_as_c_vnfId(self, vnfId):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_c_vnfId", vnfId), "AS", "IM")
credentials = self.__asIr.sendMessage(request)
if type(credentials.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING CREDENTIAL INSTANCE OPERATION (" + str(credentials.messageData[1]) + ")", 400
return json.dumps([c.toDictionary() for c in credentials.messageData])
'''
PATH: /im/as/credential/vnf/{vnfId}
N/A ACTIONS: POST, PUT, PATCH, DELETE
'''
def post_as_c_vnfId(self):
return "NOT AVAILABLE", 405
def put_as_c_vnfId(self):
return "NOT AVAILABLE", 405
def patch_as_c_vnfId(self):
return "NOT AVAILABLE", 405
def delete_as_c_vnfId(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/vnfm/running_vnfm
ACTION: GET
DESCRIPTION: Retrieve the currently running vnfm driver in
the access subsystem.
ARGUMENT: --
RETURN: - 200 (HTTP) + String [1]
- Integer error code (HTTP)
'''
def get_as_vnfm_running_vnfm(self):
request = IrModels.IrMessage().fromData(IrModels.IrManagement().fromData("AS", "get_as_vnfm_running_vnfm", None), "AS", "IM")
driver = self.__asIr.sendMessage(request)
if type(driver.messageData) == tuple:
return "ERROR CODE #3 (AS): IM/AS ERROR DURING VNFM DRIVER INSTANCE OPERATION (" + str(driver.messageData[1]) + ")", 400
return json.dumps(driver.messageData)
'''
PATH: /im/as/vnfm/running_vnfm
N/A ACTIONS: POST, PUT, PATCH, DELETE
'''
def post_as_vnfm_running_vnfm(self):
return "NOT AVAILABLE", 405
def put_as_vnfm_running_vnfm(self):
return "NOT AVAILABLE", 405
def patch_as_vnfm_running_vnfm(self):
return "NOT AVAILABLE", 405
def delete_as_vnfm_running_vnfm(self):
return "NOT AVAILABLE", 405
'''
PATH: /im/as/vnfm/running_vnfm/{vnfmId}
ACTION: GET
DESCRIPTION: Return "True" if a required VNF manager is
running, or "False" if it is not.
ARGUMENT: --
RETURN: - 200 (HTTP) + Boolean [1]
- Integer | |
import json
import re
from struct import unpack
BLEND_MODE = (
'normal',
'additive',
'multiply',
'screen'
)
ATTACHMENT_TYPE = (
'region',
'boundingbox',
'mesh',
'skinnedmesh'
)
scale = 1
class BinaryStream:
def __init__(self, base_stream):
self.base_stream = base_stream
def readBool(self):
return self.readByte() != 0
def readByte(self):
return ord(self.base_stream.read(1))
def readBytes(self, length):
return self.base_stream.read(length)
def readInt(self):
b = self.readByte()
result = b & 0x7f
if (b & 0x80):
b = self.readByte()
result |= (b & 0x7f) << 7
if (b & 0x80):
b = self.readByte()
result |= (b & 0x7f) << 14
if (b & 0x80):
b = self.readByte()
result |= (b & 0x7f) << 21
if (b & 0x80):
b = self.readByte()
result |= (b & 0x7f) << 28
result -= 0xffffffff + 1
return result
def readIntArray(self):
arr = [self.readInt() for i in range(self.readInt())]
return arr
def readShort(self):
return self.unpack('>H', 2)
def readShortArray(self):
arr = [self.readShort() for i in range(self.readInt())]
return arr
def readFloat(self):
return self.unpack('>f', 4)
def readFloatArray(self):
arr = [self.readFloat() * scale for i in range(self.readInt())]
return arr
def readString(self):
length = self.readInt()
if length == 0:
return None
if length == 1:
return ""
length -= 1
return self.unpack(str(length) + 's', length).decode()
def readHex(self, length):
return self.readBytes(length).hex()
def unpack(self, fmt, length=1):
return unpack(fmt, self.readBytes(length))[0]
def readSkin():
if (slotCnt := stream.readInt()) == 0:
return None
skin = {}
for i in range(slotCnt):
slotIdx = stream.readInt()
slot = {}
for i in range(stream.readInt()):
name = stream.readString()
attachment = readAttachment(name)
slot[name] = attachment
skin[data['slots'][slotIdx]['name']] = slot
return skin
def readAttachment(attachmentName):
if (name := stream.readString()) is None:
name = attachmentName
at = ATTACHMENT_TYPE[stream.readInt()]
if at == 'region':
if (path := stream.readString()) is None:
path = name
region = {}
region['type'] = 'region'
region['name'] = name
region['path'] = path
region['x'] = stream.readFloat() * scale
region['y'] = stream.readFloat() * scale
region['scaleX'] = stream.readFloat()
region['scaleY'] = stream.readFloat()
region['rotation'] = stream.readFloat()
region['width'] = stream.readFloat() * scale
region['height'] = stream.readFloat() * scale
region['color'] = stream.readHex(4)
return region
if at == 'boundingbox':
box = {}
box['type'] = 'boundingbox'
box['name'] = name
box['vertices'] = readFloatArray()
return box
if at == 'mesh':
if (path := stream.readString()) is None:
path = name
mesh = {}
mesh['type'] = 'mesh'
mesh['name'] = name
mesh['path'] = path
mesh['uvs'] = stream.readFloatArray()
mesh['triangles'] = stream.readShortArray()
mesh['vertices'] = stream.readFloatArray()
mesh['color'] = stream.readHex(4)
mesh['hull'] = stream.readInt()
if nonessential:
mesh['edges'] = stream.readIntArray()
mesh['width'] = stream.readFloat() * scale
mesh['height'] = stream.readFloat() * scale
return mesh
if at == 'skinnedmesh':
if (path := stream.readString()) is None:
path = name
skinnedmesh = {}
skinnedmesh['type'] = 'skinnedmesh'
skinnedmesh['name'] = name
skinnedmesh['path'] = path
skinnedmesh['uvs'] = stream.readFloatArray()
skinnedmesh['triangles'] = stream.readShortArray()
skinnedmesh['vertices'] = []
for i in range(stream.readInt()):
skinnedmesh['vertices'].append(stream.readFloat())
skinnedmesh['color'] = stream.readHex(4)
skinnedmesh['hull'] = stream.readInt()
if nonessential:
skinnedmesh['edges'] = stream.readIntArray()
skinnedmesh['width'] = stream.readFloat() * scale
skinnedmesh['height'] = stream.readFloat() * scale
return skinnedmesh
return None
def readAnimation():
animation = {}
duration = 0
slots = {}
for i in range(stream.readInt()):
slotIdx = stream.readInt()
slotMap = {}
for j in range(stream.readInt()):
timelineType = stream.readByte()
frameCnt = stream.readInt()
if timelineType == 4:
timeline = []
for frameIdx in range(frameCnt):
timeline.append({})
timeline[frameIdx]['time'] = stream.eradFloat()
timeline[frameIdx]['color'] = stream.readHex(4)
if frameIdx < frameCnt - 1:
readCurve(frameIdx, timeline)
slotMap['color'] = timeline
elif timelineType == 3:
timeline = []
for frameIdx in range(frameCnt):
timeline.append({})
timeline[frameIdx]['time'] = stream.readFloat()
timeline[frameIdx]['name'] = stream.readString()
slotMap['attachment'] = timeline
duration = max(duration, timeline[frameCnt-1]['time'])
slots[data['slots'][slotIdx]['name']] = slotMap
animation['slots'] = slots
bones = {}
for i in range(stream.readInt()):
boneIdx = stream.readInt()
boneMap = {}
for j in range(stream.readInt()):
timelineType = stream.readByte()
frameCnt = stream.readInt()
if timelineType == 1:
timeline = []
for frameIdx in range(frameCnt):
timeline.append({})
timeline[frameIdx]['time'] = stream.readFloat()
timeline[frameIdx]['angle'] = stream.readFloat()
if frameIdx < frameCnt - 1:
readCurve(frameIdx, timeline)
boneMap['rotate'] = timeline
elif timelineType == 2 or timelineType == 0:
timeline = []
timelineScale = 1
if timelineType == 2:
timelineScale = scale
for frameIdx in range(frameCnt):
timeline.append({})
timeline[frameIdx]['time'] = stream.readFloat()
timeline[frameIdx]['x'] = stream.readFloat()
timeline[frameIdx]['y'] = stream.readFloat()
if frameIdx < frameCnt - 1:
readCurve(frameIdx, timeline)
if timelineType == 0:
boneMap['scale'] = timeline
else:
boneMap['translate'] = timeline
elif timelineType == 5 or timelineType == 6:
timeline = []
for frameIdx in range(frameCnt):
timeline.append({})
timeline[frameIdx]['time'] = stream.readFloat()
if timelineType == 5:
timeline[frameIdx]['x'] = stream.readBool()
elif timelineType == 6:
timeline[frameIdx]['y'] = stream.readBool()
if timelineType == 5:
boneMap['flipX'] = timeline
else:
boneMap['flipY'] = timeline
duration = max(duration, timeline[frameCnt-1]['time'])
bones[data['bones'][boneIdx]['name']] = boneMap
animation['bones'] = bones
ik = {}
for i in range(stream.readInt()):
ikIdx = stream.readInt()
frameCnt = stream.readInt()
timeline = []
for frameIdx in range(frameCnt):
timeline.append({})
timeline[frameIdx]['time'] = stream.readFloat()
timeline[frameIdx]['mix'] = stream.readFloat()
timeline[frameIdx]['bendPositive'] = stream.readBool()
if frameIdx < frameCnt - 1:
readCurve(frameIdx, timeline)
ik[data[ikIdx]] = timeline
animation['ik'] = ik
ffd = {}
for i in range(stream.readInt()):
skinIdx = stream.readInt()
slotMap = {}
for j in range(stream.readInt()):
slotIdx = stream.readInt()
meshMap = {}
for k in range(stream.readInt()):
meshName = stream.readString()
frameCnt = stream.readInt()
attachment = None
attachments = data['skins'][data['skinName'][skinIdx]]\
[data['slots'][slotIdx]['name']]
for attachmentName in attachments:
if attachments[attachmentName]['name'] == meshName:
attachment = attachments[attachmentName]
if not attachment:
print("FFD attachment not found: " + meshName);
timeline = []
for frameIdx in range(frameCnt):
time = stream.readFloat()
if attachment['type'] == 'mesh':
vertexCnt = len(attachment['vertices'])
else:
vertexCnt = len(attachment['uvs']) * 3 * 3
# This maybe wrong
vertices = []
for verticeIdx in range(vertexCnt):
vertices[verticeIdx] = 0.0
bugFixMultiplicator = 0.1
if (end := stream.readInt()) == 0:
if attachment['type'] == 'mesh':
for verticeIdx in range(vertexCnt):
vertices[verticeIdx] += attachment['vertices']\
[verticeIdx] * \
bugFixMultiplicator
else:
start = (v := stream.readInt())
end += start
while v < end:
vertices[v] = stream.readFloat() * scale
v += 1
if attachment['type'] == 'mesh':
meshVertices = attachment['vertices']
for v in range(len(vertices)):
vertices[v] += meshVertices[v] * \
bugFixMultiplicator
timeline.append({})
timeline[frameIdx]['time'] = time
timeline[frameIdx]['vertices'] = vertices
if frameIdx < frameCnt - 1:
readCurve(frameIdx, timeline)
meshMap[meshName] = timeline
duration = max(duration, timeline[frameCnt-1]['time'])
slotMap[data['slots'][slotIdx]['name']] = meshMap
ffd[data['skinsName'][skinIdx]] = slotMap
animation['ffd'] = ffd
if (drawOrderCnt := stream.readInt()):
drawOrders = []
for i in range(drawOrderCnt):
drawOrderMap = {}
offsets = []
for j in range(stream.readInt()):
offsetMap = {}
offsetMap['slot'] = data['slots'][stream.readInt()]['name']
offsetMap['offset'] = stream.readInt()
offsets.append(offsetMap)
drawOrderMap['offsets'] = offsets
drawOrderMap['time'] = stream.readFloat()
drawOrders.append(drawOrderMap)
duration = max(duration, drawOrders[drawOrderCnt-1]['time'])
animation['drawOrder'] = drawOrders
if (eventCnt := stream.readInt()):
events = []
for i in range(eventCnt):
events.append({})
time = stream.readFloat()
events[i]['name'] = (name := data['eventsName'][stream.readInt()])
events[i]['int'] = stream.readInt()
events[i]['float'] = stream.readFloat()
events[i]['string'] = stream.readString() if stream.readBool() \
else ""
events[i]['time'] = time
duration = max(duration, events[eventCnt-1]['time'])
animation['events'] = events
return animation
def readCurve(frameIdx, timeline):
if (curve := stream.readByte()) == 1:
timeline[frameIdx]['curve'] = 'stepped'
elif curve == 2:
timeline[frameIdx]['curve'] = [stream.readFloat(), stream.readFloat(),
stream.readFloat(), stream.readFloat()]
def repl(mo):
x = str(mo.group())
a, b = x.split('e-')
c, d = a.split('.')
return '0.' + '0' * (int(b)-1) + c + d
with open('Kalina.skel.txt', 'rb') as f:
stream = BinaryStream(f)
data = {}
# skeleton
data['skeleton'] = {}
data['skeleton']['hash'] = stream.readString()
data['skeleton']['spine'] = stream.readString()
data['skeleton']['width'] = stream.readFloat()
data['skeleton']['height'] = stream.readFloat()
if (nonessential := stream.readBool()):
data['skeleton']['images'] = stream.readString()
# Bones
data['bones'] = []
for i in range(stream.readInt()):
data['bones'].append({})
data['bones'][i]['name'] = stream.readString()
data['bones'][i]['parent'] = None if (parentIdx := stream.readInt()-1) == -1 \
else data['bones'][parentIdx]['name']
data['bones'][i]['x'] = stream.readFloat() * scale
data['bones'][i]['y'] = stream.readFloat() * scale
data['bones'][i]['scaleX'] = stream.readFloat()
data['bones'][i]['scaleY'] = stream.readFloat()
data['bones'][i]['rotation'] = stream.readFloat()
data['bones'][i]['length'] = stream.readFloat() * scale
data['bones'][i]['flipX'] = stream.readBool()
data['bones'][i]['flipY'] = stream.readBool()
data['bones'][i]['inheritScale'] = stream.readBool()
data['bones'][i]['inheritRotation'] = stream.readBool()
if nonessential:
data['bones'][i]['color'] = stream.readHex(4)
# Ik Constraints
if (ikIdx := stream.readInt()):
data['ik'] = []
for i in range(ikIdx):
data['ik'].append({})
data['ik']['name'] = stream.readString()
data['ik']['bones'] = []
for i in range(stream.readInt()):
data['ik']['bones'].append(data['ik'][stream.readInt()]['name'])
data['ik']['target'] = data['ik'][stream.readInt()]['name']
data['ik']['mix'] = stream.readFloat()
data['bendPositive'] = stream.readBool()
# Slots
data['slots'] = []
for i in range(stream.readInt()):
data['slots'].append({})
data['slots'][i]['name'] = stream.readString()
data['slots'][i]['bone'] = data['bones'][stream.readInt()]['name']
data['slots'][i]['color'] = stream.readHex(4)
data['slots'][i]['attachment'] = stream.readString()
data['slots'][i]['blend'] = BLEND_MODE[stream.readInt()]
# Default Skin
data['skins'] = {}
data['skinsName'] = []
skins = {}
if (defaultSkin := readSkin()) is not None:
data['skins']['default'] = defaultSkin
data['skinsName'].append('default')
# Skin
for i in range(stream.readInt()):
skinName = readString()
skin = stream.readSkin()
skins[skinName] = skin
data['skinsName'].append(skinName)
# Events
data['events'] = {}
data['eventsName'] = []
| |
the current working Strike List.([{id: 'b/b/v/f'}, {id: 'aa/f/h'}])
@staticmethod
def _strikeList_operations_add(self, strike):
"""
Adds a list of strikes to the current working Strike List.([{id: 'b/b/v/f'}, {id: 'aa/f/h'}])
:param strike (list): The list of strikes to add.
list of object with fields
id (java.lang.String): Strike path.
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/strikeList/operations/add', headers={'content-type': 'application/json'}, data=json.dumps({'strike': strike}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Adds a flow to the current working SuperFlow
@staticmethod
def _superflow_operations_addAction(self, flowid, name, actionid, source):
"""
Adds a flow to the current working SuperFlow
:param flowid (java.lang.Integer): The flow id.
:param name (java.lang.String): The name of the action definition.
:param actionid (java.lang.Integer): The new action id.
:param source (java.lang.String): The action source.
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/superflow/operations/addAction', headers={'content-type': 'application/json'}, data=json.dumps({'flowid': flowid, 'name': name, 'actionid': actionid, 'source': source}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### null
@staticmethod
def _network_operations_list(self, userid, clazz, sortorder, sort, limit, offset):
"""
:param userid (string):
:param clazz (string):
:param sortorder (string):
:param sort (string):
:param limit (integer):
:param offset (integer):
:return returnArg (list):
list of object with fields
name (string):
type (string):
author (string):
createdOn (string):
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/network/operations/list', headers={'content-type': 'application/json'}, data=json.dumps({'userid': userid, 'clazz': clazz, 'sortorder': sortorder, 'sort': sort, 'limit': limit, 'offset': offset}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Removes a SuperFlow from the current working Application Profile.
@staticmethod
def _appProfile_operations_remove(self, superflow):
"""
Removes a SuperFlow from the current working Application Profile.
:param superflow (string): The name of the super flow.
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/appProfile/operations/remove', headers={'content-type': 'application/json'}, data=json.dumps({'superflow': superflow}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Sets the card mode of a board
@staticmethod
def _topology_operations_setCardMode(self, board, mode):
"""
Sets the card mode of a board
:param board (java.lang.Integer):
:param mode (java.lang.Integer): the new mode: 10 for BPS-L23, 7 for BPS-L47, 3 for Non-BPS
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/topology/operations/setCardMode', headers={'content-type': 'application/json'}, data=json.dumps({'board': board, 'mode': mode}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Sets the card speed of a board
@staticmethod
def _topology_operations_setCardSpeed(self, board, speed):
"""
Sets the card speed of a board
:param board (java.lang.Integer):
:param speed (java.lang.Integer):
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/topology/operations/setCardSpeed', headers={'content-type': 'application/json'}, data=json.dumps({'board': board, 'speed': speed}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Sets the card fanout of a board
@staticmethod
def _topology_operations_setCardFanout(self, board, fanout):
"""
Sets the card fanout of a board
:param board (java.lang.Integer):
:param fanout (java.lang.Integer):
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/topology/operations/setCardFanout', headers={'content-type': 'application/json'}, data=json.dumps({'board': board, 'fanout': fanout}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Sets the card fanout of a board
@staticmethod
def _topology_operations_setPerfAcc(self, board, perfacc):
"""
Sets the card fanout of a board
:param board (java.lang.Integer):
:param perfacc (java.lang.Boolean):
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/topology/operations/setPerfAcc', headers={'content-type': 'application/json'}, data=json.dumps({'board': board, 'perfacc': perfacc}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### null
@staticmethod
def _network_operations_saveAs(self, name, regenerateOldStyle=True, force=False):
"""
:param name (string): The new name given for the current working network config
:param regenerateOldStyle (boolean): Force to apply the changes made on the loaded network configuration. Force to generate a network from the old one.
:param force (boolean): Force to save the network config. It replaces a pre-existing config having the same name.
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/network/operations/saveAs', headers={'content-type': 'application/json'}, data=json.dumps({'name': name, 'regenerateOldStyle': regenerateOldStyle, 'force': force}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### null
@staticmethod
def _network_operations_save(self, name=None, regenerateOldStyle=True, force=True):
"""
:param name (string): The new name given for the current working network config
:param regenerateOldStyle (boolean): Force to apply the changes made on the loaded network configuration. Force to generate a network from the old one.
:param force (boolean): Force to save the network config. It replaces a pre-existing config having the same name.
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/network/operations/save', headers={'content-type': 'application/json'}, data=json.dumps({'name': name, 'regenerateOldStyle': regenerateOldStyle, 'force': force}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### null
@staticmethod
def _appProfile_operations_exportAppProfile(self, name, attachments, filepath):
"""
:param name (java.lang.String): The name of the test model to be exported.
:param attachments (java.lang.Boolean): True if object attachments are needed.
:param filepath (java.lang.String): The local path where to save the exported object.
"""
appWrapper = self._wrapper
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/appProfile/operations/exportAppProfile', headers={'content-type': 'application/json'}, data=json.dumps({'name': name, 'attachments': attachments, 'filepath': filepath}), verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
with open(filepath, 'wb') as fd:
for chunk in r.iter_content(chunk_size=1024):
fd.write(chunk)
fd.close()
r.close()
return {'status_code': r.status_code, 'content': 'success'}
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Imports a test model, given as a file.
@staticmethod
def _testmodel_operations_importModel(self, name, filename, force):
"""
Imports a test model, given as a file.
:param name (java.lang.String): The name of the object being imported
:param filename (java.lang.String): The file containing the object
:param force (java.lang.Boolean): Force to import the file and the object having the same name will be replaced.
"""
appWrapper = self._wrapper
files = {'file': (name, open(filename, 'rb'), 'application/xml')}
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/testmodel/operations/importModel', files=files, data={'fileInfo':str({'name': name, 'filename': filename, 'force': force})}, verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Imports an application profile, given as a file.
@staticmethod
def _appProfile_operations_importAppProfile(self, name, filename, force):
"""
Imports an application profile, given as a file.
:param name (java.lang.String): The name of the object being imported
:param filename (java.lang.String): The file containing the object
:param force (java.lang.Boolean): Force to import the file and the object having the same name will be replaced.
"""
appWrapper = self._wrapper
files = {'file': (name, open(filename, 'rb'), 'application/xml')}
r = appWrapper.session.post(url='https://' + appWrapper.host + '/bps/api/v2/core/appProfile/operations/importAppProfile', files=files, data={'fileInfo':str({'name': name, 'filename': filename, 'force': force})}, verify=False)
jsonContent = r.content is not None and (r.content.startswith(b'{') or r.content.startswith(b'['))
if(r.status_code == 200):
return json.loads(r.content) if jsonContent else r.content
else:
return {'status_code': r.status_code, 'content': json.loads(r.content) if jsonContent else r.content}
### Imports a network neighborhood model, given as a file.
@staticmethod
def _network_operations_importNetwork(self, name, filename, force):
"""
Imports a network neighborhood model, given as a file.
:param name (java.lang.String): The name of the object being imported
:param filename (java.lang.String): The file containing the | |
# -*- coding: utf8 -*-
#
# Module PLOT
#
# Part of Nutils: open source numerical utilities for Python. Jointly developed
# by HvZ Computational Engineering, TU/e Multiscale Engineering Fluid Dynamics,
# and others. More info at http://nutils.org <<EMAIL>>. (c) 2014
"""
The plot module aims to provide a consistent interface to various plotting
backends. At this point `matplotlib <http://matplotlib.org/>`_ and `vtk
<http://vtk.org>`_ are supported.
"""
from __future__ import print_function, division
from . import numpy, log, core, cache, numeric, _
import os, warnings, sys, subprocess
class BasePlot( object ):
'base class for plotting objects'
def __init__ ( self, name=None, ndigits=0, index=None, outdir=None ):
'constructor'
self.path = outdir or core.getoutdir()
self.name = name
self.index = index
self.ndigits = ndigits
def getpath( self, name, index, ext ):
if name is None:
name = self.name
if index is None:
index = self.index
if self.ndigits and index is None:
index = _getnextindex( self.path, name, ext )
if index is not None:
name += str(index).rjust( self.ndigits, '0' )
name += '.' + ext
log.path( name )
return os.path.join( self.path, name )
def __enter__( self ):
'enter with block'
assert self.name, 'name must be set to use as with-context'
return self
def __exit__( self, exc_type, exc_value, exc_tb ):
'exit with block'
if not exc_type:
self.save( self.name, self.index )
try:
self.close()
except Exception as e:
log.error( 'failed to close:', e )
def __del__( self ):
try:
self.close()
except Exception as e:
log.error( 'failed to close:', e )
def save( self, name=None, index=None ):
pass
def close( self ):
pass
class PyPlot( BasePlot ):
'matplotlib figure'
def __init__( self, name=None, imgtype=None, ndigits=3, index=None, **kwargs ):
'constructor'
import matplotlib
matplotlib.use( 'Agg', warn=False )
from matplotlib import pyplot
BasePlot.__init__( self, name, ndigits=ndigits, index=index )
self.imgtype = imgtype or core.getprop( 'imagetype', 'png' )
self._fig = pyplot.figure( **kwargs )
self._pyplot = pyplot
def __enter__( self ):
'enter with block'
# make this figure active
self._pyplot.figure(self._fig.number)
return super( PyPlot, self ).__enter__()
def __getattr__( self, attr ):
pyplot = self.__dict__['_pyplot'] # avoid recursion
return getattr( pyplot, attr )
def close( self ):
'close figure'
if not self._fig:
return # already closed
try:
self._pyplot.close( self._fig )
except Exception as e:
log.warning( 'failed to close figure: {}'.format(e) )
self._fig = None
def save( self, name=None, index=None ):
'save images'
assert self._fig, 'figure is closed'
for ext in self.imgtype.split( ',' ):
self.savefig( self.getpath(name,index,ext) )
def segments( self, points, color='black', **kwargs ):
'plot line'
segments = numpy.concatenate( [ numpy.array([xy[:-1],xy[1:]]).swapaxes(0,1) for xy in points ], axis=0 )
from matplotlib.collections import LineCollection
lc = LineCollection( segments, **kwargs )
ax = self.gca()
ax.add_collection( lc )
if isinstance( color, str ):
lc.set_color( color )
else:
array = numpy.concatenate( [ .5 * ( v[:-1] + v[1:] ) for v in color ], axis=0 )
lc.set_array( array )
self.sci( lc )
return lc
def mesh( self, points, values=None, edgecolors='k', edgewidth=.1, mergetol=0, setxylim=True, aspect='equal', tight=True, **kwargs ):
'plot elemtwise mesh'
kwargs.pop( 'triangulate', None ) # ignore deprecated argument
if not isinstance( points, numpy.ndarray ) and points[0].shape[1] == 1: # line plot
if values is not None:
self.segments( [ numpy.concatenate( [x,y[:,_]], axis=1 ) for x, y in zip( points, values ) ], values )
return
if isinstance( points, numpy.ndarray ): # bulk data
assert points.shape[-1] == 2
import matplotlib.tri
tri = matplotlib.tri.Triangulation( *points.reshape(-1,2).T )
edgecolors = 'none'
if values is not None:
values = values.ravel()
else: # mesh data
tri, edges = triangulate( points, mergetol )
if values is not None:
values = numpy.concatenate( values, axis=0 )
if values is not None:
self.tripcolor( tri, values, shading='gouraud', **kwargs )
if edgecolors != 'none':
self.segments( edges, linewidth=edgewidth )
if aspect:
( self.aspect if tight else self.axis )( aspect )
if setxylim:
self.autoscale( enable=True, axis='both', tight=True )
return tri
def aspect( self, *args, **kwargs ):
self.gca().set_aspect( *args, **kwargs )
def tripcolor( self, *args, **kwargs ):
import matplotlib.tri
assert len(args) >= 2
if isinstance( args[0], numpy.ndarray ) and isinstance( args[1], numpy.ndarray ):
# args = x, y[, triangles[, mask]], values
tri = matplotlib.tri.Triangulation( *args[:-1] )
values = args[-1]
else:
assert len(args) == 2
tri, values = args
if not isinstance( tri, matplotlib.tri.Triangulation ):
tri, edges = triangulate( tri, mergetol )
if not isinstance( values, numpy.ndarray ):
values = numpy.concatenate( values, axis=0 )
assert len(tri.x) == len(values)
mask = ~numpy.isfinite( values )
if mask.any():
tri = matplotlib.tri.Triangulation( tri.x, tri.y, tri.triangles, mask[tri.triangles].any(axis=1) )
return self._pyplot.tripcolor( tri, values, **kwargs )
def tricontour( self, tri, values, every=None, levels=None, mergetol=0, **kwargs ):
assert not every or levels is None, '"every" and "levels" arguments are mutually exclusive'
import matplotlib.tri
if not isinstance( tri, matplotlib.tri.Triangulation ):
tri, edges = triangulate( tri, mergetol )
if not isinstance( values, numpy.ndarray ):
values = numpy.concatenate( values, axis=0 )
assert len(tri.x) == len(values)
if every:
levels = numpy.arange( int(min(values)/every), int(max(values)/every)+1 ) * every
return self._pyplot.tricontour( tri, values, levels=levels, **kwargs )
def streamplot( self, tri, velo, spacing, bbox=None, mergetol=1e-5, linewidth=None, color=None, **kwargs ):
if isinstance( spacing, numpy.ndarray ):
# compatibility with original streamplot function definition
x = tri
y = velo
u = spacing
v = bbox
else:
import matplotlib.tri
if not isinstance( tri, matplotlib.tri.Triangulation ):
tri, edges = triangulate( tri, mergetol=mergetol )
if not isinstance( velo, numpy.ndarray ):
velo = numpy.concatenate( velo, axis=0 )
assert len(tri.x) == len(velo)
if bbox is None:
xlim = min(tri.x), max(tri.x)
ylim = min(tri.y), max(tri.y)
else:
xlim, ylim = bbox
nx = int( ( xlim[-1] - xlim[0] ) / spacing )
ny = int( ( ylim[-1] - ylim[0] ) / spacing )
assert nx > 0 and ny > 0
x = .5 * (xlim[0]+xlim[-1]) + ( numpy.arange(nx) - (nx-1)/2 ) * spacing
y = .5 * (ylim[0]+ylim[-1]) + ( numpy.arange(ny) - (ny-1)/2 ) * spacing
uv = interpolate( tri, numeric.meshgrid(x,y).T, velo, mergetol=mergetol )
u = uv[...,0]
v = uv[...,1]
assert isinstance( x, numpy.ndarray ) and x.ndim == 1
assert isinstance( y, numpy.ndarray ) and y.ndim == 1
assert isinstance( u, numpy.ndarray ) and u.shape == (len(y),len(x))
assert isinstance( v, numpy.ndarray ) and v.shape == (len(y),len(x))
if linewidth is not None and linewidth < 0: # convention: negative linewidth is scaled with velocity magnitude
linewidth = -linewidth * numpy.sqrt( u**2 + v**2 )
if color is None: # default: color mapped to velocity magnitude
color = numpy.sqrt( u**2 + v**2 )
return self._pyplot.streamplot( x, y, u, v, linewidth=linewidth, color=color, **kwargs )
def polycol( self, verts, facecolors='none', **kwargs ):
'add polycollection'
from matplotlib import collections
if facecolors != 'none':
assert isinstance(facecolors,numpy.ndarray) and facecolors.shape == (len(verts),)
array = facecolors
facecolors = None
polycol = collections.PolyCollection( verts, facecolors=facecolors, **kwargs )
if facecolors is None:
polycol.set_array( array )
self.gca().add_collection( polycol )
self.sci( polycol )
return polycol
def slope_marker( self, x, y, slope=None, width=.2, xoffset=0, yoffset=.2, color='0.5' ):
'slope marker'
ax = self.gca()
if slope is None:
x_, x = x[-2:]
y_, y = y[-2:]
slope = numpy.log(y/y_) / numpy.log(x/x_)
slope = numpy.round( slope * 100 ) / 100.
if float(slope) > 0:
width = -width
xscale = ax.get_xscale()
xmin, xmax = ax.get_xlim()
if xscale == 'linear':
W = ( xmax - xmin ) * width
x0 = x - W
xc = x - .5 * W
elif xscale == 'log':
W = numpy.log10( xmax / xmin ) * width
x0 = x * 10**-W
xc = x * 10**(-.5*W)
else:
raise Exception( 'unknown x-axis scale %r' % xscale )
yscale = ax.get_yscale()
H = W * float(slope)
if yscale == 'linear':
y0 = y - H
yc = y - .5 * H
elif yscale == 'log':
y0 = y * 10**-H
yc = y * 10**(-.5*H)
else:
raise Exception( 'unknown x-axis scale %r' % xscale )
from matplotlib import transforms
dpi = self.gcf().dpi_scale_trans
shifttrans = ax.transData + transforms.ScaledTranslation( xoffset, numpy.sign(H) * yoffset, dpi )
triangle = self.Polygon( [ (x0,y0), (x,y), (xc,y) ], closed=False, ec=color, fc='none', transform=shifttrans )
ax.add_patch( triangle )
self.text( xc, yc, str(slope), color=color,
horizontalalignment = 'right' if W > 0 | |
<reponame>ACSLab/pheeno_robot_code<gh_stars>1-10
"""
Author: <NAME> based heavily upon <NAME>'s tracking code
from UCLA REU (camera.py).
"""
# Import NumPy Libraries
import numpy as np
from numpy import average as avg
from numpy import subtract as sub
# Import System Libraries
import math
# Import OpenCV Libraries
import cv2
def update(x):
""" Get track bar position and update its value. """
global VAL
global MIN_SIZE
global MAX_SIZE
global MIN_VAL
global MAX_VAL
global DARKNESS_THRESHOLD
VAL = cv2.getTrackbarPos('VAL', 'trackFrame')
MIN_SIZE = cv2.getTrackbarPos('MIN_SIZE', 'trackFrame')
MAX_SIZE = cv2.getTrackbarPos('MAX_SIZE', 'trackFrame')
MIN_VAL = cv2.getTrackbarPos('MIN_VAL', 'trackFrame')
MAX_VAL = cv2.getTrackbarPos('MAX_VAL', 'trackFrame')
DARKNESS_THRESHOLD = cv2.getTrackbarPos('DARKNESS_THRESHOLD', 'trackFrame')
""" Create window and track bars. """
cv2.namedWindow('trackFrame', cv2.WINDOW_NORMAL)
cv2.createTrackbar('VAL', 'trackFrame', VAL, 200, update)
cv2.createTrackbar('MIN_SIZE', 'trackFrame', MIN_SIZE, 2000, update)
cv2.createTrackbar('MAX_SIZE', 'trackFrame', MAX_SIZE, 4000, update)
cv2.createTrackbar('MIN_VAL', 'trackFrame', MIN_VAL, 200, update)
cv2.createTrackbar('MAX_VAL', 'trackFrame', MAX_VAL, 2000, update)
cv2.createTrackbar('DARKNESS_THRESHOLD', 'trackFrame',
DARKNESS_THRESHOLD, 100, update)
class RobotData(object):
"""
Robot Data class
Attributes
----------
center : Set of integers
The center position of the robot.
orientation : float
Something
updated : bool
The state of the classes attributes. If false, it will allow for
future value updates.
Methods
-------
update(center, angle)
Updates all the attributes of the class.
reset()
Resets the updated boolean attribute for future value updates.
"""
def __init__(self, center, orientation):
self.center = center
self.orientation = orientation
self.updated = True
# center is an (x,y) tuple, orientation is an angle in degrees measured
# from the positive x axis, frame is a number which designates which frame
# the robot is in, and updated is a boolean which tells if that particular
# robot has been updated
def __repr__(self):
new_center = integerize(
(self.center[0] * CMperPIXEL, self.center[1] * CMperPIXEL))
return ("Robot at " + str(new_center) + " with orientation " +
str(self.orientation) + ".")
def update(self, updated_center, updated_angle):
self.center = updated_center
self.orientation = updated_angle
self.updated = True
def reset(self):
self.updated = False
def threshold(src, value=100):
ret, thresh = cv2.threshold(src, VAL, 255, cv2.THRESH_BINARY)
return thresh
def findAprilTags(thresh, img):
# Contouring
contourImage, contours, hierarchy = cv2.findContours(
thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
return filter(lambda c: isTag(c, img), contours)
def isTag(c, img):
""" Determines if the image is a tag, based on its area and intensity. """
return (MIN_SIZE < cv2.contourArea(c) < MAX_SIZE) and \
(MIN_VAL < averageValue(c) < MAX_VAL) and \
goodAspectRatio(c)
def goodAspectRatio(c):
_, (width, height), _ = cv2.minAreaRect(c)
aspect_ratio = max([width / height, height / width])
return 1 < aspect_ratio < 2
def averageValue(img):
height, width = img.shape[:2]
val = avg(img.sum(axis=0).sum(axis=0))
return val / (height * width)
def drawTags(tagList, img):
""" Draw all contours in red, with thickness 2 """
cv2.drawContours(img, tagList, -1, DARK_RED, 2)
def drawCorners(bottom, left, top, right, img):
""" Draw contours in varying colors on an OpenCV image. """
# Draw all contours in green, with thickness 2.
cv2.circle(img, tuple(bottom), 1, GREEN, 2)
# Draw all contours in blue, with thickness 2.
cv2.circle(img, tuple(top), 1, BLUE, 2)
# Draw all contours in dark red, with thickness 2.
cv2.circle(img, tuple(left), 1, DARK_RED, 2)
# Draw all contours in a custom color, with thickness 2.
cv2.circle(img, tuple(right), 1, CUSTOM_COLOR, 2)
def drawRobots(img):
""" Marks each robot with its index and angle on an OpenCV image. """
arrow_length = 22
for index in Robots:
new_center = integerize(Robots[index].center)
angle = Robots[index].orientation
if index in MAPPING and MAPPING[index] != 'l':
cv2.circle(img, integerize(new_center), 2, RED, 4)
# Robot's name
cv2.putText(img, str(index), (new_center[0] + 28,
new_center[1]),
cv2.FONT_HERSHEY_SIMPLEX,
.7, CUSTOM_COLOR, 2)
if index in MAPPING and MAPPING[index] != 'l':
p2 = integerize((new_center[0] + arrow_length * math.cos(angle),
new_center[1] - arrow_length * math.sin(angle)))
cv2.line(img, new_center, p2, (255, 255, 0), 2, 2)
def updateDict(tag_list, img, thresh):
global Robots
tag_views = []
for tag in tag_list:
rect = cv2.minAreaRect(tag)
tag_img = getTagImg(tag, rect, img)
id_matrix = identify(tag_img)
# Get's the commands from the message to see if they are for
# the gripper.
if id_matrix is None:
continue
index = matrixToIndex(id_matrix)
if index is None:
# Get's the commands from the message to see if they are for
# the gripper.
continue
tag_views.append(tag_img)
angle = calculateAngle(tag, rect, id_matrix)
Robots[index] = RobotData(rect[0], angle)
# remove any robots from our list that were not updated
Robots = {key: rob for key, rob in Robots.items() if rob.updated}
# Get's the commands from the message to see if they are for the gripper.
for r in Robots.values():
r.reset()
return tag_views
def getTagImg(tag, rect, img):
"""
Extracts the image of the tag from the main image, and rotates it
appropriately.
"""
bottom, left, top, right = cv2.boxPoints(rect)
# drawCorners(bottom, left, top, right, imageTrack)
try:
if dist(left, top) < dist(left, bottom):
pos_slope = False
theta = math.atan((left[1] - bottom[1]) / (left[0] - bottom[0]))
else:
pos_slope = True
theta = math.atan((right[1] - bottom[1]) / (right[0] - bottom[0]))
except ZeroDivisionError:
theta = math.atan(float('inf')) # slope is pi/2
height = dist(right, bottom)
width = dist(right, top)
if pos_slope:
width, height = height, width
f_center = rect[0][0], rect[0][1]
return subimage(img, f_center, theta, width, height)
# Developed from code by user xaedes of stack overflow
# http://stackoverflow.com/questions/11627362/how-to-straighten-a-rotated-rectangle-area-of-an-image-using-opencv-in-python
def subimage(image, center, theta, width, height):
v_x = (np.cos(theta), np.sin(theta))
v_y = (-np.sin(theta), np.cos(theta))
s_x = center[0] - v_x[0] * (width / 2) - v_y[0] * (height / 2)
s_y = center[1] - v_x[1] * (width / 2) - v_y[1] * (height / 2)
mapping = np.array([[v_x[0], v_y[0], s_x],
[v_x[1], v_y[1], s_y]])
return cv2.warpAffine(image, mapping, (width, height),
flags=cv2.WARP_INVERSE_MAP,
borderMode=cv2.BORDER_REPLICATE)
def identify(img):
XBUF = 6 # pixels of buffer zone
YBUF = 3
matrix = np.zeros((VCELLS, HCELLS), dtype=bool)
threshed = threshold(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 132)
h, w, _ = np.shape(img)
x, y = 1, 1
dx = int((w - 2 * XBUF) / float(HCELLS))
dy = int((h - 2 * YBUF) / float(VCELLS))
for i in range(HCELLS):
for j in range(VCELLS):
# Because we're interested in the white squares now
white = not isBlack(threshed,
(x + XBUF + i * dx, y + YBUF + j * dy),
(x + XBUF + (i + 1) * dx,
y + YBUF + (j + 1) * dy), dx * dy, img)
if white is not None:
matrix[j, i] = white
else:
return None
return matrix
def largestContour(contour_list):
contour = None
size = 0
for current in contour_list:
current_area = cv2.contourArea(current)
if current_area > size:
contour = current
size = current_area
return contour
def isBlack(img, p1, p2, area, defacing):
# dark squares will have an intensity below this percentage
DT = DARKNESS_THRESHOLD / 100.0
intensity = 0
p1, p2 = integerize(p1), integerize(p2)
for x in range(p1[0], p2[0]):
for y in range(p1[1], p2[1]):
intensity += bool(img[y, x])
if x in (p1[0], p2[0] - 1) or y in (p1[1], p2[1] - 1):
defacing[y, x] = RED
if area == 0:
return None # this means that we are picking up some edge motion
filled = (intensity / float((p2[1] - p1[1]) * (p2[0] - p1[0]))) < DT
return filled
def dist(p1, p2):
""" Calculates the cartesian distance between two numpy array points. """
return np.linalg.norm(sub(p1, p2))
def calculateAngle(tag, rect, id_matrix):
bottom, left, top, right = cv2.boxPoints(rect)
drawCorners(bottom, left, top, right, imageTrack)
if dist(left, top) < dist(left, bottom):
if left[0] == bottom[0]:
theta = math.atan(-float('inf')) # avoid division by zero
else:
theta = math.atan2((bottom[1] - left[1]), (left[0] - bottom[0]))
theta -= math.pi / 2
else:
if right[0] == bottom[0]:
theta = math.atan(-float('inf')) # avoid division by zero
else:
theta = math.atan2((bottom[1] - left[1]), (left[0] - bottom[0]))
# Top is light
if id_matrix[0, 0] and id_matrix[1, 0] and id_matrix[2, 0]:
return theta
# Bottom is light
elif id_matrix[0, 2] and id_matrix[1, 2] and id_matrix[2, 2]:
return theta + math.pi
# no else case because any such matricies would already be filtered out by
# matrixToIndex (returns None)
def binaryDigitsToDecimalString(L):
return str(int(''.join([str(int(x)) for x in L]), 2))
def matrixToIndex(matrix):
if np.all(matrix[:, 0]):
index = binaryDigitsToDecimalString(
matrix[:, 2]) + binaryDigitsToDecimalString(matrix[:, 1])
elif np.all(matrix[:, 2]):
index = binaryDigitsToDecimalString(
matrix[:, 0][::-1]) + \
binaryDigitsToDecimalString(matrix[:, 1][::-1])
else:
index = None
return index
def fixRobotData(robot_id, tag_center_dist):
global Robots
if robot_id in MAPPING and MAPPING[robot_id] != 'l':
center = Robots[robot_id].center
angle = Robots[robot_id].orientation
true_center = (center[0] + math.cos(angle) * tag_center_dist,
center[1] - math.sin(angle) * tag_center_dist)
Robots[robot_id].center = | |
<gh_stars>10-100
#!/usr/bin/env python3
"""Starts the user interface of gmoshui."""
from _version import __version__
from view import mainwindow, progressdialog
from PySide2 import QtCore, QtGui
from PySide2.QtWidgets import *
from PySide2.QtGui import *
from PySide2.QtCore import *
from functools import partial
import workshoputils
import addoninfo
import gmpublish
import gmafile
import sys
import shiboken2 as shiboken
import os
import re
from gmodfolder import GModFolder
class ControlMainWindow(QMainWindow):
"""Spawns the main window"""
def __init__(self, parent=None):
super(ControlMainWindow, self).__init__(parent)
self.ui = mainwindow.Ui_MainWindow()
self.ui.setupUi(self)
self.setWindowTitle("GMosh UI " + __version__)
# Create settings
QtCore.QCoreApplication.setOrganizationName("FPtje")
QtCore.QCoreApplication.setOrganizationDomain("github.com/FPtje/gmosh")
QtCore.QCoreApplication.setApplicationName("gmoshui")
self.ui.settings = QSettings()
def main():
"""Main method"""
app = QApplication(sys.argv)
mysw = ControlMainWindow()
initialiseUI(mysw.ui)
mysw.show()
sys.exit(app.exec_())
def errorMsg(s):
"""Show an error message box"""
msgBox = QMessageBox()
msgBox.setText(s)
msgBox.exec_()
class OutLog:
"""Redirect stdout to ui of program"""
def __init__(self, signal, out=None):
"""
"""
self.signal = signal
self.out = out
def write(self, m):
self.signal.emit(m)
if self.out:
self.out.write(m)
def flush(x):
pass
class WorkBackground(QtCore.QThread):
"""Run something in the background"""
target = id
signal = QtCore.Signal(str)
finished = QtCore.Signal()
def run(self):
oldstdout = sys.stdout
sys.stdout = OutLog(self.signal, sys.stdout)
self.result = self.target()
self.signal.emit("<br /><h3>FINISHED</h3>")
sys.stdout = oldstdout
self.finished.emit()
def createProgressDialog(work, onresult=id):
"""Create progress dialog"""
dialog = QDialog()
ui = progressdialog.Ui_Dialog()
ui.setupUi(dialog)
ui.progressText.clear()
ui.buttonBox.setEnabled(False)
def onThreadOutput(text):
if not shiboken.isValid(ui) or not shiboken.isValid(ui.progressText): return
ui.progressText.moveCursor(QTextCursor.End)
if text[0] == "\r":
#cursor = QTextCursor(ui.progressText.textCursor())
ui.progressText.moveCursor(QTextCursor.StartOfLine, QTextCursor.KeepAnchor)
ui.progressText.moveCursor(QTextCursor.PreviousCharacter, QTextCursor.KeepAnchor)
ui.progressText.insertHtml(text.replace('\n', '<br />'))
def enableButtons():
ui.buttonBox.setEnabled(True)
onresult(thread.result)
thread = WorkBackground()
thread.target = work
thread.signal.connect(onThreadOutput)
thread.finished.connect(enableButtons)
thread.start()
dialog.show()
dialog.exec_()
thread.exit()
del thread
#######
# Addon tools signals
#######
def addRecentAddon(widget, addon):
recentAddons = widget.settings.value("addontools/recentaddons", [])
if not recentAddons: recentAddons = []
if type(recentAddons) is str: recentAddons = [recentAddons]
if addon in recentAddons: return False
recentAddons.insert(0, addon)
widget.settings.setValue("addontools/recentaddons", recentAddons)
return True
def removeRecentAddon(widget, addon):
recentAddons = widget.settings.value("addontools/recentaddons", [])
if type(recentAddons) is str: recentAddons = [recentAddons]
recentAddons.remove(addon)
widget.settings.setValue("addontools/recentaddons", recentAddons)
def moveRecentAddon(widget, fr, to):
recentAddons = widget.settings.value("addontools/recentaddons", [])
if type(recentAddons) is str: recentAddons = [recentAddons]
recentAddons.insert(to, recentAddons.pop(fr))
widget.settings.setValue("addontools/recentaddons", recentAddons)
illegalFilesFoundMessage = """\
<h1>Illegal files found!</h1>
<p>The addon contains some files that are not allowed to be in a GMA file.</p>
<p>These are the illegal files:</p>
%s
<p>It is recommended to either remove those files or to copy paste the above list in the "Files to ignore" box</p>
"""
def addonVerifyClicked(widget, show_ok = True):
verified, badlist = widget.currentAddon.verify_files()
if verified:
if show_ok: errorMsg("No illegal files were found. You're good to go!")
return True
dialog = QDialog()
ui = progressdialog.Ui_Dialog()
ui.setupUi(dialog)
ui.progressText.setText(illegalFilesFoundMessage % '<br />'.join(badlist))
ui.buttonBox.setEnabled(True)
dialog.show()
dialog.exec_()
return False
def addonCreateGMAClicked(widget):
fileName, _ = QFileDialog.getSaveFileName(None,
"Store GMA file", os.path.join(widget.settings.value("addontools/lastgmafolder", ''), 'out.gma'), "GMA files (*.gma)")
if not fileName: return
# Force .gma extension
fileName = os.path.splitext(fileName)[0] + '.gma'
folder, _ = os.path.split(fileName)
# Store last used folder location
widget.settings.setValue("addontools/lastgmafolder", folder)
# Verify the addon
if not addonVerifyClicked(widget, False): return
createProgressDialog(partial(widget.currentAddon.compress, fileName))
def publishNew(widget, publisher):
succeeded, output = publisher.create()
if succeeded:
widget.currentAddon.save_changes()
print("<h1>Upload succeeded!</h1><br />")
print("<p>The addon has been uploaded. Do check it out at </p>")
print('<a href="http://steamcommunity.com/sharedfiles/filedetails/?id=%s">http://steamcommunity.com/sharedfiles/filedetails/?id=%s</a>' % (output, output))
print("<br /><p>Note that you will have to change the visibility of this addon in the above link to make it visible for everyone.</p>")
return
print("<h1>Upload failed!</h1> <br />")
print("<p>The upload has failed! The error message can be read below:</p><br />")
print("<br /><tt>")
print(output)
print("</tt>")
def addonPublishClicked(widget):
if not widget.currentAddon.has_workshop_id() and not widget.currentAddon.getlogo():
errorMsg("Error: When uploading a new addon to the workshop, a 512x512 jpeg image must be given.\n"
"Please either enter a workshop id or provide a 512x512 jpeg image.")
return
if not addonVerifyClicked(widget, False): return
changelog = widget.addonChangelog.toPlainText() or widget.currentAddon.getdefault_changelog() or ''
publisher = gmpublish.GmPublish(widget.currentAddon)
if widget.currentAddon.has_workshop_id():
createProgressDialog(partial(publisher.update, changelog))
return
ok = QMessageBox.warning(None, "Upload new addon", "This will be uploaded as a new addon on the workshop. To update an existing addon, please fill in the workshop ID of that addon. Are you sure you want to upload this addon?", QMessageBox.Yes, QMessageBox.No) == QMessageBox.Yes
if not ok: return
createProgressDialog(partial(publishNew, widget, publisher))
def moveSelectedRecentAddon(widget, direction):
selected = widget.recentAddons.selectedIndexes()
for s in selected:
rowText = s.data()
path = widget.recentAddons.model().itemFromIndex(s).path
item = QStandardItem(rowText)
item.path = path
widget.recentAddons.model().removeRow(s.row())
widget.recentAddons.model().insertRow(s.row() + direction, item)
widget.recentAddons.selectionModel().clearSelection()
widget.recentAddons.selectionModel().select(widget.recentAddons.model().indexFromItem(item),
QItemSelectionModel.Select | QItemSelectionModel.Rows)
moveRecentAddon(widget, s.row(), s.row() + direction)
break
enableRecentAddonsUpDownButtons(widget)
def addonMoveUpClicked(widget):
moveSelectedRecentAddon(widget, -1)
def addonMoveDownClicked(widget):
moveSelectedRecentAddon(widget, 1)
def addRecentFolderClicked(widget):
fileName, _ = QFileDialog.getOpenFileName(None,
"Open addon.json file", widget.settings.value("selectAddonLastFolder", None), "addon.json files (*.json)")
if not fileName: return
folder, _ = os.path.split(fileName)
# Store last used folder location
widget.settings.setValue("selectAddonLastFolder", folder)
try:
addoninfo.get_addon_info(fileName)
except Exception:
errorMsg("%s does not contain valid json!" % fileName)
return
if not addRecentAddon(widget, fileName): return
item = QStandardItem(shortenPath(fileName))
item.path = fileName
widget.recentAddons.model().insertRow(0, item)
widget.recentAddons.selectionModel().clearSelection()
widget.recentAddons.selectionModel().select(widget.recentAddons.model().indexFromItem(item),
QItemSelectionModel.Select | QItemSelectionModel.Rows)
recentFolderSelected(widget, widget.recentAddons.model().indexFromItem(item))
def removeRecentFolderClicked(widget):
selected = widget.recentAddons.selectedIndexes()
for s in selected:
removeRecentAddon(widget, widget.recentAddons.model().itemFromIndex(s).path)
widget.recentAddons.model().removeRow(s.row())
# Select first item
if not widget.recentAddons.model().hasIndex(0, 0): return
widget.recentAddons.selectionModel().clearSelection()
firstItem = widget.recentAddons.model().index(0, 0)
widget.recentAddons.selectionModel().select(firstItem,
QItemSelectionModel.Select | QItemSelectionModel.Rows)
recentFolderSelected(widget, firstItem)
def recentFolderSelected(widget, index):
enableRecentAddonsUpDownButtons(widget)
path = widget.recentAddons.model().itemFromIndex(index).path
try:
addonInfo = addoninfo.get_addon_info(path)
except Exception:
return
widget.currentAddon = addonInfo or addoninfo.GModAddon(dict(), '.')
if not addonInfo: return
widget.addonChangelog.setText(addonInfo.getdefault_changelog())
widget.addonDefaultChangelog.setText(addonInfo.getdefault_changelog())
widget.addonTitle.setText(addonInfo.gettitle())
widget.addonDescription.setText(addonInfo.getdescription())
widget.addonIgnore.setText('\n'.join(addonInfo.getignored()))
tags = addonInfo.gettags()
widget.addonWorkshopid.setValue(addonInfo.getworkshopid())
widget.addonType.setCurrentIndex(widget.addonType.findText(addonInfo.gettype()))
widget.addonTag1.setCurrentIndex(widget.addonTag1.findText(len(tags) > 0 and tags[0] or 'None'))
widget.addonTag2.setCurrentIndex(widget.addonTag2.findText(len(tags) > 1 and tags[1] or 'None'))
widget.addonImage.setText(addonInfo.getlogo())
widget.addonPublish.setEnabled(True)
widget.addonVerify.setEnabled(True)
widget.addonCreateGMA.setEnabled(True)
widget.addonChangelog.setEnabled(True)
widget.addonSave.setEnabled(True)
widget.addonSaveAs.setEnabled(True)
widget.addonReset.setEnabled(True)
def addonSaveClicked(widget):
widget.currentAddon.save_changes()
def addonSaveAsClicked(widget):
fileName, _ = QFileDialog.getSaveFileName(None,
"Store addon.json file", os.path.join(widget.settings.value("addontools/lastsaveasfolder", ''), 'addon.json'), "json files (*.json)")
if not fileName: return
# Force .json extension
fileName = os.path.splitext(fileName)[0] + '.json'
folder, _ = os.path.split(fileName)
# Store last used folder location
widget.settings.setValue("addontools/lastsaveasfolder", folder)
widget.currentAddon.setfile(fileName)
widget.currentAddon.save_changes()
if not addRecentAddon(widget, fileName): return
# Add to recent addons list
item = QStandardItem(shortenPath(fileName))
item.path = fileName
widget.recentAddons.model().insertRow(0, item)
widget.recentAddons.selectionModel().clearSelection()
widget.recentAddons.selectionModel().select(widget.recentAddons.model().indexFromItem(item),
QItemSelectionModel.Select | QItemSelectionModel.Rows)
def addonResetClicked(widget):
selected = widget.recentAddons.selectedIndexes()
for s in selected:
recentFolderSelected(widget, s)
break
def updateAddonInfo(widget, key, target, fnvalue, *args):
value = fnvalue(target) if callable(fnvalue) else fnvalue
if not value:
if key in widget.currentAddon.data:
widget.currentAddon.data.pop(key)
else:
widget.currentAddon.data[key] = value
def updateAddonTags(widget, val):
tag1 = widget.addonTag1.currentText()
tag2 = widget.addonTag2.currentText()
tags = []
if tag1 and tag1 != 'None': tags.append(tag1)
if tag2 and tag2 != 'None': tags.append(tag2)
widget.currentAddon.data['tags'] = tags
def selectAddonImage(widget):
fileName, _ = QFileDialog.getOpenFileName(None,
"Open jpg file", widget.settings.value("addontools/lastlogofolder", None), "jpeg files (*.jpg *.jpeg)")
if not fileName: return
folder, _ = os.path.split(fileName)
# Store last used folder location
widget.settings.setValue("addontools/lastlogofolder", folder)
widget.addonImage.setText(fileName)
widget.currentAddon.data['logo'] = fileName
#######
# GMA tools signals
#######
def split_path(p):
"""Helper to split a path into components"""
a,b = os.path.split(p)
return (split_path(a) if len(a) and len(b) else []) + [b]
def folder_hierarchy(files):
"""Helper function that creates a hierarchy of folders and files"""
hierarchy = dict()
hierarchy['name'] = "GMA File" + ' ' * 40
hierarchy['children'] = dict()
hierarchy['size'] = 0
hierarchy['path'] = ''
for f in files:
split = split_path(f['name'])
hierarchy['size'] = hierarchy['size'] + f['puresize']
cur_h = hierarchy # Current hierarchy
i = 0
for sub in split:
i = i + 1
if not sub in cur_h['children']:
cur_h['children'][sub] = dict()
cur_h['children'][sub]['children'] = dict()
cur_h = cur_h['children'][sub]
cur_h['name'] = sub
cur_h['path'] = '/'.join(split[0:i])
cur_h['size'] = 'size' in cur_h and cur_h['size'] + f['puresize'] or f['puresize']
return hierarchy
def populate(model, hierarchy, root = None):
"""Populates the GMA file tree from a hierarchy created with folder_hierarchy"""
node = QStandardItem(hierarchy['name'])
size = QStandardItem(gmafile.sizeof_simple(hierarchy['size']))
node.filePath = size.filePath = hierarchy['path']
root.appendRow([node, size]) if root else model.appendRow([node, size])
for child in iter(sorted(hierarchy['children'])):
populate(model, hierarchy['children'][child], node)
return node
def openGmaFile(widget, fileName, error = True):
if fileName == '': return
try:
info = gmafile.gmaInfo(fileName)
except Exception:
if error: errorMsg("Could not recognise the format of this file!")
return
widget.settings.setValue("gmatools/lastgmafile", fileName)
widget.gmaName.setText(info['addon_name'])
widget.gmaDescription.setText('description' in info and info['description'] or info['addon_description'])
widget.gmaAuthor.setText(info['addon_author'])
widget.gmaAuthorID.setValue(float(info['steamid']))
widget.gmaTimestamp.setDateTime(QtCore.QDateTime.fromTime_t(info['timestamp']))
widget.gmaTags.setText('tags' in info and ', '.join(info['tags']) or '')
widget.gmaType.setText('type' in info and info['type'] or '')
# Tree view
model = QStandardItemModel()
model.setHorizontalHeaderLabels(['File', 'Size'])
widget.gmaFiles.setModel(model)
# Fill in data
hierarchy = folder_hierarchy(info['files'])
root = populate(model, hierarchy)
rootIndex = model.indexFromItem(root)
widget.gmaFiles.resizeColumnToContents(0)
# Expand the root node
widget.gmaFiles.expand(rootIndex)
# Select root node
widget.gmaFiles.selectionModel().select(rootIndex, QItemSelectionModel.Select)
# Enable the extract button
widget.gmaExtract.setEnabled(True)
widget.gmaOpen.setEnabled(True)
def gmaSelectEdited(widget, fileName):
openGmaFile(widget, fileName, False)
def gmaSelectEditingFinished(widget):
openGmaFile(widget, widget.gmaSelect.text(), True)
def gmaSelectFile(widget):
fileName, _ = QFileDialog.getOpenFileName(None,
"Open GMA file", widget.settings.value("selectGMALastFolder", None), "GMA files (*.gma)")
if not fileName: return
folder, _ = os.path.split(fileName)
# Store last used folder location
widget.settings.setValue("selectGMALastFolder", folder)
if not fileName: return
folder, _ = os.path.split(fileName)
# Store last used folder location
widget.settings.setValue("selectGMALastFolder", folder)
widget.gmaSelect.setText(fileName)
openGmaFile(widget, fileName)
def gmaExtract(widget):
selected = widget.gmaFiles.selectedIndexes()
selectedPaths = set()
for i in selected:
if not i.model().itemFromIndex(i).filePath: continue
selectedPaths.add(i.model().itemFromIndex(i).filePath)
| |
[]
r1430_1500_tomorrow = []
r1500_1530_tomorrow = []
r1530_1600_tomorrow = []
r1600_1630_tomorrow = []
r1630_1700_tomorrow = []
r1700_1730_tomorrow = []
r1730_1800_tomorrow = []
r1800_1830_tomorrow = []
r1830_1900_tomorrow = []
r1900_1930_tomorrow = []
r1930_2000_tomorrow = []
r2000_2030_tomorrow = []
r2030_2100_tomorrow = []
r2100_2130_tomorrow = []
r2130_2200_tomorrow = []
r2200_2230_tomorrow = []
r2230_2300_tomorrow = []
r2300_2330_tomorrow = []
r2330_0000_tomorrow = []
# print request.GET
barbershop_name = barbershop_name
username = user_name
# username = request.GET['user_name']
user = User.objects.get(username=username)
barbershops = Barbershop.objects.filter(user=user)
# barbershop_name = request.GET['barbershop_name']
# barbershops = Barbershop.objects.filter(user=user)
for barbershop in barbershops:
if barbershop.name == barbershop_name:
barbershop = Barbershop.objects.get(name=barbershop_name)
now = datetime.datetime.now()
today = now.date()
yesterday = today - datetime.timedelta(1)
tomorrow = today + datetime.timedelta(1)
start_date = barbershop.start_date
end_date = barbershop.end_date
print yesterday
print today
print tomorrow
reservations = Reservations.objects.filter(barbershop=barbershop, start_date=today)
reservations_yesterday = Reservations.objects.filter(barbershop=barbershop, start_date=yesterday)
reservations_tomorrow = Reservations.objects.filter(barbershop=barbershop, start_date=tomorrow)
for reservation in reservations:
if '00:00' <= reservation.start_time < '00:30':
r0000_0030.append(reservation)
if '00:00' < reservation.end_time <= '00:30' or reservation.start_time < '00:30' < reservation.end_time:
if r0000_0030.count(reservation) == 0:
r0000_0030.append(reservation)
if '00:30' <= reservation.start_time < '01:00':
r0030_0100.append(reservation)
if '00:30' < reservation.end_time <= '01:00' or reservation.start_time < '01:00' < reservation.end_time:
if r0030_0100.count(reservation) == 0:
r0030_0100.append(reservation)
if '01:00' <= reservation.start_time < '01:30':
r0100_0130.append(reservation)
if '01:00' < reservation.end_time <= '01:30' or reservation.start_time < '01:30' < reservation.end_time:
if r0100_0130.count(reservation) == 0:
r0100_0130.append(reservation)
if '01:30' <= reservation.start_time < '02:00':
r0130_0200.append(reservation)
if '01:30' < reservation.end_time <= '02:00' or reservation.start_time < '02:00' < reservation.end_time:
if r0130_0200.count(reservation) == 0:
r0130_0200.append(reservation)
if '02:00' <= reservation.start_time < '02:30':
r0200_0230.append(reservation)
if '02:00' < reservation.end_time <= '02:30' or reservation.start_time < '02:30' < reservation.end_time:
if r0200_0230.count(reservation) == 0:
r0200_0230.append(reservation)
if '02:30' <= reservation.start_time < '03:00':
r0230_0300.append(reservation)
if '02:30' < reservation.end_time <= '03:00' or reservation.start_time < '03:00' < reservation.end_time:
if r0230_0300.count(reservation) == 0:
r0230_0300.append(reservation)
if '03:00' <= reservation.start_time < '03:30':
r0300_0330.append(reservation)
if '03:00' < reservation.end_time <= '03:30' or reservation.start_time < '03:30' < reservation.end_time:
if r0300_0330.count(reservation) == 0:
r0300_0330.append(reservation)
if '03:30' <= reservation.start_time < '04:00':
r0330_0400.append(reservation)
if '03:30' < reservation.end_time <= '04:00' or reservation.start_time < '04:00' < reservation.end_time:
if r0330_0400.count(reservation) == 0:
r0330_0400.append(reservation)
if '04:00' <= reservation.start_time < '04:30':
r0400_0430.append(reservation)
if '04:00' < reservation.end_time <= '04:30' or reservation.start_time < '04:30' < reservation.end_time:
if r0400_0430.count(reservation) == 0:
r0400_0430.append(reservation)
if '04:30' <= reservation.start_time < '05:00':
r0430_0500.append(reservation)
if '04:30' < reservation.end_time <= '05:00' or reservation.start_time < '05:00' < reservation.end_time:
if r0430_0500.count(reservation) == 0:
r0430_0500.append(reservation)
if '05:00' <= reservation.start_time < '05:30':
r0500_0530.append(reservation)
if '05:00' < reservation.end_time <= '05:30' or reservation.start_time < '05:30' < reservation.end_time:
if r0500_0530.count(reservation) == 0:
r0500_0530.append(reservation)
if '05:30' <= reservation.start_time < '06:00':
r0530_0600.append(reservation)
if '05:30' < reservation.end_time <= '06:00' or reservation.start_time < '06:00' < reservation.end_time:
if r0530_0600.count(reservation) == 0:
r0530_0600.append(reservation)
if '06:00' <= reservation.start_time < '06:30':
r0600_0630.append(reservation)
if '06:00' < reservation.end_time <= '06:30' or reservation.start_time < '06:30' < reservation.end_time:
if r0600_0630.count(reservation) == 0:
r0600_0630.append(reservation)
if '06:30' <= reservation.start_time < '07:00':
r0630_0700.append(reservation)
if '06:30' < reservation.end_time <= '07:00' or reservation.start_time < '07:00' < reservation.end_time:
if r0630_0700.count(reservation) == 0:
r0630_0700.append(reservation)
if '07:00' <= reservation.start_time < '07:30':
r0700_0730.append(reservation)
if '07:00' < reservation.end_time <= '07:30' or reservation.start_time < '07:30' < reservation.end_time:
if r0700_0730.count(reservation) == 0:
r0700_0730.append(reservation)
if '07:30' <= reservation.start_time < '08:00':
r0730_0800.append(reservation)
if '07:30' < reservation.end_time <= '08:00' or reservation.start_time < '08:00' < reservation.end_time:
if r0730_0800.count(reservation) == 0:
r0730_0800.append(reservation)
if '08:00' <= reservation.start_time < '08:30':
r0800_0830.append(reservation)
if '08:00' < reservation.end_time <= '08:30' or reservation.start_time < '08:30' < reservation.end_time:
if r0800_0830.count(reservation) == 0:
r0800_0830.append(reservation)
if '08:30' <= reservation.start_time < '09:00':
r0830_0900.append(reservation)
if '08:30' < reservation.end_time <= '09:00' or reservation.start_time < '09:00' < reservation.end_time:
if r0830_0900.count(reservation) == 0:
r0830_0900.append(reservation)
if '09:00' <= reservation.start_time < '09:30':
r0900_0930.append(reservation)
if '09:00' < reservation.end_time <= '09:30' or reservation.start_time < '09:30' < reservation.end_time:
if r0900_0930.count(reservation) == 0:
r0900_0930.append(reservation)
if '09:30' <= reservation.start_time < '10:00':
r0930_1000.append(reservation)
if '09:30' < reservation.end_time <= '10:00' or reservation.start_time < '10:00' < reservation.end_time:
if r0930_1000.count(reservation) == 0:
r0930_1000.append(reservation)
if '10:00' <= reservation.start_time < '10:30':
r1000_1030.append(reservation)
if '10:00' < reservation.end_time <= '10:30' or reservation.start_time < '10:30' < reservation.end_time:
if r1000_1030.count(reservation) == 0:
r1000_1030.append(reservation)
if '10:30' <= reservation.start_time < '11:00':
r1030_1100.append(reservation)
if '10:30' < reservation.end_time <= '11:00' or reservation.start_time < '11:00' < reservation.end_time:
if r1030_1100.count(reservation) == 0:
r1030_1100.append(reservation)
if '11:00' <= reservation.start_time < '11:30':
r1100_1130.append(reservation)
if '11:00' < reservation.end_time <= '11:30' or reservation.start_time < '11:30' < reservation.end_time:
if r1100_1130.count(reservation) == 0:
r1100_1130.append(reservation)
if '11:30' <= reservation.start_time < '12:00':
r1130_1200.append(reservation)
if '11:30' < reservation.end_time <= '12:00' or reservation.start_time < '12:00' < reservation.end_time:
if r1130_1200.count(reservation) == 0:
r1130_1200.append(reservation)
if '12:00' <= reservation.start_time < '12:30':
r1200_1230.append(reservation)
if '12:00' < reservation.end_time <= '12:30' or reservation.start_time < '12:30' < reservation.end_time:
if r1200_1230.count(reservation) == 0:
r1200_1230.append(reservation)
if '12:30' <= reservation.start_time < '13:00':
r1230_1300.append(reservation)
if '12:30' < reservation.end_time <= '13:00' or reservation.start_time < '13:00' < reservation.end_time:
if r1230_1300.count(reservation) == 0:
r1230_1300.append(reservation)
if '13:00' <= reservation.start_time < '13:30':
r1300_1330.append(reservation)
if '13:00' < reservation.end_time <= '13:30' or reservation.start_time < '13:30' < reservation.end_time:
if r1300_1330.count(reservation) == 0:
r1300_1330.append(reservation)
if '13:30' <= reservation.start_time < '14:00':
r1330_1400.append(reservation)
if '13:30' < reservation.end_time <= '14:00' or reservation.start_time < '14:00' < reservation.end_time:
if r1330_1400.count(reservation) == 0:
r1330_1400.append(reservation)
if '14:00' <= reservation.start_time < '14:30':
r1400_1430.append(reservation)
if '14:00' < reservation.end_time <= '14:30' or reservation.start_time < '14:30' < reservation.end_time:
if r1400_1430.count(reservation) == 0:
r1400_1430.append(reservation)
if '14:30' <= reservation.start_time < '15:00':
r1430_1500.append(reservation)
if '14:30' < reservation.end_time <= '15:00' or reservation.start_time < '15:00' < reservation.end_time:
if r1430_1500.count(reservation) == 0:
r1430_1500.append(reservation)
if '15:00' <= reservation.start_time < '15:30':
r1500_1530.append(reservation)
if '15:00' < reservation.end_time <= '15:30' or reservation.start_time < '15:30' < reservation.end_time:
if r1500_1530.count(reservation) == 0:
r1500_1530.append(reservation)
if '15:30' <= reservation.start_time < '16:00':
r1530_1600.append(reservation)
if '15:30' < reservation.end_time <= '16:00' or reservation.start_time < '16:00' < reservation.end_time:
if r1530_1600.count(reservation) == 0:
r1530_1600.append(reservation)
if '16:00' <= reservation.start_time < '16:30':
r1600_1630.append(reservation)
if '16:00' < reservation.end_time <= '16:30' or reservation.start_time < '16:30' < reservation.end_time:
if r1600_1630.count(reservation) == 0:
r1600_1630.append(reservation)
if '16:30' <= reservation.start_time < '17:00':
r1630_1700.append(reservation)
if '16:30' < reservation.end_time <= '17:00' or reservation.start_time < '17:00' < reservation.end_time:
if r1630_1700.count(reservation) == 0:
r1630_1700.append(reservation)
if '17:00' <= reservation.start_time < '17:30':
r1700_1730.append(reservation)
if '17:00' < reservation.end_time <= '17:30' or reservation.start_time < '17:30' < reservation.end_time:
if r1700_1730.count(reservation) == 0:
r1700_1730.append(reservation)
if '17:30' <= reservation.start_time < '18:00':
r1730_1800.append(reservation)
if '17:30' < reservation.end_time <= '18:00' or reservation.start_time < '18:00' < reservation.end_time:
if r1730_1800.count(reservation) == 0:
r1730_1800.append(reservation)
if '18:00' <= reservation.start_time < '18:30':
r1800_1830.append(reservation)
if '18:00' < reservation.end_time <= '18:30' or reservation.start_time < '18:30' < reservation.end_time:
if r1800_1830.count(reservation) == 0:
r1800_1830.append(reservation)
if '18:30' <= reservation.start_time < '19:00':
r1830_1900.append(reservation)
if '18:30' < reservation.end_time <= '19:00' or reservation.start_time < '19:00' < reservation.end_time:
if r1830_1900.count(reservation) == 0:
r1830_1900.append(reservation)
if '19:00' <= reservation.start_time < '19:30':
r1900_1930.append(reservation)
if '19:00' < reservation.end_time <= '19:30' or reservation.start_time < '19:30' < reservation.end_time:
if r1900_1930.count(reservation) == 0:
r1900_1930.append(reservation)
if '19:30' <= reservation.start_time < '20:00':
r1930_2000.append(reservation)
if '19:30' < reservation.end_time <= '20:00' or reservation.start_time < '20:00' < reservation.end_time:
if r1930_2000.count(reservation) == 0:
r1930_2000.append(reservation)
if '20:00' <= reservation.start_time < '20:30':
r2000_2030.append(reservation)
if '20:00' < reservation.end_time <= '20:30' or reservation.start_time < '20:30' < reservation.end_time:
if r2000_2030.count(reservation) == 0:
r2000_2030.append(reservation)
if '20:30' <= reservation.start_time < '21:00':
r2030_2100.append(reservation)
if '20:30' < reservation.end_time <= '21:00' or reservation.start_time < '21:00' < reservation.end_time:
if r2030_2100.count(reservation) == 0:
r2030_2100.append(reservation)
if '21:00' <= reservation.start_time < '21:30':
r2100_2130.append(reservation)
if '21:00' < reservation.end_time <= '21:30' or reservation.start_time < '21:30' < reservation.end_time:
if r2100_2130.count(reservation) == 0:
r2100_2130.append(reservation)
if '21:30' <= reservation.start_time < '22:00':
r2130_2200.append(reservation)
if '21:30' < reservation.end_time <= '22:00' or reservation.start_time < '22:00' < reservation.end_time:
if r2130_2200.count(reservation) == 0:
r2130_2200.append(reservation)
if '22:00' <= reservation.start_time < '22:30':
r2200_2230.append(reservation)
if '22:00' < reservation.end_time <= '22:30' or reservation.start_time < '22:30' < reservation.end_time:
if r2200_2230.count(reservation) == 0:
r2200_2230.append(reservation)
if '22:30' <= reservation.start_time < '23:00':
r2230_2300.append(reservation)
if '22:30' < reservation.end_time <= '23:00' or reservation.start_time < '23:00' < reservation.end_time:
if r2230_2300.count(reservation) == 0:
r2230_2300.append(reservation)
if '23:00' <= reservation.start_time < '23:30':
r2300_2330.append(reservation)
if '23:00' < reservation.end_time <= '23:30' or reservation.start_time < '23:30' < reservation.end_time:
if r2300_2330.count(reservation) == 0:
r2300_2330.append(reservation)
if '23:30' <= reservation.start_time < '00:00':
r2330_0000.append(reservation)
if '23:30' < reservation.end_time <= | |
# Copyright 2010 New Relic, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import functools
import time
import logging
import warnings
try:
import urlparse
except ImportError:
import urllib.parse as urlparse
from newrelic.api.application import Application, application_instance
from newrelic.api.transaction import Transaction, current_transaction
from newrelic.common.async_proxy import async_proxy, TransactionContext
from newrelic.common.encoding_utils import (obfuscate, json_encode,
decode_newrelic_header, ensure_str)
from newrelic.core.attribute import create_attributes, process_user_attribute
from newrelic.core.attribute_filter import DST_BROWSER_MONITORING, DST_NONE
from newrelic.packages import six
from newrelic.common.object_names import callable_name
from newrelic.common.object_wrapper import FunctionWrapper, wrap_object
_logger = logging.getLogger(__name__)
_js_agent_header_fragment = '<script type="text/javascript">%s</script>'
_js_agent_footer_fragment = '<script type="text/javascript">'\
'window.NREUM||(NREUM={});NREUM.info=%s</script>'
# Seconds since epoch for Jan 1 2000
JAN_1_2000 = time.mktime((2000, 1, 1, 0, 0, 0, 0, 0, 0))
MICROSECOND_MIN = JAN_1_2000 * 1000000.0
MILLISECOND_MIN = JAN_1_2000 * 1000.0
def _parse_time_stamp(time_stamp):
"""
Converts time_stamp to seconds. Input can be microseconds,
milliseconds or seconds
Divide the timestamp by the highest resolution divisor. If
the result is older than Jan 1 2000, then pick a lower
resolution divisor and repeat. It is safe to assume no
requests were queued for more than 10 years.
"""
now = time.time()
if time_stamp > MICROSECOND_MIN:
divisor = 1000000.0
elif time_stamp > MILLISECOND_MIN:
divisor = 1000.0
elif time_stamp > JAN_1_2000:
divisor = 1.0
else:
return 0.0
converted_time = time_stamp / divisor
# If queue_start is in the future, return 0.0.
if converted_time > now:
return 0.0
return converted_time
TRUE_VALUES = {'on', 'true', '1'}
FALSE_VALUES = {'off', 'false', '0'}
def _lookup_environ_setting(environ, name, default=False):
if name not in environ:
return default
flag = environ[name]
if isinstance(flag, six.string_types):
flag = flag.lower()
if flag in TRUE_VALUES:
return True
elif flag in FALSE_VALUES:
return False
return flag
def _parse_synthetics_header(header):
# Return a dictionary of values from Synthetics header
# Returns empty dict, if version is not supported.
synthetics = {}
version = None
try:
if len(header) > 0:
version = int(header[0])
if version == 1:
synthetics['version'] = version
synthetics['account_id'] = int(header[1])
synthetics['resource_id'] = header[2]
synthetics['job_id'] = header[3]
synthetics['monitor_id'] = header[4]
except Exception:
return
return synthetics
def _remove_query_string(url):
url = ensure_str(url)
out = urlparse.urlsplit(url)
return urlparse.urlunsplit((out.scheme, out.netloc, out.path, '', ''))
def _is_websocket(environ):
return environ.get('HTTP_UPGRADE', '').lower() == 'websocket'
class WebTransaction(Transaction):
unicode_error_reported = False
QUEUE_TIME_HEADERS = ('x-request-start', 'x-queue-start')
def __init__(self, application, name, group=None,
scheme=None, host=None, port=None, request_method=None,
request_path=None, query_string=None, headers=None,
enabled=None):
super(WebTransaction, self).__init__(application, enabled)
# Flags for tracking whether RUM header and footer have been
# generated.
self.rum_header_generated = False
self.rum_footer_generated = False
if not self.enabled:
return
# Inputs
self._request_uri = request_path
self._request_method = request_method
self._request_scheme = scheme
self._request_host = host
self._request_params = {}
self._request_headers = {}
try:
self._port = int(port)
except Exception:
self._port = None
# Response
self._response_headers = {}
self._response_code = None
if headers is not None:
try:
headers = headers.items()
except Exception:
pass
for k, v in headers:
k = ensure_str(k)
if k is not None:
self._request_headers[k.lower()] = v
# Capture query request string parameters, unless we're in
# High Security Mode.
if query_string and not self._settings.high_security:
query_string = ensure_str(query_string)
try:
params = urlparse.parse_qs(
query_string,
keep_blank_values=True)
self._request_params.update(params)
except Exception:
pass
self._process_queue_time()
self._process_synthetics_header()
self._process_context_headers()
if name is not None:
self.set_transaction_name(name, group, priority=1)
elif request_path is not None:
self.set_transaction_name(request_path, 'Uri', priority=1)
def _process_queue_time(self):
for queue_time_header in self.QUEUE_TIME_HEADERS:
value = self._request_headers.get(queue_time_header)
if not value:
continue
value = ensure_str(value)
try:
if value.startswith('t='):
self.queue_start = _parse_time_stamp(float(value[2:]))
else:
self.queue_start = _parse_time_stamp(float(value))
except Exception:
pass
if self.queue_start > 0.0:
break
def _process_synthetics_header(self):
# Check for Synthetics header
settings = self._settings
if settings.synthetics.enabled and \
settings.trusted_account_ids and \
settings.encoding_key:
encoded_header = self._request_headers.get('x-newrelic-synthetics')
encoded_header = encoded_header and ensure_str(encoded_header)
if not encoded_header:
return
decoded_header = decode_newrelic_header(
encoded_header,
settings.encoding_key)
synthetics = _parse_synthetics_header(decoded_header)
if synthetics and \
synthetics['account_id'] in \
settings.trusted_account_ids:
# Save obfuscated header, because we will pass it along
# unchanged in all external requests.
self.synthetics_header = encoded_header
self.synthetics_resource_id = synthetics['resource_id']
self.synthetics_job_id = synthetics['job_id']
self.synthetics_monitor_id = synthetics['monitor_id']
def _process_context_headers(self):
# Process the New Relic cross process ID header and extract
# the relevant details.
if self._settings.distributed_tracing.enabled:
self.accept_distributed_trace_headers(self._request_headers)
else:
client_cross_process_id = \
self._request_headers.get('x-newrelic-id')
txn_header = self._request_headers.get('x-newrelic-transaction')
self._process_incoming_cat_headers(client_cross_process_id,
txn_header)
def process_response(self, status_code, response_headers):
"""Processes response status and headers, extracting any
details required and returning a set of additional headers
to merge into that being returned for the web transaction.
"""
if not self.enabled:
return []
# Extract response headers
if response_headers:
try:
response_headers = response_headers.items()
except Exception:
pass
for header, value in response_headers:
header = ensure_str(header)
if header is not None:
self._response_headers[header.lower()] = value
try:
self._response_code = int(status_code)
# If response code is 304 do not insert CAT headers. See:
# https://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5
if self._response_code == 304:
return []
except Exception:
pass
if self.client_cross_process_id is None:
return []
# Generate CAT response headers
try:
read_length = int(self._request_headers.get('content-length'))
except Exception:
read_length = -1
return self._generate_response_headers(read_length)
def _update_agent_attributes(self):
if 'accept' in self._request_headers:
self._add_agent_attribute('request.headers.accept',
self._request_headers['accept'])
try:
content_length = int(self._request_headers['content-length'])
self._add_agent_attribute('request.headers.contentLength',
content_length)
except:
pass
if 'content-type' in self._request_headers:
self._add_agent_attribute('request.headers.contentType',
self._request_headers['content-type'])
if 'host' in self._request_headers:
self._add_agent_attribute('request.headers.host',
self._request_headers['host'])
if 'referer' in self._request_headers:
self._add_agent_attribute('request.headers.referer',
_remove_query_string(self._request_headers['referer']))
if 'user-agent' in self._request_headers:
self._add_agent_attribute('request.headers.userAgent',
self._request_headers['user-agent'])
if self._request_method:
self._add_agent_attribute('request.method', self._request_method)
if self._request_uri:
self._add_agent_attribute('request.uri', self._request_uri)
try:
content_length = int(self._response_headers['content-length'])
self._add_agent_attribute('response.headers.contentLength',
content_length)
except:
pass
if 'content-type' in self._response_headers:
self._add_agent_attribute('response.headers.contentType',
self._response_headers['content-type'])
if self._response_code is not None:
self._add_agent_attribute('response.status',
str(self._response_code))
return super(WebTransaction, self)._update_agent_attributes()
def browser_timing_header(self):
"""Returns the JavaScript header to be included in any HTML
response to perform real user monitoring. This function returns
the header as a native Python string. In Python 2 native strings
are stored as bytes. In Python 3 native strings are stored as
unicode.
"""
if not self.enabled:
return ''
if self._state != self.STATE_RUNNING:
return ''
if self.background_task:
return ''
if self.ignore_transaction:
return ''
if not self._settings:
return ''
if not self._settings.browser_monitoring.enabled:
return ''
if not self._settings.license_key:
return ''
# Don't return the header a second time if it has already
# been generated.
if self.rum_header_generated:
return ''
# Requirement is that the first 13 characters of the account
# license key is used as the key when obfuscating values for
# the RUM footer. Will not be able to perform the obfuscation
# if license key isn't that long for some reason.
if len(self._settings.license_key) < 13:
return ''
# Return the RUM header only if the agent received a valid value
# for js_agent_loader from the data collector. The data
# collector is not meant to send a non empty value for the
# js_agent_loader value if browser_monitoring.loader is set to
# 'none'.
if self._settings.js_agent_loader:
header = _js_agent_header_fragment % self._settings.js_agent_loader
# To avoid any issues with browser encodings, we will make sure
# that the javascript we inject for the browser agent is ASCII
# encodable. Since we obfuscate all agent and user attributes, and
# the transaction name with base 64 encoding, this will preserve
# those strings, if they have values outside of the ASCII character
# set. In the case of Python 2, we actually then use the encoded
# value as we need a native string, which for Python 2 is a byte
# string. If encoding as ASCII fails we will return an empty
# string.
try:
if six.PY2:
header = header.encode('ascii')
else:
header.encode('ascii')
except UnicodeError:
if not WebTransaction.unicode_error_reported:
_logger.error('ASCII encoding of js-agent-header failed.',
header)
WebTransaction.unicode_error_reported = True
header = ''
else:
header = ''
# We remember if we have returned a non empty string value and
# if called a second time we will not return it again. The flag
# will also be used to check whether the footer should be
# generated.
if header:
self.rum_header_generated = True
return header
def browser_timing_footer(self):
"""Returns the JavaScript footer to be included in any HTML
response to perform real user monitoring. This function returns
the footer as a native Python string. In | |
For now, will
# resort to ssh into the host and start a new "rinetd" instance each
# time a new vmattach is issued.
try :
_proc_man = ProcessManagement(username = "root", \
hostname = obj_attr_list["host_cloud_ip"], \
cloud_name = obj_attr_list["cloud_name"])
if operation == "setup" :
_cmd = "echo \"0.0.0.0 " + obj_attr_list["prov_cloud_port"] + ' '
_cmd += obj_attr_list["cloud_ip"] + " 22\" > /tmp/"
_cmd += obj_attr_list["cloud_vm_name"] + ".rinetd.conf; rinetd -c "
_cmd += "/tmp/" + obj_attr_list["cloud_vm_name"] + ".rinetd.conf"
_rexcpt = True
else:
_cmd = "sudo pkill -9 -f 'rinetd -c /tmp/" + obj_attr_list["cloud_vm_name"]
_cmd += ".rinetd.conf" + "'; sudo rm -rf /tmp/"
_cmd += obj_attr_list["cloud_vm_name"] + ".rinetd.conf"
_rexcpt = False
_msg = operation.capitalize() + " port mapping (" + obj_attr_list["prov_cloud_port"]
_msg += " -> 22) for " + obj_attr_list["name"]
_msg += " (cloud-assigned uuid " + obj_attr_list["cloud_vm_uuid"] + ") "
_msg += "running on libvirt host \"" + obj_attr_list["host_name"] + "\""
cbdebug(_msg, True)
_status, _result_stdout, _fmsg = _proc_man.run_os_command(_cmd, raise_exception = _rexcpt)
_status = 0
except ProcessManagement.ProcessManagementException as obj:
_status = obj.status
_fmsg = str(obj.msg)
except Exception as e :
_status = 23
_fmsg = str(e)
finally :
if _status :
_msg = "Error while attempting to " + operation + " port mapping for " + obj_attr_list["name"]
_msg += " (cloud-assigned uuid " + obj_attr_list["cloud_vm_uuid"] + ") "
_msg += "running on LXD host \"" + obj_attr_list["host_name"] + "\""
_msg += " in " + self.get_description() + " \"" + obj_attr_list["cloud_name"] + "\" : "
_msg += _fmsg
cberr(_msg, True)
raise CldOpsException(_msg, _status)
else :
_msg = "Successfully " + operation + " port mapping for " + obj_attr_list["name"]
_msg += " (cloud-assigned uuid " + obj_attr_list["cloud_vm_uuid"] + ") "
_msg += "running on LXD host \"" + obj_attr_list["host_name"] + "\""
_msg += " in " + self.get_description() + " \"" + obj_attr_list["cloud_name"]
_msg += "\"."
cbdebug(_msg)
return _status, _msg
def generate_libvirt_vv_template(self, obj_attr_list, boot = False) :
'''
TBD
'''
_xml_file = ""
_xml_file += "\t<volume>\n"
if boot :
obj_attr_list["cloud_vv_data_name"] = obj_attr_list["cloud_vv_name"]
obj_attr_list["cloud_vv_name"] = obj_attr_list["cloud_vv_name"].replace("-vv","-vbv")
if int(obj_attr_list["boot_volume_snapshot_size"]) > int(self.vhw_config[obj_attr_list["size"]]["vstorage"]) :
_xml_file += "\t<capacity unit=\"M\">" + str(int(obj_attr_list["boot_volume_snapshot_size"])) + "</capacity>\n"
else :
_xml_file += "\t<capacity unit=\"M\">" + str(int(self.vhw_config[obj_attr_list["size"]]["vstorage"])) + "</capacity>\n"
else :
obj_attr_list["cloud_vv_name"] = obj_attr_list["cloud_vv_data_name"]
_xml_file += "\t<capacity unit=\"G\">" + obj_attr_list["cloud_vv"] + "</capacity>\n"
_vol_name = obj_attr_list["cloud_vv_name"]
_xml_file += "\t<name>" + obj_attr_list["cloud_vv_name"] + "</name>\n"
_xml_file += "\t<target>\n"
_xml_file += "\t\t<permissions>\n"
_xml_file += "\t\t\t<mode>0777</mode>\n"
_xml_file += "\t\t</permissions>\n"
_xml_file += "\t\t<path>" + obj_attr_list["pool_path"] + "</path>\n"
if boot :
_vol_format = "qcow2"
else :
_vol_format = "raw"
obj_attr_list["cloud_vv_type"] = _vol_format
_xml_file += "\t\t<format type='" + _vol_format + "'/>\n"
_xml_file += "\t</target>\n"
if boot :
_backing_path = obj_attr_list["boot_volume_snapshot_path"]
_backing_format = obj_attr_list["boot_volume_format"]
else :
_backing_path = "none"
_backing_format = "none"
if _backing_path != "none" :
_xml_file += "\t<backingStore>\n"
_xml_file += "\t\t<path>" + _backing_path + "</path>\n"
_xml_file += "\t\t<format type='" + _backing_format + "'/>\n"
_xml_file += "\t</backingStore>\n"
_xml_file += "\t</volume>\n"
_vol_path = obj_attr_list["pool_path"] + '/' + _vol_name
obj_attr_list["volume_list"] += _vol_name + ':' + _vol_path + ':' + _vol_format + ':' + _backing_path + ':' + _backing_format + ','
return _xml_file
@trace
def generate_mac_addr(self, obj_attr_list) :
'''
This function is designed to pseudo-determinstically generate MAC addresses.
The standard 6-byte MAC address is splitup as follows:
| prefix (X bytes long) | selector byte | suffix (Y bytes long) |
For example:
1. The user sets an X-byte long 'mac_prefix' == '12:34'. This is used to
represent all experiments in a shared cluster controlled by PLMloud.
For each shared cluster, this prefix should never need to change.
This prefix is also used in the DHCP server configuration to ensure
that requests from outside VMs are not answered to VMs that do not
belong to this cluster. If there is more than one private DHCP server
in the cluster, then, this mac_prefix should be changed, otherwise not.
2. The selector byte is generated automatically to provide additional
uniqueness and predictability in the MAC address to prevent
collisions among users of the same shared cluster. It is a hash of
the username of the benchmark combined with the hostname of the VM
running the benchmark.
3. The remaining Y-byte suffix is generated at provisioning time. This is done
by having the datastore maintain a counter that represents the last used
MAC address. An increasing counter ensures that collisions never happen
but only requires a small amount of memory even when the number of Y
bytes in the suffix is very large.
'''
# Form the 1st two parts of the MAC address
_mac_prefix = "52:54:00"
bytes_needed = (17 - len(_mac_prefix)) / 3 - 1
unique_mac_selector_key = obj_attr_list["cloud_vm_name"] + obj_attr_list["experiment_id"]
selector_hd = sha256(unique_mac_selector_key.encode('utf-8')).hexdigest()
selector_pos = randint(0,len(selector_hd)-2)
selector_byte = selector_hd[selector_pos:selector_pos+2]
mac = _mac_prefix + ":" + selector_byte
for x in range(0, int(bytes_needed)) :
byte = ((int(obj_attr_list["counter"]) >> (8 * ((int(bytes_needed) - 1) - x))) & 0xff)
mac += (":%02x" % (byte))
obj_attr_list["cloud_vm_mac"] = mac.replace('-', ':')
return True
def generate_libvirt_vm_template(self, obj_attr_list) :
'''
TBD
'''
if obj_attr_list["hypervisor"] == "xen" :
_xml_template = "<domain type='xen' "
else :
_xml_template = "<domain type='kvm' "
_xml_template += ">\n"
_xml_template += "\t<name>" + str(obj_attr_list["cloud_vm_name"]) + "</name>\n"
# _xml_template += "\t<uuid>" + str(instance_attr_list["cloud_uuid"]) + "</uuid>\n"
_xml_template += "\t<memory>" + str(int(self.vhw_config[obj_attr_list["size"]]["vmem"]) * 1024) + "</memory>\n"
_xml_template += "\t<currentMemory>" + str(int(self.vhw_config[obj_attr_list["size"]]["vmem"]) * 1024) + "</currentMemory>\n"
if obj_attr_list["arch"] == "ppc64" or obj_attr_list["arch"] == "ppc64le" :
_xml_template += "\t<vcpu placement='static'>" + str(int(self.vhw_config[obj_attr_list["size"]]["vcpus"])) + "</vcpu>\n"
_xml_template += "\t<resource>\n"
_xml_template += "\t\t<partition>/machine</partition>\n"
_xml_template += "\t</resource>\n"
else :
_xml_template += "\t<vcpu>" + str(int(self.vhw_config[obj_attr_list["size"]]["vcpus"])) + "</vcpu>\n"
_xml_template += "\t<os>\n"
if obj_attr_list["hypervisor"] == "xen" :
_xml_template += "\t\t<type arch='x86_64' machine='xenfv'>hvm</type>\n"
else :
if obj_attr_list["arch"] == "ppc64" or obj_attr_list["arch"] == "ppc64le" :
_xml_template += "\t\t<type arch='ppc64' machine='pseries'>hvm</type>\n"
else :
_xml_template += "\t\t<type arch='x86_64' machine='pc'>hvm</type>\n"
if obj_attr_list["hypervisor"] == "xen" :
_xml_template += "\t\t<loader>/usr/lib/xen/boot/hvmloader</loader>\n"
_xml_template += "\t\t<boot dev='hd'/>\n"
_xml_template += "\t</os>\n"
_xml_template += "\t<features>\n"
_xml_template += "\t\t<acpi/>\n"
_xml_template += "\t\t<apic/>\n"
# _xml_template += "\t\t<pae/>\n"
_xml_template += "\t</features>\n"
_xml_template += "\t<cpu mode='host-model'>\n"
_xml_template += "\t<model fallback='allow'/>\n"
_xml_template += "\t</cpu>\n"
_xml_template += "\t<clock offset='utc'>\n"
_xml_template += "\t\t<timer name='rtc' tickpolicy='catchup'/>\n"
_xml_template += "\t\t<timer name='pit' tickpolicy='delay'/>\n"
_xml_template += "\t\t<timer name='hpet' present='no'/>\n"
_xml_template += "\t</clock>\n"
_xml_template += "\t<devices>\n"
_xml_template += "\t\t<emulator>" + obj_attr_list["emulator"] + "</emulator>\n"
_disk_number = 0
for _volume in obj_attr_list["volume_list"].split(',') + [ "cloud-init" + ':' + obj_attr_list["host_remote_dir"] + obj_attr_list["cloud_vm_name"] + ".iso:" + "raw" + ':' + "none" + ':' + "none" ] :
if _volume.count(':') == 4 :
_vol_name, _vol_path, _vol_format, _backing_path, _backing_format = _volume.split(':')
_xml_template += "\t\t<disk type='file' device='disk'>\n"
_xml_template += "\t\t\t<driver name='qemu' type='" + _vol_format + "'/>\n"
_xml_template += "\t\t\t<source file='" + _vol_path + "'/>\n"
if _backing_path != "none" :
_xml_template += "\t\t\t<backingStore type='file'>\n"
_xml_template += "\t\t\t\t<source file='" + _backing_path + "'/>\n"
_xml_template += "\t\t\t\t<format type='" + _backing_format + "'/>\n"
_xml_template += "\t\t\t</backingStore>\n"
_xml_template += "\t\t\t<target dev='"
if obj_attr_list["diskmode"] == "virtio" :
_xml_template += "v"
elif obj_attr_list["diskmode"] == "ide" :
_xml_template += "h"
elif obj_attr_list["diskmode"] == "scsi" :
_xml_template += "s"
_xml_template += "d" + chr(ord('a') + _disk_number) + "' bus='" + obj_attr_list["diskmode"] + "'/>\n"
_xml_template += "\t\t</disk>\n"
_disk_number += 1
if obj_attr_list["arch"] == "ppc64" or obj_attr_list["arch"] == "ppc64le" :
_xml_template += "\t\t<controller type='usb' index='0'>\n"
_xml_template += "\t\t\t<alias name='usb0'/>\n"
_xml_template += "\t\t</controller>\n"
_xml_template += "\t\t<controller type='pci' index='0' model='pci-root'>\n"
_xml_template += "\t\t\t<alias name='pci.0'/>\n"
_xml_template += "\t\t</controller>\n"
_xml_template += "\t\t<controller type='scsi' index='0'>\n"
_xml_template += "\t\t\t<alias name='scsi0'/>\n"
_xml_template += "\t\t\t<address type='spapr-vio' reg='0x2000'/>\n"
_xml_template += "\t\t</controller>\n"
_xml_template += "\t\t<interface type='bridge'>\n"
_xml_template += "\t\t\t<source bridge='" + obj_attr_list["network_bridge_name"] + "'/>\n"
_xml_template += "\t\t\t<mac address='" + str(obj_attr_list["cloud_vm_mac"]) + "'/>\n"
if obj_attr_list["netmode"] == "virtio" :
_xml_template += "\t\t\t<model type='virtio'/>\n"
_xml_template += "\t\t</interface>\n"
for _vnic in obj_attr_list["extra_vnics"] :
_xml_template += "\t\t<interface type='bridge'>\n"
_xml_template += "\t\t\t<source bridge='" + _vnic[1] | |
"""Tests the dependency analyzer and `dump` backend."""
from unittest import TestCase
import os
import tempfile
from plumbum import local
from .common import run_vhdeps
DIR = os.path.realpath(os.path.dirname(__file__))
class TestDump(TestCase):
"""Tests the dependency analyzer and `dump` backend."""
def test_basic(self):
"""Test basic functionality of the dump backend"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/multiple-ok')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/multiple-ok/bar_tc.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/baz.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/foo_tc.vhd',
]) + '\n')
def test_to_file(self):
"""Test outputting a dependency dump to a file"""
with tempfile.TemporaryDirectory() as tempdir:
code, _, _ = run_vhdeps(
'dump',
'-i', DIR + '/simple/multiple-ok',
'-o', tempdir+'/output')
self.assertEqual(code, 0)
with open(tempdir+'/output', 'r') as fildes:
self.assertEqual(fildes.read(), '\n'.join([
'top work 2008 ' + DIR + '/simple/multiple-ok/bar_tc.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/baz.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/foo_tc.vhd',
]) + '\n')
def test_default_include(self):
"""Test implicit working directory inclusion"""
with local.cwd(DIR + '/simple/multiple-ok'):
code, out, err = run_vhdeps('dump')
self.assertEqual(code, 0)
self.assertTrue('Including the current working directory recursively by default' in err)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/multiple-ok/bar_tc.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/baz.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/foo_tc.vhd',
]) + '\n')
def test_default_include_by_file(self):
"""Test including files instead of directories"""
code, out, _ = run_vhdeps(
'dump',
'-i', DIR + '/simple/multiple-ok',
'-i', DIR + '/simple/all-good/test_tc.vhd')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/multiple-ok/bar_tc.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/baz.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/foo_tc.vhd',
'top work 2008 ' + DIR + '/simple/all-good/test_tc.vhd',
]) + '\n')
def test_default_include_by_glob(self):
"""Test including files using glob syntax"""
code, out, _ = run_vhdeps(
'dump',
'-i', DIR + '/simple/multiple-ok/ba*.vhd')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/multiple-ok/bar_tc.vhd',
'top work 2008 ' + DIR + '/simple/multiple-ok/baz.vhd',
]) + '\n')
def test_default_filters(self):
"""Test the default version/mode filters"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/filtering')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/new.08.vhd',
'top work 1993 ' + DIR + '/simple/filtering/old.93.vhd',
'top work 2008 ' + DIR + '/simple/filtering/simulation.sim.vhd',
]) + '\n')
def test_fixed_version_1993(self):
"""Test the required version filter"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/filtering', '-v93')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 1993 ' + DIR + '/simple/filtering/old.93.vhd',
'top work 1993 ' + DIR + '/simple/filtering/simulation.sim.vhd',
]) + '\n')
def test_desired_version(self):
"""Test the desired version filter"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/filtering', '-d93')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/new.08.vhd',
'top work 1993 ' + DIR + '/simple/filtering/old.93.vhd',
'top work 1993 ' + DIR + '/simple/filtering/simulation.sim.vhd',
]) + '\n')
def test_synthesis(self):
"""Test the synthesis filter"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/filtering', '-msyn')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/new.08.vhd',
'top work 1993 ' + DIR + '/simple/filtering/old.93.vhd',
'top work 2008 ' + DIR + '/simple/filtering/synthesis.syn.vhd',
]) + '\n')
def test_no_filtering(self):
"""Test all filters disabled"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/filtering', '-mall')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/new.08.vhd',
'top work 1993 ' + DIR + '/simple/filtering/old.93.vhd',
'top work 2008 ' + DIR + '/simple/filtering/simulation.sim.vhd',
'top work 2008 ' + DIR + '/simple/filtering/synthesis.syn.vhd',
]) + '\n')
def test_selected_entities(self):
"""Test toplevel entity selection"""
code, out, _ = run_vhdeps('dump', 'new', 'old', '-i', DIR + '/simple/filtering')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/new.08.vhd',
'top work 1993 ' + DIR + '/simple/filtering/old.93.vhd',
]) + '\n')
def test_selected_entity_glob(self):
"""Test toplevel entity selection with fnmatch globs"""
code, out, _ = run_vhdeps('dump', 's*', '-i', DIR + '/simple/filtering')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/simulation.sim.vhd',
]) + '\n')
def test_selected_entity_no_match(self):
"""Test toplevel entity selection with globs that don't match
anything"""
code, out, err = run_vhdeps('dump', 's*', 'x*', '-i', DIR + '/simple/filtering')
self.assertEqual(code, 0)
self.assertTrue('Warning: work.x* did not match anything.' in err)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/filtering/simulation.sim.vhd',
]) + '\n')
def test_conflict(self):
"""Test conflicting entities (defined in multiple files)"""
code, _, err = run_vhdeps(
'dump',
'-i', DIR + '/simple/all-good',
'-i', DIR + '/simple/timeout')
self.assertEqual(code, 1)
self.assertTrue('ResolutionError: entity work.test_tc is defined in '
'multiple, ambiguous files:' in err)
def test_ignore_pragmas(self):
"""Test ignore-use pragmas"""
code, _, _ = run_vhdeps('dump', '-i', DIR + '/complex/ignore-use')
self.assertEqual(code, 0)
def test_missing_package(self):
"""Test missing package detection/error"""
code, _, err = run_vhdeps('dump', '-i', DIR + '/complex/vhlib/util/UtilMem64_pkg.vhd')
self.assertEqual(code, 1)
self.assertTrue('complex/vhlib/util/UtilMem64_pkg.vhd' in err)
self.assertTrue('could not find package work.utilstr_pkg' in err)
def test_missing_component(self):
"""Test missing component detection/error"""
code, _, err = run_vhdeps('dump', '-i', DIR + '/complex/missing-component')
self.assertEqual(code, 1)
self.assertTrue('could not find component declaration for missing' in err)
def test_black_box_enforce(self):
"""Test black box detection/error"""
code, _, err = run_vhdeps(
'dump',
'-i', DIR + '/complex/vhlib/util',
'-i', DIR + '/complex/vhlib/stream/Stream_pkg.vhd',
'-i', DIR + '/complex/vhlib/stream/StreamBuffer.vhd')
self.assertEqual(code, 1)
self.assertTrue('complex/vhlib/stream/StreamBuffer.vhd' in err)
self.assertTrue('black box: could not find entity work.streamfifo' in err)
def test_black_box_ignore(self):
"""Test ignoring a black box through the -x flag"""
code, _, _ = run_vhdeps(
'dump',
'-i', DIR + '/complex/vhlib/util',
'-x', DIR + '/complex/vhlib/stream/Stream_pkg.vhd',
'-i', DIR + '/complex/vhlib/stream/StreamBuffer.vhd')
self.assertEqual(code, 0)
def test_missing_filtered(self):
"""Test detection of missing dependencies due to active filters"""
code, _, err = run_vhdeps('dump', '-i', DIR + '/complex/missing-filtered')
self.assertEqual(code, 1)
self.assertTrue('entity work.synth_only is defined, but only in files '
'that were filtered out:' in err)
self.assertTrue('synth_only.syn.vhd is synthesis-only' in err)
def test_libraries(self):
"""Test multiple libraries"""
code, out, _ = run_vhdeps(
'dump',
'-i', DIR + '/simple/all-good',
'-i', 'timeout:' + DIR + '/simple/timeout')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top timeout 2008 ' + DIR + '/simple/timeout/test_tc.vhd',
'top work 2008 ' + DIR + '/simple/all-good/test_tc.vhd',
]) + '\n')
def test_version_override(self):
"""Test version overrides in the include flag"""
code, out, _ = run_vhdeps(
'dump',
'-i', DIR + '/simple/all-good',
'-i', '93:timeout:' + DIR + '/simple/timeout')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top timeout 1993 ' + DIR + '/simple/timeout/test_tc.vhd',
'top work 2008 ' + DIR + '/simple/all-good/test_tc.vhd',
]) + '\n')
def test_ambiguous_08(self):
"""Test disambiguation by default desired version"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/ambiguous')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/ambiguous/test.08.sim.vhd',
]) + '\n')
def test_ambiguous_93(self):
"""Test disambiguation by specific desired version"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/ambiguous', '-d', '93')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 1993 ' + DIR + '/simple/ambiguous/test.93.sim.vhd',
]) + '\n')
def test_ambiguous_syn(self):
"""Test disambiguation by synthesis vs. simulation mode"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/simple/ambiguous', '-m', 'syn')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/simple/ambiguous/test.syn.vhd',
]) + '\n')
def test_component_circle(self):
"""Test recursive instantiation using components"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/complex/component-circle')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'dep work 2008 ' + DIR + '/complex/component-circle/a.vhd',
'dep work 2008 ' + DIR + '/complex/component-circle/b.vhd',
]) + '\n')
def test_component_in_inst(self):
"""Test component keyword in instantiation"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/complex/component-in-inst')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + DIR + '/complex/component-in-inst/a.vhd',
'dep work 2008 ' + DIR + '/complex/component-in-inst/b.vhd',
]) + '\n')
def test_entity_circle(self):
"""Test the error message for a true circular dependency"""
code, _, err = run_vhdeps('dump', '-i', DIR + '/complex/entity-circle')
self.assertEqual(code, 1)
self.assertTrue('ResolutionError: circular dependency:' in err)
def test_multi_unit_circle(self):
"""Test circular dependencies caused by multiple design units per
file"""
code, _, err = run_vhdeps('dump', '-i', DIR + '/complex/multi-unit-circle')
self.assertEqual(code, 1)
self.assertTrue('ResolutionError: circular dependency:' in err)
def test_multi_unit_design(self):
"""Test dependency analysis when multiple entities are defined per
file"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/complex/multi-unit-design')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'dep work 2008 ' + DIR + '/complex/multi-unit-design/ab.vhd',
'dep work 2008 ' + DIR + '/complex/multi-unit-design/cd.vhd',
'top work 2008 ' + DIR + '/complex/multi-unit-design/test_tc.vhd',
]) + '\n')
def test_multi_tc_per_file(self):
"""Test the dump backend with multiple test cases per file"""
code, out, _ = run_vhdeps('dump', '-i', DIR + '/complex/multi-tc-per-file')
self.assertEqual(code, 0)
self.assertEqual(out, '\n'.join([
'top work 2008 ' + | |
<reponame>Kami-DiscordBot/Predeactor-Cogs
import logging
from contextlib import suppress
from datetime import datetime
from typing import Optional, Union
import discord
from redbot.core import Config, commands
from redbot.core.bot import Red
from redbot.core.utils.chat_formatting import bold, error, humanize_list
from .abc import CompositeMetaClass
from .api import Challenge
from .commands import OwnerCommands, Settings
from .errors import (
AlreadyHaveCaptchaError,
AskedForReload,
DeletedValueError,
LeftServerError,
MissingRequiredValueError,
)
from .events import Listeners
from .informations import (
__author__,
__patchnote__,
__patchnote_version__,
__version__,
)
from .utils import build_kick_embed
DEFAULT_GLOBAL = {"log_level": 50}
DEFAULT_GUILD = {
"channel": None, # The channel where the captcha is sent.
"logschannel": None, # Where logs are sent.
"enabled": False, # If challenges must be activated.
"autoroles": [], # Roles to give.
"temprole": None, # Temporary role to give.
"type": "plain", # Captcha type.
"timeout": 5, # Time in minutes before kicking.
"retry": 3, # The numnber of retry allowed.
}
log = logging.getLogger("red.predeactor.captcha")
class Captcha(
Settings,
OwnerCommands,
Listeners,
commands.Cog,
name="Captcha",
metaclass=CompositeMetaClass,
):
"""A Captcha defensive system. to challenge the new users and protect yourself a bit more of
raids."""
def __init__(self, bot: Red) -> None:
super().__init__()
self.bot: Red = bot
self.data: Config = Config.get_conf(None, identifier=495954056, cog_name="Captcha")
self.data.register_global(**DEFAULT_GLOBAL)
self.data.register_guild(**DEFAULT_GUILD)
self.running = {}
self.version = __version__
self.patchnote = __patchnote__
self.patchnoteconfig = None
async def send_or_update_log_message(
self,
guild: discord.Guild,
message_content: str,
message_to_update: Optional[discord.Message] = None,
*,
allowed_tries: tuple = None,
member: discord.Member = None,
file: discord.File = None,
embed: discord.Embed = None,
ignore_error: bool = True,
) -> Optional[discord.Message]:
"""
Send a message or update one in the log channel.
"""
time = datetime.now().strftime("%H:%M - %w/%d/%Y")
content = ""
if message_to_update:
content += message_to_update.content + "\n"
content += (
f"{bold(str(time))}{f' {member.mention}' if member else ''}"
f"{f' ({allowed_tries[0]}/{allowed_tries[1]})' if allowed_tries else ''}: "
f"{message_content}"
)
log_channel_id: Union[int, None] = await self.data.guild(guild).logschannel()
if not log_channel_id:
if ignore_error:
return None
raise MissingRequiredValueError("Missing logging channel ID.")
log_channel: discord.TextChannel = self.bot.get_channel(log_channel_id)
if log_channel and message_to_update:
try:
await message_to_update.edit(
content=content,
file=file,
embed=embed,
allowed_mentions=discord.AllowedMentions(users=False),
)
except discord.HTTPException:
if message_to_update.embeds and (
message_to_update.embeds[0].title == "Message reached his maximum capacity!"
):
# To avoid edit spam or something... smh
return message_to_update
await message_to_update.edit(
content=message_to_update.content,
file=file,
embed=discord.Embed(
colour=discord.Colour.red().value,
title="Message reached his maximum capacity!",
description=(
"I am unable to log more since the characters limit on this "
"message has been reached."
),
),
allowed_mentions=discord.AllowedMentions(users=False),
)
return message_to_update
if log_channel:
return await log_channel.send(
content,
file=file,
embed=embed,
allowed_mentions=discord.AllowedMentions(users=False),
)
raise DeletedValueError("Logging channel may have been deleted.")
async def basic_check(self, member: discord.Member) -> bool:
"""
Check the basis from a member; used when a member join the server.
"""
if member.bot:
return False
if await self.bot.cog_disabled_in_guild(self, member.guild):
return False
return await self.data.guild(member.guild).enabled()
async def create_challenge_for(self, member: discord.Member) -> Challenge:
"""
Create a Challenge class for an user and append it to the running challenges.
"""
if member.id in self.running:
raise AlreadyHaveCaptchaError("The user already have a captcha object running.")
captcha = Challenge(self.bot, member, await self.data.guild(member.guild).all())
self.running[member.id] = captcha
return captcha
async def delete_challenge_for(self, member: discord.Member) -> bool:
try:
del self.running[member.id]
return True
except KeyError:
return False
def is_running_challenge(self, member_or_id: Union[discord.Member, int]) -> bool:
if isinstance(member_or_id, discord.Member):
member_or_id = int(member_or_id.id)
return member_or_id in self.running
def obtain_challenge(self, member_or_id: Union[discord.Member, int]) -> Challenge:
if isinstance(member_or_id, discord.Member):
member_or_id = int(member_or_id.id)
if not self.is_running_challenge(member_or_id):
raise KeyError("User is not challenging any Captcha.")
return self.running[member_or_id]
async def give_temprole(self, challenge: Challenge) -> None:
temprole = challenge.config["temprole"]
if temprole:
try:
await challenge.member.add_roles(
challenge.guild.get_role(temprole), reason="Beginning Captcha challenge."
)
except discord.Forbidden:
raise PermissionError('Bot miss the "manage_roles" permission.')
async def remove_temprole(self, challenge: Challenge) -> None:
temprole = challenge.config["temprole"]
if temprole:
try:
await challenge.member.remove_roles(
challenge.guild.get_role(temprole), reason="Finishing Captcha challenge."
)
except discord.Forbidden:
raise PermissionError('Bot miss the "manage_roles" permission.')
async def realize_challenge(self, challenge: Challenge) -> bool:
# Seems to be the last goddamn function I'll be writing...
limit = await self.data.guild(challenge.member.guild).retry()
is_ok = None
timeout = False
await self.give_temprole(challenge)
try:
while is_ok is not True:
if challenge.trynum > limit:
break
try:
this = await challenge.try_challenging()
except TimeoutError:
timeout = True
break
except AskedForReload:
challenge.trynum += 1
continue
except LeftServerError:
return False
except TypeError:
# In this error, the user reacted with an invalid (Most probably custom)
# emoji. While I expect administrator to remove this permissions, I still
# need to handle, so we're fine if we don't increase trynum.
continue
if this is False:
challenge.trynum += 1
try:
await challenge.messages["answer"].delete()
except discord.Forbidden:
await self.send_or_update_log_message(
challenge.guild,
error(bold("Unable to delete member's answer.")),
challenge.messages.get("logs"),
member=challenge.member,
)
is_ok = False
else:
is_ok = True
failed = challenge.trynum > limit
logmsg = challenge.messages["logs"]
if failed or timeout:
reason = (
"Retried the captcha too many time."
if failed
else "Didn't answer to the challenge."
)
try:
await self.nicely_kick_user_from_challenge(challenge, reason)
await self.send_or_update_log_message(
challenge.guild,
bold(f"User kicked for reason: {reason}"),
logmsg,
member=challenge.member,
)
except PermissionError:
await self.send_or_update_log_message(
challenge.guild,
error(bold("Permission missing for kicking member!")),
logmsg,
member=challenge.member,
)
return True
roles = [
challenge.guild.get_role(role)
for role in await self.data.guild(challenge.guild).autoroles()
]
try:
await self.congratulation(challenge, roles)
await self.remove_temprole(challenge)
await self.send_or_update_log_message(
challenge.guild,
bold("Roles added, Captcha passed."),
logmsg,
member=challenge.member,
)
except PermissionError:
roles_name = [role.name for role in roles]
try:
await challenge.member.send(
f"Please contact the administrator of {challenge.guild.name} for obtaining "
"access of the server, I was unable to add you the roles on the server.\nYou "
f"should have obtained the following roles: "
f"{humanize_list(roles_name) if roles_name else 'None.'}"
)
except discord.Forbidden:
await challenge.channel.send(
challenge.member.mention
+ ": "
+ f"Please contact the administrator of {challenge.guild.name} for obtaining "
"access of the server, I was unable to add you the roles on the server.\nYou "
f"should have obtained the following roles: "
f"{humanize_list(roles_name) if roles_name else 'None.'}",
delete_after=10,
)
await self.send_or_update_log_message(
challenge.guild,
error(bold("Permission missing for giving roles! Member alerted.")),
logmsg,
member=challenge.member,
)
finally:
try:
await challenge.cleanup_messages()
except PermissionError:
await self.send_or_update_log_message(
challenge.guild,
error(bold("Missing permissions for deleting all messages for verification!")),
challenge.messages.get("logs"),
member=challenge.member,
)
return True
async def congratulation(self, challenge: Challenge, roles: list) -> None:
"""
Congrats to a member! He finished the captcha!
"""
# Admin may have set channel to be DM, checking for manage_roles is useless since
# it always return False, instead, we're taking a random text channel of the guild
# to check our permission for kicking.
channel = (
challenge.channel
if not isinstance(challenge.channel, discord.DMChannel)
else challenge.guild.text_channels[0]
)
if not channel.permissions_for(self.bot.get_guild(challenge.guild.id).me).manage_roles:
raise PermissionError('Bot miss the "manage_roles" permission.')
await challenge.member.add_roles(*roles, reason="Passed Captcha successfully.")
async def nicely_kick_user_from_challenge(self, challenge: Challenge, reason: str) -> bool:
# We're gonna check our permission first, to avoid DMing the user for nothing.
# Admin may have set channel to be DM, checking for kick_members is useless since
# it always return False, instead, we're taking a random text channel of the guild
# to check our permission for kicking.
channel = (
challenge.channel
if not isinstance(challenge.channel, discord.DMChannel)
else challenge.guild.text_channels[0]
)
if not channel.permissions_for(self.bot.get_guild(challenge.guild.id).me).kick_members:
raise PermissionError('Bot miss the "kick_members" permission.')
with suppress(discord.Forbidden, discord.HTTPException):
await challenge.member.send(embed=build_kick_embed(challenge.guild, reason))
try:
await challenge.guild.kick(challenge.member, reason=reason)
except discord.Forbidden:
raise PermissionError("Unable to kick member.")
return True
# PLEASE DON'T TOUCH THOSE FUNCTIONS WITH YOUR COG OR EVAL. Thanks. - Pred
# Those should only be used by the cog - 4 bags of None of your business.
def format_help_for_context(self, ctx: commands.Context) -> str:
"""
This will put some text at the top of the main help. ([p]help Captcha)
Thank to Sinbad.
"""
pre_processed = super().format_help_for_context(ctx)
return "{pre_processed}\n\nAuthor: {authors}\nVersion: {version}".format(
pre_processed=pre_processed,
authors=humanize_list(__author__),
version=self.version,
)
async def _initialize(self, send_patchnote: bool = True) -> None:
"""
An initializer for the cog.
It just set the logging level and send the patchnote if asked.
"""
log_level = await self.data.log_level()
log.setLevel(log_level)
log.info("Captcha logging level has been set to: {lev}".format(lev=log_level))
log.debug(
"This logging level is reserved for testing and monitoring purpose, set the "
"level to 2 if you prefer to be alerted by less minor events or doesn't want to help "
"debugging this cog."
)
if send_patchnote:
await self._send_patchnote()
async def _send_patchnote(self) -> None:
await self.bot.wait_until_red_ready()
self.patchnoteconfig = notice = Config.get_conf(
None,
identifier=4145125452,
cog_name="PredeactorNews",
)
notice.register_user(version="0")
async with notice.get_users_lock():
old_patchnote_version: str = await notice.user(self.bot.user).version()
if old_patchnote_version != __patchnote_version__:
log.info("New version of patchnote detected! Delivering... (¬‿¬ | |
underworld_graph = {
992: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(75,61)",
"elevation": 0,
"w": 966
},
966: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(74,61)",
"elevation": 0,
"e": 992,
"w": 960
},
960: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(73,61)",
"elevation": 0,
"e": 966,
"w": 956
},
956: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(72,61)",
"elevation": 0,
"e": 960,
"w": 902
},
902: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(71,61)",
"elevation": 0,
"e": 956,
"w": 874
},
874: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,61)",
"elevation": 0,
"e": 902,
"w": 762
},
762: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,61)",
"elevation": 0,
"e": 874,
"w": 728
},
728: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,61)",
"elevation": 0,
"n": 741,
"e": 762,
"w": 724
},
741: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,62)",
"elevation": 0,
"s": 728,
"e": 793
},
793: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,62)",
"elevation": 0,
"n": 808,
"e": 901,
"w": 741
},
808: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,63)",
"elevation": 0,
"n": 821,
"s": 793,
"e": 920
},
821: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,64)",
"elevation": 0,
"n": 974,
"s": 808,
"e": 953
},
974: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,65)",
"elevation": 0,
"s": 821
},
953: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,64)",
"elevation": 0,
"w": 821
},
920: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,63)",
"elevation": 0,
"e": 946,
"w": 808
},
946: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(71,63)",
"elevation": 0,
"w": 920
},
901: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,62)",
"elevation": 0,
"w": 793
},
724: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,61)",
"elevation": 0,
"n": 737,
"s": 748,
"e": 728,
"w": 711
},
737: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,62)",
"elevation": 0,
"n": 756,
"s": 724
},
756: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,63)",
"elevation": 0,
"s": 737,
"e": 868
},
868: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,63)",
"elevation": 0,
"n": 885,
"w": 756
},
885: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,64)",
"elevation": 0,
"s": 868
},
748: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,60)",
"elevation": 0,
"n": 724,
"s": 772,
"e": 764
},
772: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,59)",
"elevation": 0,
"n": 748,
"s": 780
},
780: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,58)",
"elevation": 0,
"n": 772,
"s": 818
},
818: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,57)",
"elevation": 0,
"n": 780,
"s": 877,
"e": 829
},
877: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,56)",
"elevation": 0,
"n": 818,
"s": 997,
"e": 937
},
997: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(67,55)",
"elevation": 0,
"n": 877
},
937: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,56)",
"elevation": 0,
"w": 877
},
829: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,57)",
"elevation": 0,
"e": 912,
"w": 818
},
912: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,57)",
"elevation": 0,
"w": 829
},
764: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,60)",
"elevation": 0,
"s": 769,
"e": 848,
"w": 748
},
769: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,59)",
"elevation": 0,
"n": 764,
"s": 799,
"e": 847
},
799: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(68,58)",
"elevation": 0,
"n": 769,
"e": 908
},
908: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,58)",
"elevation": 0,
"w": 799
},
847: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,59)",
"elevation": 0,
"w": 769
},
848: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(69,60)",
"elevation": 0,
"e": 853,
"w": 764
},
853: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,60)",
"elevation": 0,
"s": 958,
"e": 939,
"w": 848
},
958: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,59)",
"elevation": 0,
"n": 853,
"s": 972
},
972: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(70,58)",
"elevation": 0,
"n": 958
},
939: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(71,60)",
"elevation": 0,
"w": 853
},
711: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(66,61)",
"elevation": 0,
"n": 721,
"e": 724,
"w": 633
},
721: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(66,62)",
"elevation": 0,
"s": 711
},
633: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(65,61)",
"elevation": 0,
"e": 711,
"w": 623
},
623: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(64,61)",
"elevation": 0,
"n": 609,
"e": 633
},
609: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(64,62)",
"elevation": 0,
"n": 603,
"s": 623,
"e": 652
},
603: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(64,63)",
"elevation": 0,
"n": 618,
"s": 609,
"w": 520
},
618: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(64,64)",
"elevation": 0,
"s": 603,
"e": 631
},
631: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(65,64)",
"elevation": 0,
"s": 646,
"w": 618
},
646: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(65,63)",
"elevation": 0,
"n": 631,
"e": 662
},
662: {
"title": "Darkness",
"description": "You are standing on grass and surrounded by darkness.",
"terrain": "NORMAL",
"coordinates": "(66,63)",
"elevation": 0,
"n": 675,
"w": 646
},
| |
<filename>libs/html5lib/filters/optionaltags.py
import _base
class Filter(_base.Filter):
def slider(self):
previous1 = previous2 = None
for token in self.source:
if previous1 is not None:
yield previous2, previous1, token
previous2 = previous1
previous1 = token
yield previous2, previous1, None
def __iter__(self):
for previous, token, next in self.slider():
type = token["type"]
if type == "StartTag":
if (token["data"] or
not self.is_optional_start(token["name"], previous, next)):
yield token
elif type == "EndTag":
if not self.is_optional_end(token["name"], next):
yield token
else:
yield token
def is_optional_start(self, tagname, previous, next):
type = next and next["type"] or None
if tagname in 'html':
# An html element's start tag may be omitted if the first thing
# inside the html element is not a space character or a comment.
return type not in ("Comment", "SpaceCharacters")
elif tagname == 'head':
# A head element's start tag may be omitted if the first thing
# inside the head element is an element.
# XXX: we also omit the start tag if the head element is empty
if type in ("StartTag", "EmptyTag"):
return True
elif type == "EndTag":
return next["name"] == "head"
elif tagname == 'body':
# A body element's start tag may be omitted if the first thing
# inside the body element is not a space character or a comment,
# except if the first thing inside the body element is a script
# or style element and the node immediately preceding the body
# element is a head element whose end tag has been omitted.
if type in ("Comment", "SpaceCharacters"):
return False
elif type == "StartTag":
# XXX: we do not look at the preceding event, so we never omit
# the body element's start tag if it's followed by a script or
# a style element.
return next["name"] not in ('script', 'style')
else:
return True
elif tagname == 'colgroup':
# A colgroup element's start tag may be omitted if the first thing
# inside the colgroup element is a col element, and if the element
# is not immediately preceeded by another colgroup element whose
# end tag has been omitted.
if type in ("StartTag", "EmptyTag"):
# XXX: we do not look at the preceding event, so instead we never
# omit the colgroup element's end tag when it is immediately
# followed by another colgroup element. See is_optional_end.
return next["name"] == "col"
else:
return False
elif tagname == 'tbody':
# A tbody element's start tag may be omitted if the first thing
# inside the tbody element is a tr element, and if the element is
# not immediately preceeded by a tbody, thead, or tfoot element
# whose end tag has been omitted.
if type == "StartTag":
# omit the thead and tfoot elements' end tag when they are
# immediately followed by a tbody element. See is_optional_end.
if previous and previous['type'] == 'EndTag' and \
previous['name'] in ('tbody','thead','tfoot'):
return False
return next["name"] == 'tr'
else:
return False
return False
def is_optional_end(self, tagname, next):
type = next and next["type"] or None
if tagname in ('html', 'head', 'body'):
# An html element's end tag may be omitted if the html element
# is not immediately followed by a space character or a comment.
return type not in ("Comment", "SpaceCharacters")
elif tagname in ('li', 'optgroup', 'tr'):
# A li element's end tag may be omitted if the li element is
# immediately followed by another li element or if there is
# no more content in the parent element.
# An optgroup element's end tag may be omitted if the optgroup
# element is immediately followed by another optgroup element,
# or if there is no more content in the parent element.
# A tr element's end tag may be omitted if the tr element is
# immediately followed by another tr element, or if there is
# no more content in the parent element.
if type == "StartTag":
return next["name"] == tagname
else:
return type == "EndTag" or type is None
elif tagname in ('dt', 'dd'):
# A dt element's end tag may be omitted if the dt element is
# immediately followed by another dt element or a dd element.
# A dd element's end tag may be omitted if the dd element is
# immediately followed by another dd element or a dt element,
# or if there is no more content in the parent element.
if type == "StartTag":
return next["name"] in ('dt', 'dd')
elif tagname == 'dd':
return type == "EndTag" or type is None
else:
return False
elif tagname == 'p':
# A p element's end tag may be omitted if the p element is
# immediately followed by an address, article, aside,
# blockquote, datagrid, dialog, dir, div, dl, fieldset,
# footer, form, h1, h2, h3, h4, h5, h6, header, hr, menu,
# nav, ol, p, pre, section, table, or ul, element, or if
# there is no more content in the parent element.
if type in ("StartTag", "EmptyTag"):
return next["name"] in ('address', 'article', 'aside',
'blockquote', 'datagrid', 'dialog',
'dir', 'div', 'dl', 'fieldset', 'footer',
'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
'header', 'hr', 'menu', 'nav', 'ol',
'p', 'pre', 'section', 'table', 'ul')
else:
return type == "EndTag" or type is None
elif tagname == 'option':
# An option element's end tag may be omitted if the option
# element is immediately followed by another option element,
# or if it is immediately followed by an <code>optgroup</code>
# element, or if there is no more content in the parent
# element.
if type == "StartTag":
return next["name"] in ('option', 'optgroup')
else:
return type == "EndTag" or type is None
elif tagname in ('rt', 'rp'):
# An rt element's end tag may be omitted if the rt element is
# immediately followed by an rt or rp element, or if there is
# no more content in the parent element.
# An rp element's end tag may be omitted if the rp element is
# immediately followed by an rt or rp element, or if there is
# no more content in the parent element.
if type == "StartTag":
return next["name"] in ('rt', 'rp')
else:
return type == "EndTag" or type is None
elif tagname == 'colgroup':
# A colgroup element's end tag may be omitted if the colgroup
# element is not immediately followed by a space character or
# a comment.
if type in ("Comment", "SpaceCharacters"):
return False
elif type == "StartTag":
# XXX: we also look for an immediately following colgroup
# element. See is_optional_start.
return next["name"] != 'colgroup'
else:
return True
elif tagname in ('thead', 'tbody'):
# A thead element's end tag may be omitted if the thead element
# is immediately followed by a tbody or tfoot element.
# A tbody element's end tag may be omitted if the tbody element
# is immediately followed by a tbody or tfoot element, or if
# there is no more content in the parent element.
# A tfoot element's end tag may be omitted if the tfoot element
# is immediately followed by a tbody element, or if there is no
# more content in the parent element.
# XXX: we never omit the end tag when the following element is
# a tbody. See is_optional_start.
if type == "StartTag":
return next["name"] in ['tbody', 'tfoot']
elif tagname == 'tbody':
return type == "EndTag" or type is None
else:
return False
elif tagname == 'tfoot':
# A tfoot element's end tag may be omitted if the tfoot element
# is immediately followed by a tbody element, or if there is no
# more content in the parent element.
# XXX: we never omit the end tag when the following element is
# a tbody. See is_optional_start.
if type == "StartTag":
return next["name"] == 'tbody'
else:
return type == | |
<reponame>ozdanborne/felix
# -*- coding: utf-8 -*-
# Copyright (c) 2015-2016 Tigera, Inc. All rights reserved.
# Copyright 2015 Cisco Systems
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
felix.test.test_frules
~~~~~~~~~~~~~~~~~~~~~~~~~
Tests of iptables rules generation function.
"""
import logging
from mock import Mock, patch, call
from netaddr import IPAddress
from calico.felix import frules
from calico.felix.fiptables import IptablesUpdater
from calico.felix.futils import FailedSystemCall, IPV4
from calico.felix.test.base import BaseTestCase, load_config
_log = logging.getLogger(__name__)
EXPECTED_TOP_LEVEL_DEPS = {
'felix-INPUT': set(['felix-FROM-ENDPOINT', 'felix-FROM-HOST-IF']),
'felix-OUTPUT': set(['felix-TO-HOST-IF']),
'felix-FORWARD': set(['felix-FROM-ENDPOINT', 'felix-TO-ENDPOINT']),
'felix-FAILSAFE-IN': set(), 'felix-FAILSAFE-OUT': set()
}
class TestRules(BaseTestCase):
@patch("calico.felix.futils.check_call", autospec=True)
@patch("calico.felix.frules.devices", autospec=True)
@patch("calico.felix.frules.HOSTS_IPSET_V4", autospec=True)
def test_install_global_rules(self, m_ipset, m_devices, m_check_call):
m_devices.interface_exists.return_value = False
m_devices.interface_up.return_value = False
m_set_ips = m_devices.set_interface_ips
env_dict = {
"FELIX_ETCDADDR": "localhost:4001",
"FELIX_HOSTNAME": "myhost",
"FELIX_INTERFACEPREFIX": "tap",
"FELIX_METADATAADDR": "192.168.127.12",
"FELIX_METADATAPORT": "1234",
"FELIX_IPINIPENABLED": "True",
"FELIX_IPINIPMTU": "1480",
"FELIX_DEFAULTENDPOINTTOHOSTACTION": "RETURN"
}
config = load_config("felix_missing.cfg", env_dict=env_dict)
config.IP_IN_IP_ADDR = IPAddress("10.0.0.1")
m_v4_upd = Mock(spec=IptablesUpdater)
m_v6_upd = Mock(spec=IptablesUpdater)
m_v6_raw_upd = Mock(spec=IptablesUpdater)
m_v4_nat_upd = Mock(spec=IptablesUpdater)
m_v6_nat_upd = Mock(spec=IptablesUpdater)
frules.install_global_rules(config, m_v4_upd, m_v4_nat_upd,
ip_version=4)
frules.install_global_rules(config, m_v6_upd, m_v6_nat_upd,
ip_version=6, raw_updater=m_v6_raw_upd)
self.assertEqual(
m_v4_nat_upd.ensure_rule_inserted.mock_calls,
[
call("POSTROUTING --out-interface tunl0 "
"-m addrtype ! --src-type LOCAL --limit-iface-out "
"-m addrtype --src-type LOCAL "
"-j MASQUERADE",
async=False),
call("PREROUTING --jump felix-PREROUTING", async=False),
call("POSTROUTING --jump felix-POSTROUTING", async=False)
]
)
m_v4_upd.ensure_rule_inserted.assert_has_calls([
call("INPUT --jump felix-INPUT", async=False),
call("OUTPUT --jump felix-OUTPUT", async=False),
call("FORWARD --jump felix-FORWARD", async=False)
]
)
expected_chains = {
'felix-FIP-DNAT': [],
'felix-FIP-SNAT': [],
'felix-PREROUTING': [
'--append felix-PREROUTING --jump felix-FIP-DNAT',
'--append felix-PREROUTING --protocol tcp --dport 80 --destination '
'169.254.169.254/32 --jump DNAT --to-destination 192.168.127.12:1234'
],
'felix-POSTROUTING': [
'--append felix-POSTROUTING --jump felix-FIP-SNAT'
]
}
m_v4_nat_upd.rewrite_chains.assert_called_once_with(
expected_chains,
{'felix-PREROUTING': set(['felix-FIP-DNAT']),
'felix-POSTROUTING': set(['felix-FIP-SNAT'])},
async=False
)
expected_chains = {
'felix-INPUT': [
'--append felix-INPUT --match conntrack --ctstate INVALID --jump DROP',
'--append felix-INPUT --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-INPUT --jump MARK --set-mark 0/0x4000000',
'--append felix-INPUT --in-interface tap+ --jump MARK --set-mark 0x4000000/0x4000000',
'--append felix-INPUT --goto felix-FROM-HOST-IF --match mark --mark 0/0x4000000',
'--append felix-INPUT --protocol tcp --destination 192.168.127.12 --dport 1234 --jump ACCEPT',
'--append felix-INPUT --protocol udp --sport 68 --dport 67 --jump ACCEPT',
'--append felix-INPUT --protocol udp --dport 53 --jump ACCEPT',
'--append felix-INPUT --jump felix-FROM-ENDPOINT'
],
'felix-OUTPUT': [
'--append felix-OUTPUT --match conntrack --ctstate INVALID --jump DROP',
'--append felix-OUTPUT --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-OUTPUT --jump MARK --set-mark 0/0x4000000',
'--append felix-OUTPUT --out-interface tap+ --jump MARK --set-mark 0x4000000/0x4000000',
'--append felix-OUTPUT --goto felix-TO-HOST-IF --match mark --mark 0/0x4000000',
],
'felix-FORWARD': [
'--append felix-FORWARD --in-interface tap+ --match conntrack --ctstate INVALID --jump DROP',
'--append felix-FORWARD --out-interface tap+ --match conntrack --ctstate INVALID --jump DROP',
'--append felix-FORWARD --in-interface tap+ --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-FORWARD --out-interface tap+ --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-FORWARD --jump felix-FROM-ENDPOINT --in-interface tap+',
'--append felix-FORWARD --jump felix-TO-ENDPOINT --out-interface tap+',
'--append felix-FORWARD --jump ACCEPT --in-interface tap+',
'--append felix-FORWARD --jump ACCEPT --out-interface tap+'
],
'felix-FAILSAFE-IN': [
'--append felix-FAILSAFE-IN --protocol tcp --dport 22 --jump ACCEPT'
],
'felix-FAILSAFE-OUT': [
'--append felix-FAILSAFE-OUT --protocol tcp --dport 2379 --jump ACCEPT',
'--append felix-FAILSAFE-OUT --protocol tcp --dport 2380 --jump ACCEPT',
'--append felix-FAILSAFE-OUT --protocol tcp --dport 4001 --jump ACCEPT',
'--append felix-FAILSAFE-OUT --protocol tcp --dport 7001 --jump ACCEPT'
]
}
m_v4_upd.rewrite_chains.assert_called_once_with(
expected_chains,
EXPECTED_TOP_LEVEL_DEPS,
async=False
)
self.assertEqual(
m_v6_nat_upd.ensure_rule_inserted.mock_calls,
[
call("PREROUTING --jump felix-PREROUTING", async=False),
call("POSTROUTING --jump felix-POSTROUTING", async=False),
]
)
m_v6_upd.ensure_rule_inserted.assert_has_calls([
call("INPUT --jump felix-INPUT", async=False),
call("OUTPUT --jump felix-OUTPUT", async=False),
call("FORWARD --jump felix-FORWARD", async=False)
]
)
expected_chains = {
'felix-FIP-DNAT': [],
'felix-FIP-SNAT': [],
'felix-PREROUTING': [
'--append felix-PREROUTING --jump felix-FIP-DNAT'
],
'felix-POSTROUTING': [
'--append felix-POSTROUTING --jump felix-FIP-SNAT'
]
}
m_v6_nat_upd.rewrite_chains.assert_called_once_with(
expected_chains, {
'felix-PREROUTING': set(['felix-FIP-DNAT']),
'felix-POSTROUTING': set(['felix-FIP-SNAT'])
}, async=False
)
m_v6_raw_upd.rewrite_chains.assert_called_once_with(
{'felix-PREROUTING': [
'--append felix-PREROUTING --jump DROP -m comment '
'--comment "IPv6 rpfilter failed"'
]},
{
'felix-PREROUTING': {}
},
async=False
)
m_ipset.ensure_exists.assert_called_once_with()
self.assertEqual(
m_check_call.mock_calls,
[
call(["ip", "tunnel", "add", "tunl0", "mode", "ipip"]),
call(["ip", "link", "set", "tunl0", "mtu", "1480"]),
call(["ip", "link", "set", "tunl0", "up"]),
]
)
self.assertEqual(
m_set_ips.mock_calls,
[call(IPV4, "tunl0", set([IPAddress("10.0.0.1")]))]
)
@patch("calico.felix.futils.check_call", autospec=True)
@patch("calico.felix.frules.devices", autospec=True)
@patch("calico.felix.frules.HOSTS_IPSET_V4", autospec=True)
def test_install_global_ipip_disabled(self, m_ipset, m_devices, m_check_call):
m_devices.interface_exists.return_value = False
m_devices.interface_up.return_value = False
m_set_ips = m_devices.set_interface_ips
env_dict = {
"FELIX_ETCDADDR": "localhost:4001",
"FELIX_HOSTNAME": "myhost",
"FELIX_INTERFACEPREFIX": "tap",
"FELIX_METADATAADDR": "192.168.127.12",
"FELIX_METADATAPORT": "1234",
"FELIX_IPINIPENABLED": "false",
"FELIX_IPINIPMTU": "1480",
"FELIX_DEFAULTENDPOINTTOHOSTACTION": "RETURN"
}
config = load_config("felix_missing.cfg", env_dict=env_dict)
m_v4_upd = Mock(spec=IptablesUpdater)
m_v6_upd = Mock(spec=IptablesUpdater)
m_v6_raw_upd = Mock(spec=IptablesUpdater)
m_v6_nat_upd = Mock(spec=IptablesUpdater)
m_v4_nat_upd = Mock(spec=IptablesUpdater)
frules.install_global_rules(config, m_v4_upd, m_v4_nat_upd,
ip_version=4)
frules.install_global_rules(config, m_v6_upd, m_v6_nat_upd,
ip_version=6, raw_updater=m_v6_raw_upd)
self.assertEqual(
m_v4_nat_upd.ensure_rule_inserted.mock_calls,
[call("PREROUTING --jump felix-PREROUTING", async=False),
call("POSTROUTING --jump felix-POSTROUTING", async=False)]
)
m_v4_upd.ensure_rule_inserted.assert_has_calls([
call("INPUT --jump felix-INPUT", async=False),
call("OUTPUT --jump felix-OUTPUT", async=False),
call("FORWARD --jump felix-FORWARD", async=False)
]
)
self.assertEqual(
m_v4_nat_upd.ensure_rule_removed.mock_calls,
[call("POSTROUTING --out-interface tunl0 "
"-m addrtype ! --src-type LOCAL --limit-iface-out "
"-m addrtype --src-type LOCAL "
"-j MASQUERADE",
async=False)]
)
m_v6_raw_upd.ensure_rule_inserted.assert_called_once_with(
'PREROUTING --in-interface tap+ --match rpfilter --invert --jump '
'felix-PREROUTING',
async=False,
)
m_v6_raw_upd.rewrite_chains.assert_called_once_with(
{'felix-PREROUTING': [
'--append felix-PREROUTING --jump DROP -m comment '
'--comment "IPv6 rpfilter failed"'
]},
{
'felix-PREROUTING': {}
},
async=False
)
self.assertFalse(m_ipset.ensure_exists.called)
self.assertFalse(m_check_call.called)
self.assertFalse(m_set_ips.called)
expected_chains = {
'felix-FIP-DNAT': [],
'felix-FIP-SNAT': [],
'felix-PREROUTING': [
'--append felix-PREROUTING --jump felix-FIP-DNAT',
'--append felix-PREROUTING --protocol tcp --dport 80 --destination '
'169.254.169.254/32 --jump DNAT --to-destination 192.168.127.12:1234'
],
'felix-POSTROUTING': [
'--append felix-POSTROUTING --jump felix-FIP-SNAT'
]
}
m_v4_nat_upd.rewrite_chains.assert_called_once_with(
expected_chains,
{'felix-PREROUTING': set(['felix-FIP-DNAT']),
'felix-POSTROUTING': set(['felix-FIP-SNAT'])},
async=False
)
expected_chains = {
'felix-INPUT': [
'--append felix-INPUT --match conntrack --ctstate INVALID --jump DROP',
'--append felix-INPUT --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-INPUT --jump MARK --set-mark 0/0x4000000',
'--append felix-INPUT --in-interface tap+ --jump MARK --set-mark 0x4000000/0x4000000',
'--append felix-INPUT --goto felix-FROM-HOST-IF --match mark --mark 0/0x4000000',
'--append felix-INPUT --protocol tcp --destination 192.168.127.12 --dport 1234 --jump ACCEPT',
'--append felix-INPUT --protocol udp --sport 68 --dport 67 --jump ACCEPT',
'--append felix-INPUT --protocol udp --dport 53 --jump ACCEPT',
'--append felix-INPUT --jump felix-FROM-ENDPOINT'
],
'felix-OUTPUT': [
'--append felix-OUTPUT --match conntrack --ctstate INVALID --jump DROP',
'--append felix-OUTPUT --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-OUTPUT --jump MARK --set-mark 0/0x4000000',
'--append felix-OUTPUT --out-interface tap+ --jump MARK --set-mark 0x4000000/0x4000000',
'--append felix-OUTPUT --goto felix-TO-HOST-IF --match mark --mark 0/0x4000000',
],
'felix-FORWARD': [
'--append felix-FORWARD --in-interface tap+ --match conntrack --ctstate INVALID --jump DROP',
'--append felix-FORWARD --out-interface tap+ --match conntrack --ctstate INVALID --jump DROP',
'--append felix-FORWARD --in-interface tap+ --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-FORWARD --out-interface tap+ --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-FORWARD --jump felix-FROM-ENDPOINT --in-interface tap+',
'--append felix-FORWARD --jump felix-TO-ENDPOINT --out-interface tap+',
'--append felix-FORWARD --jump ACCEPT --in-interface tap+',
'--append felix-FORWARD --jump ACCEPT --out-interface tap+'
],
'felix-FAILSAFE-IN': [
'--append felix-FAILSAFE-IN --protocol tcp --dport 22 --jump ACCEPT'
],
'felix-FAILSAFE-OUT': [
'--append felix-FAILSAFE-OUT --protocol tcp --dport 2379 --jump ACCEPT',
'--append felix-FAILSAFE-OUT --protocol tcp --dport 2380 --jump ACCEPT',
'--append felix-FAILSAFE-OUT --protocol tcp --dport 4001 --jump ACCEPT',
'--append felix-FAILSAFE-OUT --protocol tcp --dport 7001 --jump ACCEPT'
]
}
m_v4_upd.rewrite_chains.assert_called_once_with(
expected_chains,
EXPECTED_TOP_LEVEL_DEPS,
async=False
)
@patch("calico.felix.futils.check_call", autospec=True)
@patch("calico.felix.frules.devices", autospec=True)
@patch("calico.felix.frules.HOSTS_IPSET_V4", autospec=True)
def test_install_global_no_ipv6(self, m_ipset, m_devices, m_check_call):
m_devices.interface_exists.return_value = False
m_devices.interface_up.return_value = False
m_set_ips = m_devices.set_interface_ips
env_dict = {
"FELIX_ETCDADDR": "localhost:4001",
"FELIX_HOSTNAME": "myhost",
"FELIX_INTERFACEPREFIX": "tap",
"FELIX_METADATAADDR": "192.168.127.12",
"FELIX_METADATAPORT": "1234",
"FELIX_IPINIPENABLED": "false",
"FELIX_IPINIPMTU": "1480",
"FELIX_DEFAULTENDPOINTTOHOSTACTION": "RETURN"
}
config = load_config("felix_missing.cfg", env_dict=env_dict)
m_v4_upd = Mock(spec=IptablesUpdater)
m_v4_nat_upd = Mock(spec=IptablesUpdater)
frules.install_global_rules(config, m_v4_upd, m_v4_nat_upd,
ip_version=4)
self.assertEqual(
m_v4_nat_upd.ensure_rule_inserted.mock_calls,
[call("PREROUTING --jump felix-PREROUTING", async=False),
call("POSTROUTING --jump felix-POSTROUTING", async=False)]
)
m_v4_upd.ensure_rule_inserted.assert_has_calls([
call("INPUT --jump felix-INPUT", async=False),
call("OUTPUT --jump felix-OUTPUT", async=False),
call("FORWARD --jump felix-FORWARD", async=False)
]
)
self.assertEqual(
m_v4_nat_upd.ensure_rule_removed.mock_calls,
[call("POSTROUTING --out-interface tunl0 "
"-m addrtype ! --src-type LOCAL --limit-iface-out "
"-m addrtype --src-type LOCAL "
"-j MASQUERADE",
async=False)]
)
self.assertFalse(m_ipset.ensure_exists.called)
self.assertFalse(m_check_call.called)
self.assertFalse(m_set_ips.called)
expected_chains = {
'felix-FIP-DNAT': [],
'felix-FIP-SNAT': [],
'felix-PREROUTING': [
'--append felix-PREROUTING --jump felix-FIP-DNAT',
'--append felix-PREROUTING --protocol tcp --dport 80 --destination '
'169.254.169.254/32 --jump DNAT --to-destination 192.168.127.12:1234'
],
'felix-POSTROUTING': [
'--append felix-POSTROUTING --jump felix-FIP-SNAT'
]
}
m_v4_nat_upd.rewrite_chains.assert_called_once_with(
expected_chains,
{'felix-PREROUTING': set(['felix-FIP-DNAT']),
'felix-POSTROUTING': set(['felix-FIP-SNAT'])},
async=False
)
expected_chains = {
'felix-INPUT': [
'--append felix-INPUT --match conntrack --ctstate INVALID --jump DROP',
'--append felix-INPUT --match conntrack --ctstate RELATED,ESTABLISHED --jump ACCEPT',
'--append felix-INPUT --jump MARK --set-mark 0/0x4000000',
'--append felix-INPUT --in-interface tap+ --jump MARK --set-mark 0x4000000/0x4000000',
'--append felix-INPUT --goto felix-FROM-HOST-IF --match mark --mark 0/0x4000000',
'--append felix-INPUT --protocol tcp --destination 192.168.127.12 --dport 1234 --jump ACCEPT',
'--append | |
Size of population 2 after split.
b1: Population growth coefficient of population 1
b2: Population growth coefficient of population 2
m12: Migration from pop 2 to pop 1 (2*Na*m12).
m21: Migration from pop 1 to pop 2.
Tam: The scaled time between the split and the end of ancient migration (in units of 2*Na generations).
Ts: The scaled time between the end of ancient migration and present.
n1,n2: Size of fs to generate.
pts: Number of points to use in grid for evaluation.
"""
# Define the grid we'll use
xx = dadi.Numerics.default_grid(pts)
# phi for the equilibrium ancestral population
phi = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
phi = dadi.Integration.one_pop(phi, xx, Tp, nu=nuA)
# Now do the divergence event
phi = dadi.PhiManip.phi_1D_to_2D(xx, phi)
# We start the population size change after the split independantly in each population and set the migration rate to m12 and m21
bnu1_func = lambda t: nu1 * b1**(t/Tam)
bnu2_func = lambda t: nu2 * b2**(t/Tam)
phi = dadi.Integration.two_pops(phi, xx, Tam, bnu1_func, bnu2_func, m12=m12, m21=m21)
# We continue the population size change after ancient migration (until present) independantly in each population and set the migration rates to zero
bnu1_func = lambda t: nu1 * b1**(t/Ts)
bnu2_func = lambda t: nu2 * b2**(t/Ts)
phi = dadi.Integration.two_pops(phi, xx, Ts, bnu1_func, bnu2_func, m12=0, m21=0)
###
## Finally, calculate the spectrum.
fs = dadi.Spectrum.from_phi(phi, (n1,n2), (xx,xx))
return fs
def AMA2N(params, (n1,n2), pts):
nuA, nu1, nu2, hrf, m12, m21, Tam, Tp, Ts, Q = params
"""
Model with split, ancient migration, heterogenous effective population size (with 2 classes of loci shared by the two populations = Hill-Robertson effects)
nu1: Size of population 1 after split.
nu2: Size of population 2 after split.
hrf: Hill-Robertson factor, i.e. the degree to which Ne is locally reduced due to the effects of background selection and selective sweep effects
m12: Migration from pop 2 to pop 1 (2*Na*m12).
m21: Migration from pop 1 to pop 2.
Tam: The scaled time between the split and the end of ancient migration.
Ts: The scaled time between the end of ancient migration and present (in units of 2*Na generations).
Q: The proportion of the genome with a reduced effective size due to selection at linked sites
n1,n2: Size of fs to generate.
pts: Number of points to use in grid for evaluation.
"""
# Define the grid we'll use
xx = dadi.Numerics.default_grid(pts)
#### Calculate the pectrum in normally-recombining regions
# phi for the equilibrium ancestral population
phinr = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
phinr = dadi.Integration.one_pop(phinr, xx, Tp, nu=nuA)
# Now do the divergence event
phinr = dadi.PhiManip.phi_1D_to_2D(xx, phinr)
# We set the population sizes after the split to nu1 and nu2 and the migration rates to m12 and m21
phinr = dadi.Integration.two_pops(phinr, xx, Tam, nu1, nu2, m12=m12, m21=m21)
# We keep the population sizes after the split to nu1 and nu2 and set the migration rates to zero
phinr = dadi.Integration.two_pops(phinr, xx, Ts, nu1, nu2, m12=0, m21=0)
## calculate the spectrum.
fsnr = dadi.Spectrum.from_phi(phinr, (n1,n2), (xx,xx))
#### Spectrum of low-recombining regions
# phi for the equilibrium ancestral population
philr = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
philr = dadi.Integration.one_pop(philr, xx, Tp, nu=nuA)
# Now do the divergence event
philr = dadi.PhiManip.phi_1D_to_2D(xx, philr)
# We set the population sizes after the split to hrf*nu1 and hrf*nu2 and the migration rates to m12 and m21
philr = dadi.Integration.two_pops(philr, xx, Tam, nu1*hrf, nu2*hrf, m12=m12, m21=m21)
# We keep the population sizes after the split to hrf*nu1 and hrf*nu2 and set the migration rates to zero
philr = dadi.Integration.two_pops(philr, xx, Ts, nu1*hrf, nu2*hrf, m12=0, m21=0)
## calculate the spectrum.
fslr = dadi.Spectrum.from_phi(philr, (n1,n2), (xx,xx))
#### Sum the two spectra in proportion O and 1-O
fs= (1-Q)*fsnr + Q*fslr
return fs
def AMA2N2m(params, (n1,n2), pts):
nuA, nu1, nu2, hrf, m12, m21, me12, me21, Tam, Tp, Ts, P, Q = params
"""
Model of semi permeability with split, ancient migration with 2 migration rates, heterogenous effective population size (2 classes, shared by the two populations = background selection)
nu1: Size of population 1 after split.
nu2: Size of population 2 after split.
hrf: Hill-Robertson factor, i.e. the degree to which Ne is locally reduced due to the effects of background selection and selective sweep effects
m12: Migration from pop 2 to pop 1 (2*Na*m12).
m21: Migration from pop 1 to pop 2.
me12: Effective migration from pop 2 to pop 1 in genomic islands.
me21: Effective migration from pop 1 to pop 2 in genomic islands.
Ts: The scaled time between the split and the ancient migration (in units of 2*Na generations).
Tam: The scale time between the ancient migration and present.
P: The proportion of the genome evolving neutrally
Q: The proportion of the genome with a reduced effective size due to selection at linked sites
n1,n2: Size of fs to generate.
pts: Number of points to use in grid for evaluation.
"""
# Define the grid we'll use
xx = dadi.Numerics.default_grid(pts)
#### Calculate the neutral spectrum
# phi for the equilibrium ancestral population
phiN = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
phiN = dadi.Integration.one_pop(phiN, xx, Tp, nu=nuA)
# Now do the divergence event
phiN = dadi.PhiManip.phi_1D_to_2D(xx, phiN)
# We set the population sizes after the split to nu1 and nu2 and the migration rate to m12 and m21
phiN = dadi.Integration.two_pops(phiN, xx, Tam, nu1, nu2, m12=m12, m21=m21)
# We keep the population sizes after the split to nu1 and nu2 and set the migration rates to zero
phiN = dadi.Integration.two_pops(phiN, xx, Ts, nu1, nu2, m12=0, m21=0)
###
## calculate the spectrum.
fsN = dadi.Spectrum.from_phi(phiN, (n1,n2), (xx,xx))
#### Calculate the genomic island spectrum
# phi for the equilibrium ancestral population
phiI = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
phiI = dadi.Integration.one_pop(phiI, xx, Tp, nu=nuA)
# Now do the divergence event
phiI = dadi.PhiManip.phi_1D_to_2D(xx, phiI)
# We set the population sizes after the split to nu1 and nu2 and the migration rates to me12 and me21
phiI = dadi.Integration.two_pops(phiI, xx, Ts, nu1, nu2, m12=me12, m21=me21)
# We keep the population sizes after the split to nu1 and nu2 and set the migration rate to zero
phiI = dadi.Integration.two_pops(phiI, xx, Tam, nu1, nu2, m12=0, m21=0)
###
## calculate the spectrum.
fsI = dadi.Spectrum.from_phi(phiI, (n1,n2), (xx,xx))
#### Calculate the pectrum in normally-recombining regions
# phi for the equilibrium ancestral population
phinr = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
phinr = dadi.Integration.one_pop(phinr, xx, Tp, nu=nuA)
# Now do the divergence event
phinr = dadi.PhiManip.phi_1D_to_2D(xx, phinr)
# We set the population sizes after the split to nu1 and nu2 and the migration rates to m12 and m21
phinr = dadi.Integration.two_pops(phinr, xx, Tam, nu1, nu2, m12=m12, m21=m21)
# We keep the population sizes after the split to nu1 and nu2 and set the migration rates to zero
phinr = dadi.Integration.two_pops(phinr, xx, Ts, nu1, nu2, m12=0, m21=0)
###
## calculate the spectrum.
# oriented
fsnr = dadi.Spectrum.from_phi(phinr, (n1,n2), (xx,xx))
#### Spectrum of low-recombining regions
# phi for the equilibrium ancestral population
philr = dadi.PhiManip.phi_1D(xx)
#Now do the population growth event.
philr = dadi.Integration.one_pop(philr, xx, Tp, nu=nuA)
# Now do the divergence event
philr = dadi.PhiManip.phi_1D_to_2D(xx, philr)
# We set the population sizes after the split to hrf*nu1 and hrf*nu2 and the migration rates to m12 and m21
philr = dadi.Integration.two_pops(philr, xx, Tam, nu1*hrf, nu2*hrf, m12=m12, m21=m21)
# We keep the population sizes after the split to hrf*nu1 and hrf*nu2 and set the migration rates to zero
philr = dadi.Integration.two_pops(philr, xx, Ts, nu1*hrf, nu2*hrf, m12=0, m21=0)
###
## calculate the spectrum.
fslr = dadi.Spectrum.from_phi(philr, (n1,n2), (xx,xx))
#### Sum the spectra
fs = P*fsN+(1-P)*fsI+(1-Q)*fsnr+Q*fslr
return fs
def AMA2NG(params, (n1,n2), pts):
nuA, nu1, nu2, b1, b2, hrf, m12, | |
<gh_stars>0
#!/bin/env python3
import sys
import os
import traceback
import ast
from neo4j import GraphDatabase
sys.path.append(os.path.dirname(os.path.abspath(__file__))+"/../../reasoningtool/QuestionAnswering/")
from KGNodeIndex import KGNodeIndex
sys.path.append(os.path.dirname(os.path.abspath(__file__))+"/../../") # code directory
from RTXConfiguration import RTXConfiguration
sys.path.append(os.path.dirname(os.path.abspath(__file__))+"/../../UI/OpenAPI/python-flask-server/")
from swagger_server.models.node import Node
from swagger_server.models.edge import Edge
from swagger_server.models.node_attribute import NodeAttribute
from swagger_server.models.edge_attribute import EdgeAttribute
class KGQuerier:
def __init__(self, response_object, kp_to_use):
self.response = response_object
self.kp = "KG2" if kp_to_use == "ARAX/KG2" else "KG1"
self.query_graph = None
self.cypher_query = None
self.query_results = None
self.edge_to_nodes_map = dict()
self.final_kg = {'nodes': dict(), 'edges': dict()}
def answer_one_hop_query(self, query_graph, qnodes_using_curies_from_prior_step):
"""
This function answers a one-hop (single-edge) query using either KG1 or KG2.
:param query_graph: A Reasoner API standard query graph.
:param qnodes_using_curies_from_prior_step: Set of QNode IDs whose curie is now a list of curies found in a
prior expand step (only for Expand's purposes).
:return: An (almost) Reasoner API standard knowledge graph containing all of the nodes and edges returned as
results for the query. (Dictionary version, organized by QG IDs.)
"""
self.query_graph = query_graph
dsl_parameters = self.response.data['parameters']
kp = self.kp
synonym_usages_dict = dict()
if dsl_parameters['use_synonyms']:
synonym_usages_dict = self.__add_curie_synonyms_to_query_nodes(self.query_graph.nodes, kp,
qnodes_using_curies_from_prior_step)
if not self.response.status == 'OK':
return self.final_kg, self.edge_to_nodes_map
self.__convert_query_graph_to_cypher_query(dsl_parameters['enforce_directionality'])
if not self.response.status == 'OK':
return self.final_kg, self.edge_to_nodes_map
self.__answer_query_using_kg_neo4j(kp, dsl_parameters['continue_if_no_results'])
if not self.response.status == 'OK':
return self.final_kg, self.edge_to_nodes_map
self.__add_answers_to_kg(dsl_parameters['synonym_handling'], synonym_usages_dict, kp, query_graph)
if not self.response.status == 'OK':
return self.final_kg, self.edge_to_nodes_map
return self.final_kg, self.edge_to_nodes_map
def answer_single_node_query(self, qnode):
if not qnode.curie:
self.response.error(f"Cannot expand a single query node if it doesn't have a curie", error_code="InvalidQuery")
else:
# Gather synonyms as appropriate
use_synonyms = self.response.data['parameters'].get('use_synonyms')
synonym_handling = self.response.data['parameters'].get('synonym_handling')
synonym_usages_dict = dict()
if use_synonyms:
synonym_usages_dict = self.__add_curie_synonyms_to_query_nodes([qnode], self.kp)
if not self.response.status == 'OK':
return self.final_kg
# Build and run a cypher query to get this node/nodes
where_clause = f"{qnode.id}.id='{qnode.curie}'" if type(qnode.curie) is str else f"{qnode.id}.id in {qnode.curie}"
cypher_query = f"MATCH {self.__get_cypher_for_query_node(qnode)} WHERE {where_clause} RETURN {qnode.id}"
results = self.__run_cypher_query(cypher_query, self.kp)
# Process the results and add to our answer knowledge graph, handling synonyms as appropriate
for result in results:
neo4j_node = result.get(qnode.id)
swagger_node = self.__convert_neo4j_node_to_swagger_node(neo4j_node, qnode.id, self.kp)
if qnode.id in synonym_usages_dict and synonym_handling == "map_back":
# Only add the original curie (discard synonym nodes)
if swagger_node.id in synonym_usages_dict[qnode.id].keys():
self.__add_node_to_kg(swagger_node)
else:
self.__add_node_to_kg(swagger_node)
return self.final_kg
def __add_curie_synonyms_to_query_nodes(self, query_nodes, kp, qnodes_using_curies_from_prior_step=None):
self.response.debug("Looking for query nodes to use curie synonyms for")
if not qnodes_using_curies_from_prior_step:
qnodes_using_curies_from_prior_step = set()
kgni = KGNodeIndex()
synonym_usages_dict = dict()
for qnode in query_nodes:
if qnode.curie and (qnode.id not in qnodes_using_curies_from_prior_step):
curies_to_use_synonyms_for = qnode.curie if type(qnode.curie) is list else [qnode.curie]
synonyms = []
for curie in curies_to_use_synonyms_for:
original_curie = curie
equivalent_curies = kgni.get_equivalent_curies(original_curie, kg_name=kp)
if len(equivalent_curies) > 1:
synonyms += equivalent_curies
qnode.type = None # Equivalent curie types may be different than the original, so we clear this
if qnode.id not in synonym_usages_dict:
synonym_usages_dict[qnode.id] = dict()
synonym_usages_dict[qnode.id][original_curie] = equivalent_curies
elif len(equivalent_curies) == 1:
self.response.info(f"Could not find any equivalent curies in {kp} for {original_curie}")
synonyms += equivalent_curies
else:
self.response.error(f"{kp} does not contain a node with curie {original_curie}", error_code="UnknownCurie")
# Use our new synonyms list only if we actually found any synonyms
if synonyms != curies_to_use_synonyms_for:
self.response.info(f"Using equivalent curies for qnode {qnode.id} ({qnode.curie}): {synonyms}")
qnode.curie = synonyms
return synonym_usages_dict
def __convert_query_graph_to_cypher_query(self, enforce_directionality):
if len(self.query_graph.edges) > 1:
self.response.error(f"KGQuerier requires a single-edge query graph", error_code="InvalidQuery")
else:
self.response.debug(f"Generating cypher for edge {self.query_graph.edges[0].id} query graph")
try:
# Build the match clause
edge = self.query_graph.edges[0]
source_node = self.__get_query_node(edge.source_id)
target_node = self.__get_query_node(edge.target_id)
edge_cypher = self.__get_cypher_for_query_edge(edge, enforce_directionality)
source_node_cypher = self.__get_cypher_for_query_node(source_node)
target_node_cypher = self.__get_cypher_for_query_node(target_node)
match_clause = f"MATCH {source_node_cypher}{edge_cypher}{target_node_cypher}"
# Build the where clause
where_fragments = []
for node in [source_node, target_node]:
if node.curie:
if type(node.curie) is str:
where_fragment = f"{node.id}.id='{node.curie}'"
else:
where_fragment = f"{node.id}.id in {node.curie}"
where_fragments.append(where_fragment)
if len(where_fragments):
where_clause = "WHERE "
where_clause += " AND ".join(where_fragments)
else:
where_clause = ""
# Build the with clause
source_node_col_name = f"nodes_{source_node.id}"
target_node_col_name = f"nodes_{target_node.id}"
edge_col_name = f"edges_{edge.id}"
extra_edge_properties = "{.*, " + f"id:ID({edge.id}), {source_node.id}:{source_node.id}.id, {target_node.id}:{target_node.id}.id" + "}"
with_clause = f"WITH collect(distinct {source_node.id}) as {source_node_col_name}, " \
f"collect(distinct {target_node.id}) as {target_node_col_name}, " \
f"collect(distinct {edge.id}{extra_edge_properties}) as {edge_col_name}"
# Build the return clause
return_clause = f"RETURN {source_node_col_name}, {target_node_col_name}, {edge_col_name}"
self.cypher_query = f"{match_clause} {where_clause} {with_clause} {return_clause}"
except:
tb = traceback.format_exc()
error_type, error, _ = sys.exc_info()
self.response.error(f"Problem generating cypher for query. {tb}", error_code=error_type.__name__)
def __answer_query_using_kg_neo4j(self, kp, continue_if_no_results):
self.response.info(f"Sending cypher query for edge {self.query_graph.edges[0].id} to {kp} neo4j")
self.query_results = self.__run_cypher_query(self.cypher_query, kp)
if self.response.status == 'OK':
columns_with_lengths = dict()
for column in self.query_results[0]:
columns_with_lengths[column] = len(self.query_results[0].get(column))
if any(length == 0 for length in columns_with_lengths.values()):
if continue_if_no_results:
self.response.warning(f"No paths were found in {kp} satisfying this query graph")
else:
self.response.error(f"No paths were found in {kp} satisfying this query graph", error_code="NoResults")
else:
num_results_string = ", ".join([f"{column.split('_')[1]}: {value}" for column, value in sorted(columns_with_lengths.items())])
self.response.info(f"Query for edge {self.query_graph.edges[0].id} returned results ({num_results_string})")
def __add_answers_to_kg(self, synonym_handling, synonym_usages_dict, kp, query_graph):
self.response.debug(f"Processing query results for edge {self.query_graph.edges[0].id}")
node_uuid_to_curie_dict = self.__build_node_uuid_to_curie_dict(self.query_results[0]) if kp == "KG1" else dict()
results_table = self.query_results[0]
column_names = [column_name for column_name in results_table]
for column_name in column_names:
# Load answer nodes into our knowledge graph
if column_name.startswith('nodes'): # Example column name: 'nodes_n00'
qnode_id = column_name.replace("nodes_", "", 1)
for node in results_table.get(column_name):
swagger_node = self.__convert_neo4j_node_to_swagger_node(node, qnode_id, kp)
if synonym_handling == 'map_back' and qnode_id in synonym_usages_dict:
# Only keep the node corresponding to the original curie (discard synonym nodes)
if swagger_node.id in synonym_usages_dict[qnode_id].keys():
self.__add_node_to_kg(swagger_node)
else:
self.__add_node_to_kg(swagger_node)
# Load answer edges into our knowledge graph
elif column_name.startswith('edges'): # Example column name: 'edges_e01'
qedge_id = column_name.replace("edges_", "", 1)
for edge in results_table.get(column_name):
if kp == "KG2":
swagger_edge = self.__convert_kg2_edge_to_swagger_edge(edge, qedge_id)
else:
swagger_edge = self.__convert_kg1_edge_to_swagger_edge(edge, qedge_id, node_uuid_to_curie_dict)
# Record which of this edge's nodes correspond to which qnode_id
qedge = query_graph.edges[0]
self.edge_to_nodes_map[swagger_edge.id] = dict()
for qnode_id in [qedge.source_id, qedge.target_id]:
node_curie = edge.get(qnode_id)
self.edge_to_nodes_map[swagger_edge.id][qnode_id] = node_curie
if synonym_handling == 'map_back':
# Edit edge to point to original curie, if it uses a synonym
for qnode_id, synonym_usage_mappings in synonym_usages_dict.items():
curie_for_this_qnode_id = self.edge_to_nodes_map[swagger_edge.id].get(qnode_id)
for original_curie, synonyms_used in synonym_usage_mappings.items():
if curie_for_this_qnode_id in synonyms_used:
if swagger_edge.source_id == curie_for_this_qnode_id:
swagger_edge.source_id = original_curie
if swagger_edge.target_id == curie_for_this_qnode_id:
swagger_edge.target_id = original_curie
self.edge_to_nodes_map[swagger_edge.id][qnode_id] = original_curie
self.__add_edge_to_kg(swagger_edge)
# Make sure any original curie that synonyms were used for appears in the answer kg as appropriate
if synonym_handling == 'map_back':
for qnode_id, synonym_usage_mappings in synonym_usages_dict.items():
for original_curie, synonyms_used in synonym_usage_mappings.items():
if qnode_id not in self.final_kg['nodes'] or original_curie not in self.final_kg['nodes'][qnode_id]:
# Get this node from neo4j and add it to the kg
cypher = f"match (n) where n.id='{original_curie}' return n limit 1"
original_node = self.__run_cypher_query(cypher, kp)[0].get('n')
swagger_node = self.__convert_neo4j_node_to_swagger_node(original_node, qnode_id, kp)
self.__add_node_to_kg(swagger_node)
if self.final_kg['edges']:
# Remove any self-edges
edges_to_remove = []
qedge_id = self.query_graph.edges[0]
for qedge_id, edges in self.final_kg['edges'].items():
for edge_key, edge in edges.items():
if edge.source_id == edge.target_id:
edges_to_remove.append(edge_key)
for edge_id in edges_to_remove:
self.final_kg['edges'][qedge_id].pop(edge_id)
# Remove any nodes that may have been orphaned
for qnode_id in [node.id for node in self.query_graph.nodes]:
node_ids_used_by_edges_for_this_qnode_id = set()
for edge in self.final_kg['edges'][qedge_id].values():
node_ids_used_by_edges_for_this_qnode_id.add(self.edge_to_nodes_map[edge.id][qnode_id])
orphan_node_ids_for_this_qnode_id = set(self.final_kg['nodes'][qnode_id].keys()).difference(node_ids_used_by_edges_for_this_qnode_id)
for node_id in orphan_node_ids_for_this_qnode_id:
self.final_kg['nodes'][qnode_id].pop(node_id)
def __convert_neo4j_node_to_swagger_node(self, neo4j_node, qnode_id, kp):
if kp == "KG2":
return self.__convert_kg2_node_to_swagger_node(neo4j_node, qnode_id)
else:
return self.__convert_kg1_node_to_swagger_node(neo4j_node, qnode_id)
def __convert_kg2_node_to_swagger_node(self, neo4j_node, qnode_id):
swagger_node = Node()
swagger_node.qnode_id = qnode_id
swagger_node.id = neo4j_node.get('id')
swagger_node.name = neo4j_node.get('name')
swagger_node.description = neo4j_node.get('description')
swagger_node.uri = neo4j_node.get('iri')
swagger_node.node_attributes = []
node_category = neo4j_node.get('category_label')
swagger_node.type = node_category if type(node_category) is list else [node_category]
# Fill out the 'symbol' property (only really relevant for nodes from UniProtKB)
if swagger_node.symbol is None and swagger_node.id.lower().startswith("uniprot"):
swagger_node.symbol = neo4j_node.get('name')
swagger_node.name = neo4j_node.get('full_name')
# Add all additional properties on KG2 nodes as swagger NodeAttribute objects
additional_kg2_node_properties = ['publications', 'synonym', 'category', 'provided_by', 'deprecated',
'update_date']
node_attributes = self.__create_swagger_attributes("node", additional_kg2_node_properties, neo4j_node)
swagger_node.node_attributes += node_attributes
return swagger_node
def __convert_kg1_node_to_swagger_node(self, neo4j_node, qnode_id):
swagger_node = Node()
swagger_node.qnode_id = qnode_id
swagger_node.id = neo4j_node.get('id')
swagger_node.name = neo4j_node.get('name')
swagger_node.symbol = neo4j_node.get('symbol')
swagger_node.description = neo4j_node.get('description')
swagger_node.uri = neo4j_node.get('uri')
swagger_node.node_attributes = []
node_category = neo4j_node.get('category')
swagger_node.type = node_category if type(node_category) is list else [node_category]
return swagger_node
def __convert_kg2_edge_to_swagger_edge(self, neo4j_edge, qedge_id):
swagger_edge = Edge()
swagger_edge.id = f"KG2:{neo4j_edge.get('id')}"
swagger_edge.qedge_id = qedge_id
swagger_edge.type = neo4j_edge.get('simplified_edge_label')
swagger_edge.source_id = neo4j_edge.get('subject')
swagger_edge.target_id = neo4j_edge.get('object')
swagger_edge.relation = neo4j_edge.get('relation')
swagger_edge.publications = ast.literal_eval(neo4j_edge.get('publications'))
swagger_edge.provided_by = self.__convert_strange_provided_by_field_to_list(neo4j_edge.get('provided_by')) # Temporary hack until provided_by is fixed in | |
filter_by(reserved=reserved).\
filter_by(address=address).\
update(params, synchronize_session='evaluate')
if not rows_updated:
LOG.debug('The row was updated in a concurrent transaction, '
'we will fetch another row')
raise exception.FixedIpAssociateFailed(net=network_id)
return fixed_ip_ref
@require_admin_context
@_retry_on_deadlock
@retrying.retry(stop_max_attempt_number=5, retry_on_exception=
lambda exc: isinstance(exc, exception.FixedIpAssociateFailed))
def fixed_ip_associate_pool(context, network_id, instance_uuid=None,
host=None):
if instance_uuid and not uuidutils.is_uuid_like(instance_uuid):
raise exception.InvalidUUID(uuid=instance_uuid)
session = get_session()
with session.begin():
network_or_none = or_(models.FixedIp.network_id == network_id,
models.FixedIp.network_id == null())
fixed_ip_ref = model_query(context, models.FixedIp, session=session,
read_deleted="no").\
filter(network_or_none).\
filter_by(reserved=False).\
filter_by(instance_uuid=None).\
filter_by(host=None).\
first()
if not fixed_ip_ref:
raise exception.NoMoreFixedIps(net=network_id)
params = {}
if fixed_ip_ref['network_id'] is None:
params['network_id'] = network_id
if instance_uuid:
params['instance_uuid'] = instance_uuid
if host:
params['host'] = host
rows_updated = model_query(context, models.FixedIp, session=session,
read_deleted="no").\
filter_by(id=fixed_ip_ref['id']).\
filter_by(network_id=fixed_ip_ref['network_id']).\
filter_by(reserved=False).\
filter_by(instance_uuid=None).\
filter_by(host=None).\
filter_by(address=fixed_ip_ref['address']).\
update(params, synchronize_session='evaluate')
if not rows_updated:
LOG.debug('The row was updated in a concurrent transaction, '
'we will fetch another row')
raise exception.FixedIpAssociateFailed(net=network_id)
return fixed_ip_ref
@require_context
def fixed_ip_create(context, values):
fixed_ip_ref = models.FixedIp()
fixed_ip_ref.update(values)
try:
fixed_ip_ref.save()
except db_exc.DBDuplicateEntry:
raise exception.FixedIpExists(address=values['address'])
return fixed_ip_ref
@require_context
def fixed_ip_bulk_create(context, ips):
engine = get_engine()
with engine.begin() as conn:
try:
tab = models.FixedIp.__table__
conn.execute(tab.insert(), ips)
except db_exc.DBDuplicateEntry as e:
raise exception.FixedIpExists(address=e.value)
@require_context
def fixed_ip_disassociate(context, address):
session = get_session()
with session.begin():
_fixed_ip_get_by_address(context, address, session=session).\
update({'instance_uuid': None,
'virtual_interface_id': None})
def fixed_ip_disassociate_all_by_timeout(context, host, time):
session = get_session()
# NOTE(vish): only update fixed ips that "belong" to this
# host; i.e. the network host or the instance
# host matches. Two queries necessary because
# join with update doesn't work.
with session.begin():
host_filter = or_(and_(models.Instance.host == host,
models.Network.multi_host == true()),
models.Network.host == host)
result = model_query(context, models.FixedIp, (models.FixedIp.id,),
read_deleted="no", session=session).\
filter(models.FixedIp.allocated == false()).\
filter(models.FixedIp.updated_at < time).\
join((models.Network,
models.Network.id == models.FixedIp.network_id)).\
join((models.Instance,
models.Instance.uuid == models.FixedIp.instance_uuid)).\
filter(host_filter).\
all()
fixed_ip_ids = [fip[0] for fip in result]
if not fixed_ip_ids:
return 0
result = model_query(context, models.FixedIp, session=session).\
filter(models.FixedIp.id.in_(fixed_ip_ids)).\
update({'instance_uuid': None,
'leased': False,
'updated_at': timeutils.utcnow()},
synchronize_session='fetch')
return result
@require_context
def fixed_ip_get(context, id, get_network=False):
query = model_query(context, models.FixedIp).filter_by(id=id)
if get_network:
query = query.options(joinedload('network'))
result = query.first()
if not result:
raise exception.FixedIpNotFound(id=id)
# FIXME(sirp): shouldn't we just use project_only here to restrict the
# results?
if (nova.context.is_user_context(context) and
result['instance_uuid'] is not None):
instance = instance_get_by_uuid(context.elevated(read_deleted='yes'),
result['instance_uuid'])
nova.context.authorize_project_context(context, instance.project_id)
return result
@require_admin_context
def fixed_ip_get_all(context):
result = model_query(context, models.FixedIp, read_deleted="yes").all()
if not result:
raise exception.NoFixedIpsDefined()
return result
@require_context
def fixed_ip_get_by_address(context, address, columns_to_join=None):
return _fixed_ip_get_by_address(context, address,
columns_to_join=columns_to_join)
def _fixed_ip_get_by_address(context, address, session=None,
columns_to_join=None):
if session is None:
session = get_session()
if columns_to_join is None:
columns_to_join = []
with session.begin(subtransactions=True):
try:
result = model_query(context, models.FixedIp, session=session)
for column in columns_to_join:
result = result.options(joinedload_all(column))
result = result.filter_by(address=address).first()
if not result:
raise exception.FixedIpNotFoundForAddress(address=address)
except db_exc.DBError:
msg = _("Invalid fixed IP Address %s in request") % address
LOG.warn(msg)
raise exception.FixedIpInvalid(msg)
# NOTE(sirp): shouldn't we just use project_only here to restrict the
# results?
if (nova.context.is_user_context(context) and
result['instance_uuid'] is not None):
instance = _instance_get_by_uuid(
context.elevated(read_deleted='yes'),
result['instance_uuid'],
session
)
nova.context.authorize_project_context(context,
instance.project_id)
return result
@require_context
def fixed_ip_get_by_floating_address(context, floating_address):
return model_query(context, models.FixedIp).\
join(models.FloatingIp,
models.FloatingIp.fixed_ip_id ==
models.FixedIp.id).\
filter(models.FloatingIp.address == floating_address).\
first()
# NOTE(tr3buchet) please don't invent an exception here, None is fine
@require_context
def fixed_ip_get_by_instance(context, instance_uuid):
if not uuidutils.is_uuid_like(instance_uuid):
raise exception.InvalidUUID(uuid=instance_uuid)
vif_and = and_(models.VirtualInterface.id ==
models.FixedIp.virtual_interface_id,
models.VirtualInterface.deleted == 0)
result = model_query(context, models.FixedIp, read_deleted="no").\
filter_by(instance_uuid=instance_uuid).\
outerjoin(models.VirtualInterface, vif_and).\
options(contains_eager("virtual_interface")).\
options(joinedload('network')).\
options(joinedload('floating_ips')).\
order_by(asc(models.VirtualInterface.created_at),
asc(models.VirtualInterface.id)).\
all()
if not result:
raise exception.FixedIpNotFoundForInstance(instance_uuid=instance_uuid)
return result
@require_admin_context
def fixed_ip_get_by_host(context, host):
session = get_session()
with session.begin():
instance_uuids = _instance_get_all_uuids_by_host(context, host,
session=session)
if not instance_uuids:
return []
return model_query(context, models.FixedIp, session=session).\
filter(models.FixedIp.instance_uuid.in_(instance_uuids)).\
all()
@require_context
def fixed_ip_get_by_network_host(context, network_id, host):
result = model_query(context, models.FixedIp, read_deleted="no").\
filter_by(network_id=network_id).\
filter_by(host=host).\
first()
if not result:
raise exception.FixedIpNotFoundForNetworkHost(network_id=network_id,
host=host)
return result
@require_context
def fixed_ips_by_virtual_interface(context, vif_id):
result = model_query(context, models.FixedIp, read_deleted="no").\
filter_by(virtual_interface_id=vif_id).\
options(joinedload('network')).\
options(joinedload('floating_ips')).\
all()
return result
@require_context
def fixed_ip_update(context, address, values):
session = get_session()
with session.begin():
_fixed_ip_get_by_address(context, address, session=session).\
update(values)
def _fixed_ip_count_by_project(context, project_id, session=None):
nova.context.authorize_project_context(context, project_id)
return model_query(context, models.FixedIp, (models.FixedIp.id,),
read_deleted="no", session=session).\
join((models.Instance,
models.Instance.uuid == models.FixedIp.instance_uuid)).\
filter(models.Instance.project_id == project_id).\
count()
###################
@require_context
def virtual_interface_create(context, values):
"""Create a new virtual interface record in the database.
:param values: = dict containing column values
"""
try:
vif_ref = models.VirtualInterface()
vif_ref.update(values)
vif_ref.save()
except db_exc.DBError:
raise exception.VirtualInterfaceCreateException()
return vif_ref
def _virtual_interface_query(context, session=None, use_slave=False):
return model_query(context, models.VirtualInterface, session=session,
read_deleted="no", use_slave=use_slave)
@require_context
def virtual_interface_get(context, vif_id):
"""Gets a virtual interface from the table.
:param vif_id: = id of the virtual interface
"""
vif_ref = _virtual_interface_query(context).\
filter_by(id=vif_id).\
first()
return vif_ref
@require_context
def virtual_interface_get_by_address(context, address):
"""Gets a virtual interface from the table.
:param address: = the address of the interface you're looking to get
"""
try:
vif_ref = _virtual_interface_query(context).\
filter_by(address=address).\
first()
except db_exc.DBError:
msg = _("Invalid virtual interface address %s in request") % address
LOG.warn(msg)
raise exception.InvalidIpAddressError(msg)
return vif_ref
@require_context
def virtual_interface_get_by_uuid(context, vif_uuid):
"""Gets a virtual interface from the table.
:param vif_uuid: the uuid of the interface you're looking to get
"""
vif_ref = _virtual_interface_query(context).\
filter_by(uuid=vif_uuid).\
first()
return vif_ref
@require_context
@require_instance_exists_using_uuid
def virtual_interface_get_by_instance(context, instance_uuid, use_slave=False):
"""Gets all virtual interfaces for instance.
:param instance_uuid: = uuid of the instance to retrieve vifs for
"""
vif_refs = _virtual_interface_query(context, use_slave=use_slave).\
filter_by(instance_uuid=instance_uuid).\
order_by(asc("created_at"), asc("id")).\
all()
return vif_refs
@require_context
def virtual_interface_get_by_instance_and_network(context, instance_uuid,
network_id):
"""Gets virtual interface for instance that's associated with network."""
vif_ref = _virtual_interface_query(context).\
filter_by(instance_uuid=instance_uuid).\
filter_by(network_id=network_id).\
first()
return vif_ref
@require_context
def virtual_interface_delete_by_instance(context, instance_uuid):
"""Delete virtual interface records that are associated
with the instance given by instance_id.
:param instance_uuid: = uuid of instance
"""
_virtual_interface_query(context).\
filter_by(instance_uuid=instance_uuid).\
soft_delete()
@require_context
def virtual_interface_get_all(context):
"""Get all vifs."""
vif_refs = _virtual_interface_query(context).all()
return vif_refs
###################
def _metadata_refs(metadata_dict, meta_class):
metadata_refs = []
if metadata_dict:
for k, v in metadata_dict.iteritems():
metadata_ref = meta_class()
metadata_ref['key'] = k
metadata_ref['value'] = v
metadata_refs.append(metadata_ref)
return metadata_refs
def _validate_unique_server_name(context, session, name):
if not CONF.osapi_compute_unique_server_name_scope:
return
lowername = name.lower()
base_query = model_query(context, models.Instance, session=session,
read_deleted='no').\
filter(func.lower(models.Instance.hostname) == lowername)
if CONF.osapi_compute_unique_server_name_scope == 'project':
instance_with_same_name = base_query.\
filter_by(project_id=context.project_id).\
count()
elif CONF.osapi_compute_unique_server_name_scope == 'global':
instance_with_same_name = base_query.count()
else:
msg = _('Unknown osapi_compute_unique_server_name_scope value: %s'
' Flag must be empty, "global" or'
' "project"') % CONF.osapi_compute_unique_server_name_scope
LOG.warn(msg)
return
if instance_with_same_name > 0:
raise exception.InstanceExists(name=lowername)
def _handle_objects_related_type_conversions(values):
"""Make sure that certain things in values (which may have come from
an objects.instance.Instance object) are in suitable form for the
database.
"""
# NOTE(danms): Make sure IP addresses are passed as strings to
# the database engine
for key in ('access_ip_v4', 'access_ip_v6'):
if key in values and values[key] is not None:
values[key] = str(values[key])
datetime_keys = ('created_at', 'deleted_at', 'updated_at',
'launched_at', 'terminated_at', 'scheduled_at')
convert_objects_related_datetimes(values, *datetime_keys)
def _check_instance_exists(context, session, instance_uuid):
if not model_query(context, models.Instance, session=session,
read_deleted="no").filter_by(
uuid=instance_uuid).first():
raise exception.InstanceNotFound(instance_id=instance_uuid)
@require_context
def instance_create(context, values):
"""Create a new Instance record in the database.
context - request context object
values - dict containing column values.
"""
# NOTE(rpodolyaka): create the default security group, if it doesn't exist.
# This must be done in a separate transaction, so that this one is not
# aborted in case a concurrent one succeeds first and the unique constraint
# for security group names is violated by a concurrent INSERT
security_group_ensure_default(context)
values = values.copy()
values['metadata'] = _metadata_refs(
values.get('metadata'), models.InstanceMetadata)
values['system_metadata'] = _metadata_refs(
values.get('system_metadata'), models.InstanceSystemMetadata)
_handle_objects_related_type_conversions(values)
instance_ref = models.Instance()
if not values.get('uuid'):
values['uuid'] = str(uuid.uuid4())
instance_ref['info_cache'] = models.InstanceInfoCache()
info_cache = values.pop('info_cache', None)
if info_cache is not None:
instance_ref['info_cache'].update(info_cache)
security_groups = values.pop('security_groups', [])
instance_ref['extra'] = models.InstanceExtra()
instance_ref['extra'].update(
{'numa_topology': None,
'pci_requests': None,
'vcpu_model': None,
})
instance_ref['extra'].update(values.pop('extra', {}))
instance_ref.update(values)
def _get_sec_group_models(session, security_groups):
models = []
default_group = _security_group_ensure_default(context, session)
if 'default' in security_groups:
models.append(default_group)
# Generate a new list, so we don't modify the original
security_groups = [x for x in security_groups if x != 'default']
if security_groups:
models.extend(_security_group_get_by_names(context,
session, context.project_id, security_groups))
return models
session = get_session()
with session.begin():
if 'hostname' in values:
_validate_unique_server_name(context, session, values['hostname'])
instance_ref.security_groups = _get_sec_group_models(session,
security_groups)
session.add(instance_ref)
# create the instance uuid to ec2_id mapping entry for instance
ec2_instance_create(context, instance_ref['uuid'])
return instance_ref
def _instance_data_get_for_user(context, project_id, user_id, session=None):
result = model_query(context,
models.Instance, (
func.count(models.Instance.id),
func.sum(models.Instance.vcpus),
func.sum(models.Instance.memory_mb),
), session=session).\
filter_by(project_id=project_id)
if user_id:
result = result.filter_by(user_id=user_id).first()
else:
result = result.first()
# NOTE(vish): convert None to 0
return (result[0] or 0, result[1] or 0, result[2] or 0)
@require_context
@_retry_on_deadlock
def instance_destroy(context, instance_uuid, constraint=None):
session = get_session()
with session.begin():
if uuidutils.is_uuid_like(instance_uuid):
instance_ref = _instance_get_by_uuid(context, instance_uuid,
session=session)
else:
raise exception.InvalidUUID(instance_uuid)
query = model_query(context, models.Instance, session=session).\
filter_by(uuid=instance_uuid)
if constraint is not None:
query = constraint.apply(models.Instance, query)
count = query.soft_delete()
if count == 0:
raise exception.ConstraintNotMet()
model_query(context, models.SecurityGroupInstanceAssociation,
session=session).\
filter_by(instance_uuid=instance_uuid).\
soft_delete()
model_query(context, models.InstanceInfoCache, session=session).\
filter_by(instance_uuid=instance_uuid).\
soft_delete()
model_query(context, models.InstanceMetadata, session=session).\
filter_by(instance_uuid=instance_uuid).\
soft_delete()
model_query(context, models.InstanceFault, session=session).\
filter_by(instance_uuid=instance_uuid).\
soft_delete()
model_query(context, models.InstanceExtra, session=session).\
filter_by(instance_uuid=instance_uuid).\
soft_delete()
return instance_ref
@require_context
def instance_get_by_uuid(context, uuid, columns_to_join=None, | |
import os
import dash
import dash_bootstrap_components as dbc
import dash_core_components as dcc
import dash_html_components as html
import geopandas as gpd
import pandas as pd
import plotly.graph_objects as go
import plotly.express as px
from scipy import stats
from peaky_finders.predictor import (
create_load_duration,
ISO_LIST,
get_peak_data,
get_iso_map,
get_forecasts,
)
app_name = os.getenv("APP_NAME", "dash-peaky-finders")
iso_map = get_iso_map()
peak_data = get_peak_data(ISO_LIST)
predictions, load, temperature = get_forecasts(ISO_LIST)
load_duration_curves = create_load_duration(peak_data)
TEMPLATE = "plotly_white"
app = dash.Dash(
external_stylesheets=[dbc.themes.LUX], suppress_callback_exceptions=True
)
server = app.server
"""Homepage"""
app.layout = html.Div(
[dcc.Location(id="url", refresh=False), html.Div(id="page-content"),]
)
index_page = html.Div(
[
html.Br(),
html.Br(),
dbc.Row(
[
dbc.Col(html.H1(children="Welcome to Peaky Finders"), width=5),
dbc.Col(width=5),
],
justify="center",
),
html.Br(),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
html.H4(
children="To what extent do weather and weekday determine total electricity demand on the grid? Click an ISO button below to find out."
),
html.Div(
[
dcc.Link(
html.Button(
"HOME", id="home-button", className="mr-1"
),
href=f"/{app_name}/",
),
dcc.Link(
html.Button(
"CAISO", id="caiso-button", className="mr-1"
),
href=f"/{app_name}/caiso",
),
dcc.Link(
html.Button(
"MISO", id="miso-button", className="mr-1"
),
href=f"/{app_name}/miso",
),
dcc.Link(
html.Button(
"PJM", id="pjm-button", className="mr-1"
),
href=f"/{app_name}/pjm",
),
dcc.Link(
html.Button(
"NYISO", id="nyiso-button", className="mr-1"
),
href=f"/{app_name}/nyiso",
),
dcc.Link(
html.Button(
"ISONE", id="isone-button", className="mr-1"
),
href=f"/{app_name}/isone",
),
]
),
]
),
width=7,
),
dbc.Col(width=3),
],
justify="center",
),
html.Br(),
html.Br(),
html.Br(),
html.Br(),
dbc.Row(
[dbc.Col(html.H4(children="ISO Territory Map"), width=4), dbc.Col(width=4)],
justify="center",
),
html.Div(
[
dcc.Graph(
figure=px.choropleth(
iso_map,
geojson=iso_map.geometry,
locations=iso_map.index,
color="NAME",
projection="mercator",
)
.update_geos(fitbounds="locations", visible=False)
.update_layout(height=600, margin={"r": 0, "t": 0, "l": 0, "b": 0},)
)
],
style={"display": "inline-block", "width": "90%"},
),
]
)
"""NYISO LAYOUT"""
nyiso_layout = html.Div(
[
html.Div(id="nyiso-content"),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
dcc.Link(
html.Button("HOME", id="home-button", className="mr-1"),
href=f"/{app_name}/",
),
dcc.Link(
html.Button(
"CAISO", id="caiso-button", className="mr-1"
),
href=f"/{app_name}/caiso",
),
dcc.Link(
html.Button("MISO", id="miso-button", className="mr-1"),
href=f"/{app_name}/miso",
),
dcc.Link(
html.Button("PJM", id="pjm-button", className="mr-1"),
href=f"/{app_name}/pjm",
),
dcc.Link(
html.Button(
"NYISO", id="nyiso-button", className="mr-1"
),
href=f"/{app_name}/nyiso",
),
dcc.Link(
html.Button(
"ISONE", id="isone-button", className="mr-1"
),
href=f"/{app_name}/isone",
),
]
),
width=4,
),
dbc.Col(width=7),
],
justify="center",
),
html.Br(),
html.Br(),
dbc.Row(
[
dbc.Col(
html.H1("New York Independent System Operator (NYISO)"), width=9
),
dbc.Col(width=2),
],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""
"The NYISO is the New York Independent System Operator — the organization responsible for
managing New York’s electric grid and its competitive wholesale electric marketplace." For more information,
visit https://www.nyiso.com/.
"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[dbc.Col(html.H3("Model Performance"), width=9), dbc.Col(width=2),],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""Mean Absolute Error (MAE) for February, 2021: 347.62 (pretty good)"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[
dbc.Col(
dcc.Dropdown(
id="nyiso-dropdown",
options=[
{"label": "Actual", "value": "Actual"},
{"label": "Predicted", "value": "Predicted"},
],
value=["Actual", "Predicted"],
multi=True,
),
width=6,
),
dbc.Col(width=5),
],
justify="center",
),
dcc.Graph(id="nyiso-graph"),
html.Br(),
html.Br(),
dbc.Row(
[dbc.Col(html.H3("Training Data"), width=9), dbc.Col(width=2)],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""
The NYISO forecasting model was trained on historical load and weather data
from 2018-2021. Temperature readings are from New York City.
"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
dcc.Graph(
figure=px.histogram(
peak_data["NYISO"],
x=peak_data["NYISO"]["load_MW"],
nbins=75,
marginal="rug",
title=f"Distribution of NYISO Daily Peaks",
color_discrete_sequence=["darkturquoise"],
).update_layout(
template=TEMPLATE,
xaxis_title="Peak Load (MW)",
yaxis_title="Number of Days",
)
),
]
),
width=4,
),
dbc.Col(
html.Div(
[
dcc.Graph(
figure=go.Figure()
.add_trace(
go.Scatter(
x=load_duration_curves["NYISO"]
.reset_index()
.index,
y=load_duration_curves["NYISO"].values,
mode="lines",
fill="tozeroy",
line=dict(color="maroon", width=3),
)
)
.update_layout(
title="Peak Load Sorted by Day (Highest to Lowest)",
xaxis_title="Number of Days",
yaxis_title="Load (MW)",
template=TEMPLATE,
),
),
]
),
width=4,
),
dbc.Col(
html.Div(
[
dcc.Dropdown(
id="nyiso-scatter-dropdown",
options=[
{"label": "Day of Week", "value": "weekday"},
{"label": "Season", "value": "season"},
],
value="season",
multi=False,
),
dcc.Graph(id="nyiso-scatter"),
]
),
width=4,
),
]
),
]
)
@app.callback(
dash.dependencies.Output("nyiso-content", "children"),
[dash.dependencies.Input("nyiso-button", "value")],
)
@app.callback(
dash.dependencies.Output("nyiso-graph", "figure"),
[dash.dependencies.Input("nyiso-dropdown", "value")],
)
def plot_nyiso_load_(value):
fig = go.Figure()
if "Actual" in value:
fig.add_trace(
go.Scatter(
x=load["NYISO"].index,
y=load["NYISO"].values,
name="Actual Load",
line=dict(color="maroon", width=3),
)
)
if "Predicted" in value:
fig.add_trace(
go.Scatter(
x=predictions["NYISO"].index,
y=predictions["NYISO"].values,
name="Forecasted Load",
line=dict(color="darkturquoise", width=3, dash="dash"),
)
)
return fig.update_layout(
title="System Load: Actual vs. Predicted",
xaxis_title="Date",
yaxis_title="Load (MW)",
template=TEMPLATE,
)
@app.callback(
dash.dependencies.Output("nyiso-scatter", "figure"),
[dash.dependencies.Input("nyiso-scatter-dropdown", "value")],
)
def nyiso_scatter_plot(value):
fig = px.scatter(peak_data["NYISO"], x="load_MW", y="temperature", color=value)
return fig.update_layout(template=TEMPLATE, title="Peak Load vs. Temperature")
app_name = os.getenv("APP_NAME", "dash-peaky-finders")
"""PJM LAYOUT"""
pjm_layout = html.Div(
[
html.Div(id="pjm-content"),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
dcc.Link(
html.Button("HOME", id="home-button", className="mr-1"),
href=f"/{app_name}/",
),
dcc.Link(
html.Button(
"CAISO", id="caiso-button", className="mr-1"
),
href=f"/{app_name}/caiso",
),
dcc.Link(
html.Button("MISO", id="miso-button", className="mr-1"),
href=f"/{app_name}/miso",
),
dcc.Link(
html.Button("PJM", id="pjm-button", className="mr-1"),
href=f"/{app_name}/pjm",
),
dcc.Link(
html.Button(
"NYISO", id="nyiso-button", className="mr-1"
),
href=f"/{app_name}/nyiso",
),
dcc.Link(
html.Button(
"ISONE", id="isone-button", className="mr-1"
),
href=f"/{app_name}/isone",
),
]
),
width=4,
),
dbc.Col(width=7),
],
justify="center",
),
html.Br(),
html.Br(),
dbc.Row(
[
dbc.Col(
html.H1("Pennsylvania, Jersey, Maryland Power Pool (PJM)"), width=9
),
dbc.Col(width=2),
],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""
"PJM is a regional transmission organization (RTO) that coordinates the
movement of wholesale electricity in all or parts of 13 states and
the District of Columbia." For more information, visit https://www.pjm.com.
"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[dbc.Col(html.H3("Model Performance"), width=9), dbc.Col(width=2),],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""Mean Absolute Error (MAE) for February, 2021: 2,886.66 (not great)"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[
dbc.Col(
dcc.Dropdown(
id="pjm-dropdown",
options=[
{"label": "Actual", "value": "Actual"},
{"label": "Predicted", "value": "Predicted"},
],
value=["Actual", "Predicted"],
multi=True,
),
width=6,
),
dbc.Col(width=5),
],
justify="center",
),
dcc.Graph(id="pjm-graph"),
html.Br(),
html.Br(),
dbc.Row(
[dbc.Col(html.H3("Training Data"), width=9), dbc.Col(width=2)],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""
The PJM forecasting model was trained on historical load and weather data
from 2018-2021. Temperature readings are from Philadelphia.
"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
dcc.Graph(
figure=px.histogram(
peak_data["PJM"],
x=peak_data["PJM"]["load_MW"],
nbins=75,
marginal="rug",
title=f"Distribution of PJM Daily Peaks",
color_discrete_sequence=["darkturquoise"],
).update_layout(
template=TEMPLATE,
xaxis_title="Peak Load (MW)",
yaxis_title="Number of Days",
)
),
]
),
width=4,
),
dbc.Col(
html.Div(
[
dcc.Graph(
figure=go.Figure()
.add_trace(
go.Scatter(
x=load_duration_curves["PJM"]
.reset_index()
.index,
y=load_duration_curves["PJM"].values,
mode="lines",
fill="tozeroy",
line=dict(color="maroon", width=3),
)
)
.update_layout(
title="Peak Load Sorted by Day (Highest to Lowest)",
xaxis_title="Number of Days",
yaxis_title="Load (MW)",
template=TEMPLATE,
),
),
]
),
width=4,
),
dbc.Col(
html.Div(
[
dcc.Dropdown(
id="pjm-scatter-dropdown",
options=[
{"label": "Day of Week", "value": "weekday"},
{"label": "Season", "value": "season"},
],
value="season",
multi=False,
),
dcc.Graph(id="pjm-scatter"),
]
),
width=4,
),
]
),
]
)
@app.callback(
dash.dependencies.Output("pjm-content", "children"),
[dash.dependencies.Input("pjm-button", "value")],
)
@app.callback(
dash.dependencies.Output("pjm-graph", "figure"),
[dash.dependencies.Input("pjm-dropdown", "value")],
)
def plot_pjm_load_(value):
fig = go.Figure()
if "Actual" in value:
fig.add_trace(
go.Scatter(
x=load["PJM"].index,
y=load["PJM"].values,
name="Actual Load",
line=dict(color="maroon", width=3),
)
)
if "Predicted" in value:
fig.add_trace(
go.Scatter(
x=predictions["PJM"].index,
y=predictions["PJM"].values,
name="Forecasted Load",
line=dict(color="darkturquoise", width=3, dash="dash"),
)
)
return fig.update_layout(
title="System Load: Actual vs. Predicted",
xaxis_title="Date",
yaxis_title="Load (MW)",
template=TEMPLATE,
)
@app.callback(
dash.dependencies.Output("pjm-scatter", "figure"),
[dash.dependencies.Input("pjm-scatter-dropdown", "value")],
)
def pjm_scatter_plot(value):
fig = px.scatter(peak_data["PJM"], x="load_MW", y="temperature", color=value)
return fig.update_layout(template=TEMPLATE, title="Peak Load vs. Temperature")
"""MISO LAYOUT"""
miso_layout = html.Div(
[
html.Div(id="miso-content"),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
dcc.Link(
html.Button("HOME", id="home-button", className="mr-1"),
href=f"/{app_name}/",
),
dcc.Link(
html.Button(
"CAISO", id="caiso-button", className="mr-1"
),
href=f"/{app_name}/caiso",
),
dcc.Link(
html.Button("MISO", id="miso-button", className="mr-1"),
href=f"/{app_name}/miso",
),
dcc.Link(
html.Button("PJM", id="pjm-button", className="mr-1"),
href=f"/{app_name}/pjm",
),
dcc.Link(
html.Button(
"NYISO", id="nyiso-button", className="mr-1"
),
href=f"/{app_name}/nyiso",
),
dcc.Link(
html.Button(
"ISONE", id="isone-button", className="mr-1"
),
href=f"/{app_name}/isone",
),
]
),
width=4,
),
dbc.Col(width=7),
],
justify="center",
),
html.Br(),
html.Br(),
dbc.Row(
[
dbc.Col(
html.H1("Midcontinent Independent System Operator (MISO)"), width=9
),
dbc.Col(width=2),
],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""
"Midcontinent Independent System Operator (MISO) is an independent,
not-for-profit organization that delivers safe, cost-effective
electric power across 15 U.S. states and the Canadian province of
Manitoba." For more information,
visit www.misoenergy.org.
"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[dbc.Col(html.H3("Model Performance"), width=9), dbc.Col(width=2),],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""Mean Absolute Error (MAE) for February, 2021: 2382.66 (not great)"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[
dbc.Col(
dcc.Dropdown(
id="miso-dropdown",
options=[
{"label": "Actual", "value": "Actual"},
{"label": "Predicted", "value": "Predicted"},
],
value=["Actual", "Predicted"],
multi=True,
),
width=6,
),
dbc.Col(width=5),
],
justify="center",
),
dcc.Graph(id="miso-graph"),
html.Br(),
html.Br(),
dbc.Row(
[dbc.Col(html.H3("Training Data"), width=9), dbc.Col(width=2)],
justify="center",
),
dbc.Row(
[
dbc.Col(
html.Div(
children="""
The MISO forecasting model was trained on historical load and weather data
from 2018-2021. Temperature readings are from Minneapolis.
"""
),
width=9,
),
dbc.Col(width=2),
],
justify="center",
),
html.Br(),
dbc.Row(
[
dbc.Col(
html.Div(
[
dcc.Graph(
figure=px.histogram(
peak_data["MISO"],
x=peak_data["MISO"]["load_MW"],
nbins=75,
marginal="rug",
title=f"Distribution of MISO Daily Peaks",
color_discrete_sequence=["darkturquoise"],
).update_layout(
template=TEMPLATE,
xaxis_title="Peak Load (MW)",
yaxis_title="Number of Days",
)
),
]
),
width=4,
),
dbc.Col(
html.Div(
[
dcc.Graph(
figure=go.Figure()
.add_trace(
go.Scatter(
x=load_duration_curves["MISO"]
.reset_index()
.index,
y=load_duration_curves["MISO"].values,
mode="lines",
fill="tozeroy",
line=dict(color="maroon", width=3),
)
)
.update_layout(
title="Peak Load Sorted by Day (Highest to Lowest)",
xaxis_title="Number of Days",
yaxis_title="Load (MW)",
template=TEMPLATE,
),
),
]
),
width=4,
),
dbc.Col(
html.Div(
[
dcc.Dropdown(
id="miso-scatter-dropdown",
| |
<reponame>victorfica/utils<filename>myboxplot.py<gh_stars>0
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from numpy.random import permutation, seed
import pandas as pd
import seaborn as sns
from itertools import cycle
from vectools import untangle
try:
import numba as nb
from bootstrap_nb import bootci_nb
NUMBA = True
@nb.njit()
def _keepdims_mean(dat):
return np.array([np.mean(dat[:, 0])])
except ImportError:
from scikits.bootstrap import ci
NUMBA = False
__all__ = ['scatterdots',
'myboxplot',
'manyboxplots',
'swarmbox',
'discrete_boxplot']
def scatterdots(data, x, axh=None, width=0.8, returnx=False, rseed=820, **kwargs):
"""Dots plotted with random x-coordinates and y-coordinates from data array.
Parameters
----------
data : ndarray
x : float
Specifies the center of the dot cloud on the x-axis.
axh : matplotlib figure handle
If None then use plt.gca()
width : float
Specifies the range of the dots along the x-axis.
returnx : bool
If True, return the x-coordinates of the plotted data points.
rseed : float
Random seed. Defaults to a constant so that regenerated figures of
the same data are identical.
Returns
-------
Optionally returns the x-coordinates as plotted."""
if axh is None:
axh = plt.gca()
np.random.seed(rseed)
if data is None or len(data) == 0:
if returnx:
return None
return
if not isinstance(data, np.ndarray):
data = np.array(data)
validi = np.arange(len(data))
if any(np.isnan(data)):
validi = np.where(np.logical_not(np.isnan(data)))[0]
ploty = data[validi]
if len(ploty) == 0:
if returnx:
return None
return
w = width
plotx = np.random.permutation(np.linspace(-w/2., w/2., len(ploty)) + x)
axh.scatter(plotx, ploty, **kwargs)
if returnx:
outx = np.nan * np.ones(data.shape)
outx[validi] = plotx
return outx
def myboxplot(data, x = 1, axh=None, width=0.8, boxcolor='black',scatterwidth=0.6,dotcolor='red',returnx=False,subsetInd=None,altDotcolor='gray',violin=False,**kwargs):
"""Make a boxplot with scatterdots overlaid.
Parameters
----------
data : np.ndarray or pd.Series
x : float
Position of box along x-axis.
axh : matplotlib figure handle
If None then use plt.gca()
width : float
Width of the box.
boxcolor : mpl color
scatterwidth : float
Width of the spread of the data points.
dotcolor : mpl color
subsetInd : boolean or int index
Indicates a subset of the data that should be summarized in the boxplot.
However, all data points will be plotted.
altDotcolor : mpl color
Specify the color of the data points that are not in the subset.
returnx : bool
Return the x-coordinates of the data points.
violin : bool
Specify whether the box is a violin plot.
Returns
-------
outx : np.ndarray
Optionall, an array of the x-coordinates as plotted."""
if axh is None:
axh = plt.gca()
if isinstance(data, pd.Series):
data = data.values
if not subsetInd is None:
if not (subsetInd.dtype == np.array([0, 1], dtype=bool).dtype):
tmp = np.zeros(data.shape, dtype=bool)
tmp[subsetInd] = True
subsetInd = tmp
else:
subsetInd = np.ones(data.shape, dtype=bool)
subsetInd = np.asarray(subsetInd)
if not 's' in kwargs:
kwargs['s'] = 20
if not 'marker' in kwargs:
kwargs['marker'] = 'o'
if not 'linewidths' in kwargs:
kwargs['linewidths'] = 0.5
"""Boxplot with dots overlaid"""
outx = np.zeros(data.shape)
if subsetInd.sum() > 0:
if not boxcolor == 'none' and not boxcolor is None:
if violin and False:
sns.violinplot(data[subsetInd], color = boxcolor, positions = [x], alpha = 0.5)
else:
bp = axh.boxplot(data[subsetInd], positions = [x], widths = width, sym = '')
for element in list(bp.keys()):
for b in bp[element]:
b.set_color(boxcolor)
kwargs['c'] = dotcolor
subsetx = scatterdots(data[subsetInd], x = x, axh = axh, width = scatterwidth, returnx = True, **kwargs)
outx[subsetInd] = subsetx
if (~subsetInd).sum() > 0:
kwargs['c'] = altDotcolor
subsetx = scatterdots(data[~subsetInd], x = x, axh = axh, width = scatterwidth, returnx = True, **kwargs)
outx[~subsetInd] = subsetx
if returnx:
return outx
def manyboxplots(df, cols=None, axh=None, colLabels=None,annotation='N',horizontal=False,vRange=None,xRot=0, **kwargs):
"""Series of boxplots along x-axis (or flipped horizontally along y-axis [NOT IMPLEMENTED])
WORK IN PROGRESS
Optionally add annotation for each boxplot with:
(1) "N"
(2) "pctpos" (response rate, by additionally specifying responders)
NOT YET IMPLEMENTED
Parameters
----------
df : pd.DataFrame
cols : list
Column names to be plotted
axh : matplotlib figure handle
If None then use plt.gca()
colLabels : list
Column labels (optional)
annotation : str or None
Specifies what the annotation should be: "N" or "pctpos"
horizontal : bool
Specifies whether boxplots should be vertical (default, False) or horizontal (True)
kwargs : additional arguments
Passed to myboxplot function to specify colors etc."""
if axh is None:
axh = plt.gca()
if cols is None:
cols = df.columns
if colLabels is None:
colLabels = cols
elif len(colLabels)<cols:
colLabels += cols[len(colLabels):]
for x, c in enumerate(cols):
myboxplot(df[c].dropna(), x = x, axh = axh, **kwargs)
if not vRange is None:
plt.ylim(vRange)
yl = plt.ylim()
annotationKwargs = dict(xytext = (0, -10), textcoords = 'offset points', ha = 'center', va = 'top', size = 'medium')
for x, c in enumerate(cols):
tmp = df[c].dropna()
if annotation == 'N':
plt.annotate('%d' % len(tmp), xy = (x, yl[1]), **annotationKwargs)
elif annotation == 'pctpos':
pass
plt.xlim((-1, x+1))
plt.xticks(np.arange(x+1))
xlabelsL = axh.set_xticklabels(colLabels, fontsize='large', rotation=xRot, fontname='Consolas')
def swarmbox(x, y, data, hue=None, palette=None, order=None, hue_order=None, connect=False, connect_on=[], legend_loc=0, legend_bbox=None, swarm_alpha=1, swarm_size=5, box_alpha=1, box_edgecolor='k', box_facewhite=False):
"""Based on seaborn boxplots and swarmplots.
Adds the option to connect dots by joining on an identifier columns"""
if palette is None and not hue is None:
palette = sns.color_palette('Set2', n_colors=data[hue].unique().shape[0])
if hue_order is None and not hue is None:
hue_order = sorted(data[hue].unique())
if order is None:
order = sorted(data[x].unique())
params = dict(data=data, x=x, y=y, hue=hue, order=order, hue_order=hue_order)
box_axh = sns.boxplot(**params,
fliersize=0,
linewidth=1,
palette=palette)
for patch in box_axh.artists:
patch.set_edgecolor((0, 0, 0, 1))
r, g, b, a = patch.get_facecolor()
if box_facewhite:
patch.set_facecolor((1, 1, 1, 1))
else:
patch.set_facecolor((r, g, b, box_alpha))
for line in box_axh.lines:
line.set_color(box_edgecolor)
swarm = sns.swarmplot(**params,
linewidth=0.5,
edgecolor='black',
dodge=True,
alpha=swarm_alpha,
size=swarm_size,
palette=palette)
if connect and not hue is None:
for i in range(len(hue_order) - 1):
"""Loop over pairs of hues (i.e. grouped boxes)"""
curHues = hue_order[i:i+2]
"""Pull out just the swarm collections that are needed"""
zipper = [order] + [swarm.collections[i::len(hue_order)], swarm.collections[i+1::len(hue_order)]]
for curx, cA, cB in zip(*zipper):
"""Loop over the x positions (i.e. outer groups)"""
indA = (data[x] == curx) & (data[hue] == curHues[0])
indB = (data[x] == curx) & (data[hue] == curHues[1])
"""Locate the data and match it up with the points plotted for each hue"""
tmpA = data[[x, hue, y] + connect_on].loc[indA].dropna()
tmpB = data[[x, hue, y] + connect_on].loc[indB].dropna()
plottedA = cA.get_offsets() # shaped (n_elements x 2)
plottedB = cB.get_offsets()
"""Merge the data from each hue, including the new detangled x coords,
based on what was plotted"""
tmpA.loc[:, '_untangi'] = untangle(tmpA[y].values, plottedA[:, 1])
tmpB.loc[:, '_untangi'] = untangle(tmpB[y].values, plottedB[:, 1])
tmpA.loc[:, '_newx'] = plottedA[:, 0][tmpA['_untangi'].values]
tmpB.loc[:, '_newx'] = plottedB[:, 0][tmpB['_untangi'].values]
"""Using 'inner' drops the data points that are in one hue grouping and not the other"""
tmp = pd.merge(tmpA, tmpB, left_on=connect_on, right_on=connect_on, suffixes=('_A', '_B'), how='inner')
"""Plot them one by one"""
for rind, r in tmp.iterrows():
plt.plot(r[['_newx_A', '_newx_B']],
r[[y + '_A', y + '_B']],
'-', color='gray', linewidth=0.5)
if not hue is None and not legend_loc is None:
plt.legend([plt.Circle(1, color=c, alpha=1) for c in palette], hue_order, title=hue, loc=legend_loc, bbox_to_anchor=legend_bbox)
if legend_loc is None:
plt.gca().legend_.remove()
def _xspacing(v, mxWidth=0.3, idealNumPoints=4):
xlim = min(mxWidth, (len(v)/idealNumPoints)*mxWidth/2)
x = np.linspace(-xlim, xlim, len(v))
x = np.random.permutation(x)
"""Use v*0 so that it has the right labels for apply"""
return v*0 + x
def _yjitter(v, jitter=0.3):
y = np.linspace(-jitter/2, jitter/2, len(v))
y = np.random.permutation(y)
return y + v
def discrete_boxplot(x, y, hue, data, yjitter=0.3, palette=None, order=None, hue_order=None, IQR=True, mean_df=None, pvalue_df=None):
if order is None:
order = data[x].unique()
if len(order) == 1:
xspacing = 2
else:
xspacing = 1
if hue_order is None:
hue_order = data[hue].unique()
if palette is None:
palette = [c for i,c in zip(range(len(hue_order)), cycle(mpl.cm.Set1.colors))]
yl = (data[y].min() - 0.5, data[y].max() + 0.5)
plotx = 0
xt = []
xtl = []
for xval in order:
xcoords = []
xcoords_labels = {}
for hueval, color in zip(hue_order, palette):
tmp = data.loc[(data[hue] == hueval) & (data[x] == xval), y]
if mean_df is None:
if IQR:
lcl, mu, ucl = np.percentile(tmp.values, [25, 50, 75])
else:
if NUMBA:
"""bootci_nb requires a 2D matrix and will operate along rows. statfunction needs to return a vector"""
mu, lcl, ucl = bootci_nb(tmp.values[:, None], statfunction=_keepdims_mean, alpha=0.05, n_samples=10000, method='bca').ravel()
| |
m.b1108 <= 0)
m.e1739 = Constraint(expr= -m.b1098 + m.b1108 <= 0)
m.e1740 = Constraint(expr= -m.b1099 + m.b1108 <= 0)
m.e1741 = Constraint(expr= -m.b1098 + m.b1109 <= 0)
m.e1742 = Constraint(expr= -m.b1099 + m.b1109 <= 0)
m.e1743 = Constraint(expr= -m.b1100 + m.b1109 <= 0)
m.e1744 = Constraint(expr= -m.b1097 + m.b1110 <= 0)
m.e1745 = Constraint(expr= -m.b1099 + m.b1110 <= 0)
m.e1746 = Constraint(expr= -m.b1100 + m.b1110 <= 0)
m.e1747 = Constraint(expr= -m.b1097 + m.b1111 <= 0)
m.e1748 = Constraint(expr= -m.b1098 + m.b1111 <= 0)
m.e1749 = Constraint(expr= -m.b1100 + m.b1111 <= 0)
m.e1750 = Constraint(expr= -m.b1097 + m.b1112 <= 0)
m.e1751 = Constraint(expr= -m.b1098 + m.b1112 <= 0)
m.e1752 = Constraint(expr= -m.b1099 + m.b1112 <= 0)
m.e1753 = Constraint(expr= -m.b1114 + m.b1117 <= 0)
m.e1754 = Constraint(expr= -m.b1115 + m.b1117 <= 0)
m.e1755 = Constraint(expr= -m.b1116 + m.b1117 <= 0)
m.e1756 = Constraint(expr= -m.b1113 + m.b1118 <= 0)
m.e1757 = Constraint(expr= -m.b1115 + m.b1118 <= 0)
m.e1758 = Constraint(expr= -m.b1116 + m.b1118 <= 0)
m.e1759 = Constraint(expr= -m.b1113 + m.b1119 <= 0)
m.e1760 = Constraint(expr= -m.b1114 + m.b1119 <= 0)
m.e1761 = Constraint(expr= -m.b1116 + m.b1119 <= 0)
m.e1762 = Constraint(expr= -m.b1113 + m.b1120 <= 0)
m.e1763 = Constraint(expr= -m.b1114 + m.b1120 <= 0)
m.e1764 = Constraint(expr= -m.b1115 + m.b1120 <= 0)
m.e1765 = Constraint(expr= -m.b1114 + m.b1121 <= 0)
m.e1766 = Constraint(expr= -m.b1115 + m.b1121 <= 0)
m.e1767 = Constraint(expr= -m.b1116 + m.b1121 <= 0)
m.e1768 = Constraint(expr= -m.b1113 + m.b1122 <= 0)
m.e1769 = Constraint(expr= -m.b1115 + m.b1122 <= 0)
m.e1770 = Constraint(expr= -m.b1116 + m.b1122 <= 0)
m.e1771 = Constraint(expr= -m.b1113 + m.b1123 <= 0)
m.e1772 = Constraint(expr= -m.b1114 + m.b1123 <= 0)
m.e1773 = Constraint(expr= -m.b1116 + m.b1123 <= 0)
m.e1774 = Constraint(expr= -m.b1113 + m.b1124 <= 0)
m.e1775 = Constraint(expr= -m.b1114 + m.b1124 <= 0)
m.e1776 = Constraint(expr= -m.b1115 + m.b1124 <= 0)
m.e1777 = Constraint(expr= -m.b1114 + m.b1125 <= 0)
m.e1778 = Constraint(expr= -m.b1115 + m.b1125 <= 0)
m.e1779 = Constraint(expr= -m.b1116 + m.b1125 <= 0)
m.e1780 = Constraint(expr= -m.b1113 + m.b1126 <= 0)
m.e1781 = Constraint(expr= -m.b1115 + m.b1126 <= 0)
m.e1782 = Constraint(expr= -m.b1116 + m.b1126 <= 0)
m.e1783 = Constraint(expr= -m.b1113 + m.b1127 <= 0)
m.e1784 = Constraint(expr= -m.b1114 + m.b1127 <= 0)
m.e1785 = Constraint(expr= -m.b1116 + m.b1127 <= 0)
m.e1786 = Constraint(expr= -m.b1113 + m.b1128 <= 0)
m.e1787 = Constraint(expr= -m.b1114 + m.b1128 <= 0)
m.e1788 = Constraint(expr= -m.b1115 + m.b1128 <= 0)
m.e1789 = Constraint(expr= -m.b1130 + m.b1133 <= 0)
m.e1790 = Constraint(expr= -m.b1131 + m.b1133 <= 0)
m.e1791 = Constraint(expr= -m.b1132 + m.b1133 <= 0)
m.e1792 = Constraint(expr= -m.b1129 + m.b1134 <= 0)
m.e1793 = Constraint(expr= -m.b1131 + m.b1134 <= 0)
m.e1794 = Constraint(expr= -m.b1132 + m.b1134 <= 0)
m.e1795 = Constraint(expr= -m.b1129 + m.b1135 <= 0)
m.e1796 = Constraint(expr= -m.b1130 + m.b1135 <= 0)
m.e1797 = Constraint(expr= -m.b1132 + m.b1135 <= 0)
m.e1798 = Constraint(expr= -m.b1129 + m.b1136 <= 0)
m.e1799 = Constraint(expr= -m.b1130 + m.b1136 <= 0)
m.e1800 = Constraint(expr= -m.b1131 + m.b1136 <= 0)
m.e1801 = Constraint(expr= -m.b1130 + m.b1137 <= 0)
m.e1802 = Constraint(expr= -m.b1131 + m.b1137 <= 0)
m.e1803 = Constraint(expr= -m.b1132 + m.b1137 <= 0)
m.e1804 = Constraint(expr= -m.b1129 + m.b1138 <= 0)
m.e1805 = Constraint(expr= -m.b1131 + m.b1138 <= 0)
m.e1806 = Constraint(expr= -m.b1132 + m.b1138 <= 0)
m.e1807 = Constraint(expr= -m.b1129 + m.b1139 <= 0)
m.e1808 = Constraint(expr= -m.b1130 + m.b1139 <= 0)
m.e1809 = Constraint(expr= -m.b1132 + m.b1139 <= 0)
m.e1810 = Constraint(expr= -m.b1129 + m.b1140 <= 0)
m.e1811 = Constraint(expr= -m.b1130 + m.b1140 <= 0)
m.e1812 = Constraint(expr= -m.b1131 + m.b1140 <= 0)
m.e1813 = Constraint(expr= -m.b1130 + m.b1141 <= 0)
m.e1814 = Constraint(expr= -m.b1131 + m.b1141 <= 0)
m.e1815 = Constraint(expr= -m.b1132 + m.b1141 <= 0)
m.e1816 = Constraint(expr= -m.b1129 + m.b1142 <= 0)
m.e1817 = Constraint(expr= -m.b1131 + m.b1142 <= 0)
m.e1818 = Constraint(expr= -m.b1132 + m.b1142 <= 0)
m.e1819 = Constraint(expr= -m.b1129 + m.b1143 <= 0)
m.e1820 = Constraint(expr= -m.b1130 + m.b1143 <= 0)
m.e1821 = Constraint(expr= -m.b1132 + m.b1143 <= 0)
m.e1822 = Constraint(expr= -m.b1129 + m.b1144 <= 0)
m.e1823 = Constraint(expr= -m.b1130 + m.b1144 <= 0)
m.e1824 = Constraint(expr= -m.b1131 + m.b1144 <= 0)
m.e1825 = Constraint(expr= -m.b1146 + m.b1149 <= 0)
m.e1826 = Constraint(expr= -m.b1147 + m.b1149 <= 0)
m.e1827 = Constraint(expr= -m.b1148 + m.b1149 <= 0)
m.e1828 = Constraint(expr= -m.b1145 + m.b1150 <= 0)
m.e1829 = Constraint(expr= -m.b1147 + m.b1150 <= 0)
m.e1830 = Constraint(expr= -m.b1148 + m.b1150 <= 0)
m.e1831 = Constraint(expr= -m.b1145 + m.b1151 <= 0)
m.e1832 = Constraint(expr= -m.b1146 + m.b1151 <= 0)
m.e1833 = Constraint(expr= -m.b1148 + m.b1151 <= 0)
m.e1834 = Constraint(expr= -m.b1145 + m.b1152 <= 0)
m.e1835 = Constraint(expr= -m.b1146 + m.b1152 <= 0)
m.e1836 = Constraint(expr= -m.b1147 + m.b1152 <= 0)
m.e1837 = Constraint(expr= -m.b1146 + m.b1153 <= 0)
m.e1838 = Constraint(expr= -m.b1147 + m.b1153 <= 0)
m.e1839 = Constraint(expr= -m.b1148 + m.b1153 <= 0)
m.e1840 = Constraint(expr= -m.b1145 + m.b1154 <= 0)
m.e1841 = Constraint(expr= -m.b1147 + m.b1154 <= 0)
m.e1842 = Constraint(expr= -m.b1148 + m.b1154 <= 0)
m.e1843 = Constraint(expr= -m.b1145 + m.b1155 <= 0)
m.e1844 = Constraint(expr= -m.b1146 + m.b1155 <= 0)
m.e1845 = Constraint(expr= -m.b1148 + m.b1155 <= 0)
m.e1846 = Constraint(expr= -m.b1145 + m.b1156 <= 0)
m.e1847 = Constraint(expr= -m.b1146 + m.b1156 <= 0)
m.e1848 = Constraint(expr= -m.b1147 + m.b1156 <= 0)
m.e1849 = Constraint(expr= -m.b1146 + m.b1157 <= 0)
m.e1850 = Constraint(expr= -m.b1147 + m.b1157 <= 0)
m.e1851 = Constraint(expr= -m.b1148 + m.b1157 <= 0)
m.e1852 = Constraint(expr= -m.b1145 + m.b1158 <= 0)
m.e1853 = Constraint(expr= -m.b1147 + m.b1158 <= 0)
m.e1854 = Constraint(expr= -m.b1148 + m.b1158 <= 0)
m.e1855 = Constraint(expr= -m.b1145 + m.b1159 <= 0)
m.e1856 = Constraint(expr= -m.b1146 + m.b1159 <= 0)
m.e1857 = Constraint(expr= -m.b1148 + m.b1159 <= 0)
m.e1858 = Constraint(expr= -m.b1145 + m.b1160 <= 0)
m.e1859 = Constraint(expr= -m.b1146 + m.b1160 <= 0)
m.e1860 = Constraint(expr= -m.b1147 + m.b1160 <= 0)
m.e1861 = Constraint(expr= -m.b1162 + m.b1165 <= 0)
m.e1862 = Constraint(expr= -m.b1163 + m.b1165 <= 0)
m.e1863 = Constraint(expr= -m.b1164 + m.b1165 <= 0)
m.e1864 = Constraint(expr= -m.b1161 + m.b1166 <= 0)
m.e1865 = Constraint(expr= -m.b1163 + m.b1166 <= 0)
m.e1866 = Constraint(expr= -m.b1164 + m.b1166 <= 0)
m.e1867 = Constraint(expr= -m.b1161 + m.b1167 <= 0)
m.e1868 = Constraint(expr= -m.b1162 + m.b1167 <= 0)
m.e1869 = Constraint(expr= -m.b1164 + m.b1167 <= 0)
m.e1870 = Constraint(expr= -m.b1161 + m.b1168 <= 0)
m.e1871 = Constraint(expr= -m.b1162 + m.b1168 <= 0)
m.e1872 = Constraint(expr= -m.b1163 + m.b1168 <= 0)
m.e1873 = Constraint(expr= -m.b1162 + m.b1169 <= 0)
m.e1874 = Constraint(expr= -m.b1163 + m.b1169 <= 0)
m.e1875 = Constraint(expr= -m.b1164 + m.b1169 <= 0)
m.e1876 = Constraint(expr= -m.b1161 + m.b1170 <= 0)
m.e1877 = Constraint(expr= -m.b1163 + m.b1170 <= 0)
m.e1878 = Constraint(expr= -m.b1164 + m.b1170 <= 0)
m.e1879 = Constraint(expr= -m.b1161 + m.b1171 <= 0)
m.e1880 = Constraint(expr= -m.b1162 + m.b1171 <= 0)
m.e1881 = Constraint(expr= -m.b1164 + m.b1171 <= 0)
m.e1882 = Constraint(expr= -m.b1161 + m.b1172 <= 0)
m.e1883 = Constraint(expr= -m.b1162 + m.b1172 <= 0)
m.e1884 = Constraint(expr= -m.b1163 + m.b1172 <= 0)
m.e1885 = Constraint(expr= -m.b1162 + m.b1173 <= 0)
m.e1886 = Constraint(expr= -m.b1163 + m.b1173 <= 0)
m.e1887 = Constraint(expr= -m.b1164 + m.b1173 <= 0)
m.e1888 = Constraint(expr= -m.b1161 + m.b1174 <= 0)
m.e1889 = Constraint(expr= -m.b1163 + m.b1174 <= 0)
m.e1890 = Constraint(expr= -m.b1164 + m.b1174 <= 0)
m.e1891 = Constraint(expr= -m.b1161 + m.b1175 <= 0)
m.e1892 = Constraint(expr= -m.b1162 + m.b1175 <= 0)
m.e1893 = Constraint(expr= -m.b1164 + m.b1175 <= 0)
m.e1894 = Constraint(expr= -m.b1161 + m.b1176 <= 0)
m.e1895 = Constraint(expr= -m.b1162 + m.b1176 <= 0)
m.e1896 = Constraint(expr= -m.b1163 + m.b1176 <= 0)
m.e1897 = Constraint(expr= -m.b1178 + m.b1181 <= 0)
m.e1898 = Constraint(expr= -m.b1179 + m.b1181 <= 0)
m.e1899 = Constraint(expr= -m.b1180 + m.b1181 <= 0)
m.e1900 = Constraint(expr= -m.b1177 + m.b1182 <= 0)
m.e1901 = Constraint(expr= -m.b1179 + m.b1182 <= 0)
m.e1902 = Constraint(expr= -m.b1180 + m.b1182 <= 0)
m.e1903 = Constraint(expr= -m.b1177 + m.b1183 <= 0)
m.e1904 = Constraint(expr= -m.b1178 + m.b1183 <= 0)
m.e1905 = Constraint(expr= -m.b1180 + m.b1183 <= 0)
m.e1906 = Constraint(expr= -m.b1177 + m.b1184 <= 0)
m.e1907 = Constraint(expr= -m.b1178 + m.b1184 <= 0)
m.e1908 = Constraint(expr= -m.b1179 + m.b1184 <= 0)
m.e1909 = Constraint(expr= -m.b1178 + m.b1185 <= 0)
m.e1910 = Constraint(expr= -m.b1179 + m.b1185 <= 0)
m.e1911 = Constraint(expr= -m.b1180 + m.b1185 <= 0)
m.e1912 = Constraint(expr= -m.b1177 + m.b1186 <= 0)
m.e1913 = Constraint(expr= -m.b1179 + m.b1186 <= 0)
m.e1914 = Constraint(expr= -m.b1180 + m.b1186 <= 0)
m.e1915 = Constraint(expr= -m.b1177 + m.b1187 <= 0)
m.e1916 = Constraint(expr= -m.b1178 + m.b1187 <= 0)
m.e1917 = Constraint(expr= -m.b1180 + m.b1187 <= 0)
m.e1918 = Constraint(expr= -m.b1177 + m.b1188 <= 0)
m.e1919 = Constraint(expr= -m.b1178 + m.b1188 <= 0)
m.e1920 = Constraint(expr= -m.b1179 + m.b1188 <= 0)
m.e1921 = Constraint(expr= -m.b1178 | |
default=-1)
return retval
@property
def hsrp_priority(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
if not self.has_ip_hsrp:
return 0 # Return this if there is no hsrp on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*priority\s+(\d+)',
group=2, result_type=int, default=100)
return retval
@property
def hsrp_hello_timer(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*timers\s+(\d+)\s+\d+',
group=2, result_type=int, default=0)
return retval
@property
def hsrp_hold_timer(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*timers\s+\d+\s+(\d+)',
group=2, result_type=int, default=0)
return retval
@property
def has_hsrp_track(self):
return bool(self.hsrp_track)
@property
def hsrp_track(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*track\s(\S+.+?)\s+\d+\s*',
group=2, result_type=str, default='')
return retval
@property
def has_hsrp_usebia(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*(use-bia)',
group=2, result_type=bool, default=False)
return retval
@property
def has_hsrp_preempt(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*(use-bia)',
group=2, result_type=bool, default=False)
return retval
@property
def hsrp_authentication_md5_keychain(self):
## For API simplicity, I always assume there is only one hsrp
## group on the interface
retval = self.re_match_iter_typed(r'^\s*standby\s+(\d+\s+)*authentication\s+md5\s+key-chain\s+(\S+)',
group=2, result_type=str, default='')
return retval
@property
def has_hsrp_authentication_md5(self):
keychain = self.hsrp_authentication_md5_keychain
return bool(keychain)
@property
def hsrp_authentication_cleartext(self):
pass
##------------- MAC ACLs
@property
def has_mac_accessgroup_in(self):
if not self.is_switchport:
return False
return bool(self.mac_accessgroup_in)
@property
def has_mac_accessgroup_out(self):
if not self.is_switchport:
return False
return bool(self.mac_accessgroup_out)
@property
def mac_accessgroup_in(self):
retval = self.re_match_iter_typed(r'^\s*mac\saccess-group\s+(\S+)\s+in\s*$',
result_type=str, default='')
return retval
@property
def mac_accessgroup_out(self):
retval = self.re_match_iter_typed(r'^\s*mac\saccess-group\s+(\S+)\s+out\s*$',
result_type=str, default='')
return retval
##------------- IPv4 ACLs
@property
def has_ip_accessgroup_in(self):
return bool(self.ipv4_accessgroup_in)
@property
def has_ip_accessgroup_out(self):
return bool(self.ipv4_accessgroup_out)
@property
def has_ipv4_accessgroup_in(self):
return bool(self.ipv4_accessgroup_in)
@property
def has_ipv4_accessgroup_out(self):
return bool(self.ipv4_accessgroup_out)
@property
def ip_accessgroup_in(self):
return self.ipv4_accessgroup_in
@property
def ip_accessgroup_out(self):
return self.ipv4_accessgroup_out
@property
def ipv4_accessgroup_in(self):
retval = self.re_match_iter_typed(r'^\s*ip\saccess-group\s+(\S+)\s+in\s*$',
result_type=str, default='')
return retval
@property
def ipv4_accessgroup_out(self):
retval = self.re_match_iter_typed(r'^\s*ip\saccess-group\s+(\S+)\s+out\s*$',
result_type=str, default='')
return retval
##
##------------- IOS Interface Object
##
class IOSIntfLine(BaseIOSIntfLine):
def __init__(self, *args, **kwargs):
"""Accept an IOS line number and initialize family relationship
attributes
.. warning::
All :class:`~models_cisco.IOSIntfLine` methods are still considered beta-quality, until this notice is removed. The behavior of APIs on this object could change at any time.
"""
super(IOSIntfLine, self).__init__(*args, **kwargs)
@classmethod
def is_object_for(cls, line="", re=re):
intf_regex = r'^interface\s+(\S+.+)'
if re.search(intf_regex, line):
return True
return False
##
##------------- IOS Interface Globals
##
class IOSIntfGlobal(BaseCfgLine):
def __init__(self, *args, **kwargs):
super(IOSIntfGlobal, self).__init__(*args, **kwargs)
self.feature = 'interface global'
def __repr__(self):
return "<%s # %s '%s'>" % (self.classname, self.linenum,
self.text)
@classmethod
def is_object_for(cls, line="", re=re):
if re.search('^(no\s+cdp\s+run)|(logging\s+event\s+link-status\s+global)|(spanning-tree\sportfast\sdefault)|(spanning-tree\sportfast\sbpduguard\sdefault)', line):
return True
return False
@property
def has_cdp_disabled(self):
if self.re_search('^no\s+cdp\s+run\s*'):
return True
return False
@property
def has_intf_logging_def(self):
if self.re_search('^logging\s+event\s+link-status\s+global'):
return True
return False
@property
def has_stp_portfast_def(self):
if self.re_search('^spanning-tree\sportfast\sdefault'):
return True
return False
@property
def has_stp_portfast_bpduguard_def(self):
if self.re_search('^spanning-tree\sportfast\sbpduguard\sdefault'):
return True
return False
@property
def has_stp_mode_rapidpvst(self):
if self.re_search('^spanning-tree\smode\srapid-pvst'):
return True
return False
##
##------------- IOS Hostname Line
##
class IOSHostnameLine(BaseCfgLine):
def __init__(self, *args, **kwargs):
super(IOSHostnameLine, self).__init__(*args, **kwargs)
self.feature = 'hostname'
def __repr__(self):
return "<%s # %s '%s'>" % (self.classname, self.linenum,
self.hostname)
@classmethod
def is_object_for(cls, line="", re=re):
if re.search('^hostname', line):
return True
return False
@property
def hostname(self):
retval = self.re_match_typed(r'^hostname\s+(\S+)',
result_type=str, default='')
return retval
##
##------------- IOS Access Line
##
class IOSAccessLine(BaseCfgLine):
def __init__(self, *args, **kwargs):
super(IOSAccessLine, self).__init__(*args, **kwargs)
self.feature = 'access line'
def __repr__(self):
return "<%s # %s '%s' info: '%s'>" % (self.classname, self.linenum, self.name, self.range_str)
@classmethod
def is_object_for(cls, line="", re=re):
if re.search('^line', line):
return True
return False
@property
def is_accessline(self):
retval = self.re_match_typed(r'^(line\s+\S+)',
result_type=str, default='')
return bool(retval)
@property
def name(self):
retval = self.re_match_typed(r'^line\s+(\S+)',
result_type=str, default='')
# special case for IOS async lines: i.e. "line 33 48"
if re.search('\d+', retval):
return ''
return retval
def reset(self, atomic=True):
# Insert build_reset_string() before this line...
self.insert_before(self.build_reset_string(), atomic=atomic)
def build_reset_string(self):
# IOS interfaces are defaulted like this...
return "default " + self.text
@property
def range_str(self):
return ' '.join(map(str, self.line_range))
@property
def line_range(self):
## Return the access-line's numerical range as a list
## line con 0 => [0]
## line 33 48 => [33, 48]
retval = self.re_match_typed(r'([a-zA-Z]+\s+)*(\d+\s*\d*)$',
group=2, result_type=str, default='')
tmp = map(int, retval.strip().split())
return tmp
def manual_exectimeout_min(self):
tmp = self.parse_exectimeout
return tmp[0]
def manual_exectimeout_sec(self):
tmp = self.parse_exectimeout
if len(tmp>0):
return 0
return tmp[1]
@property
def parse_exectimeout(self):
retval = self.re_match_iter_typed(r'^\s*exec-timeout\s+(\d+\s*\d*)\s*$',
group=1, result_type=str, default='')
tmp = map(int, retval.strip().split())
return tmp
##
##------------- Base IOS Route line object
##
class BaseIOSRouteLine(BaseCfgLine):
def __init__(self, *args, **kwargs):
super(BaseIOSRouteLine, self).__init__(*args, **kwargs)
def __repr__(self):
return "<%s # %s '%s' info: '%s'>" % (self.classname, self.linenum, self.network_object, self.routeinfo)
@property
def routeinfo(self):
### Route information for the repr string
if self.tracking_object_name:
return self.nexthop_str+" AD: "+str(self.admin_distance)+" Track: "+self.tracking_object_name
else:
return self.nexthop_str+" AD: "+str(self.admin_distance)
@classmethod
def is_object_for(cls, line="", re=re):
return False
@property
def vrf(self):
raise NotImplementedError
@property
def address_family(self):
## ipv4, ipv6, etc
raise NotImplementedError
@property
def network(self):
raise NotImplementedError
@property
def netmask(self):
raise NotImplementedError
@property
def admin_distance(self):
raise NotImplementedError
@property
def nexthop_str(self):
raise NotImplementedError
@property
def tracking_object_name(self):
raise NotImplementedError
##
##------------- IOS Route line object
##
_RE_IP_ROUTE = re.compile(r"""^ip\s+route
(?:\s+(?:vrf\s+(?P<vrf>\S+)))? # VRF detection
\s+
(?P<prefix>\d+\.\d+\.\d+\.\d+) # Prefix detection
\s+
(?P<netmask>\d+\.\d+\.\d+\.\d+) # Netmask detection
(?:\s+(?P<nh_intf>[^\d]\S+))? # NH intf
(?:\s+(?P<nh_addr>\d+\.\d+\.\d+\.\d+))? # NH addr
(?:\s+(?P<dhcp>dhcp))? # DHCP keyword (FIXME: add unit test)
(?:\s+(?P<global>global))? # Global keyword
(?:\s+(?P<ad>\d+))? # Administrative distance
(?:\s+(?P<mcast>multicast))? # Multicast Keyword (FIXME: add unit test)
(?:\s+name\s+(?P<name>\S+))? # Route name
(?:\s+(?P<permanent>permanent))? # Permanent Keyword (exclusive of track)
(?:\s+track\s+(?P<track>\d+))? # Track object (exclusive of permanent)
(?:\s+tag\s+(?P<tag>\d+))? # Route tag
""", re.VERBOSE)
_RE_IPV6_ROUTE = re.compile(r"""^ipv6\s+route
(?:\s+vrf\s+(?P<vrf>\S+))?
(?:\s+(?P<prefix>{0})\/(?P<masklength>\d+)) # Prefix detection
(?:
(?:\s+(?P<nh_addr1>{1}))
|(?:\s+(?P<nh_intf>\S+(?:\s+\d\S*?\/\S+)?)(?:\s+(?P<nh_addr2>{2}))?)
)
(?:\s+nexthop-vrf\s+(?P<nexthop_vrf>\S+))?
(?:\s+(?P<ad>\d+))? # Administrative distance
(?:\s+(?:(?P<ucast>unicast)|(?P<mcast>multicast)))?
(?:\s+tag\s+(?P<tag>\d+))? # Route tag
""".format(_IPV6_REGEX_STR_COMPRESSED1, _IPV6_REGEX_STR_COMPRESSED2,
_IPV6_REGEX_STR_COMPRESSED3), re.VERBOSE)
class IOSRouteLine(BaseIOSRouteLine):
def __init__(self, *args, **kwargs):
super(IOSRouteLine, self).__init__(*args, **kwargs)
if 'ipv6' in self.text[0:4]:
self.feature = 'ipv6 route'
self._address_family = "ipv6"
mm = _RE_IPV6_ROUTE.search(self.text)
if not (mm is None):
self.route_info = mm.groupdict()
else:
raise ValueError("Could not parse '{0}'".format(self.text))
else:
self.feature = 'ip route'
self._address_family = "ip"
mm = _RE_IP_ROUTE.search(self.text)
if not (mm is None):
self.route_info = mm.groupdict()
else:
raise ValueError("Could not parse '{0}'".format(self.text))
@classmethod
def is_object_for(cls, line="", re=re):
if (line[0:8]=='ip route') or (line[0:10]=='ipv6 route'):
return True
return False
@property
def vrf(self):
if not (self.route_info['vrf'] is None):
return self.route_info['vrf']
else:
return ''
@property
def address_family(self):
## ipv4, ipv6, etc
return self._address_family
@property
def network(self):
if self._address_family=='ip':
return self.route_info['prefix']
elif self._address_family=='ipv6':
retval = self.re_match_typed(r'^ipv6\s+route\s+(vrf\s+)*(\S+?)\/\d+',
group=2, result_type=str, default='')
return retval
@property
def netmask(self):
if self._address_family=='ip':
return self.route_info['netmask']
elif self._address_family=='ipv6':
return str(self.network_object.netmask)
return retval
@property
def masklen(self):
if self._address_family=='ip':
return self.network_object.prefixlen
elif self._address_family=='ipv6':
masklen_str = self.route_info['masklength'] or '128'
return int(masklen_str)
@property
def network_object(self):
try:
if self._address_family=='ip':
return IPv4Obj('%s/%s' % (self.network, self.netmask),
strict=False)
elif self._address_family=='ipv6':
return IPv6Obj('%s/%s' % (self.network, self.masklen))
except:
return None
@property
def nexthop_str(self):
if self._address_family=='ip':
if self.next_hop_interface:
return self.next_hop_interface + " " + self.next_hop_addr
else:
return self.next_hop_addr
elif self._address_family=='ipv6':
retval = self.re_match_typed(r'^ipv6\s+route\s+(vrf\s+)*\S+\s+(\S+)',
group=2, result_type=str, default='')
return retval
@property
def next_hop_interface(self):
if self._address_family=='ip':
if self.route_info['nh_intf']:
return self.route_info['nh_intf']
else:
return ''
elif self._address_family=='ipv6':
if self.route_info['nh_intf']:
return self.route_info['nh_intf']
else:
return ''
@property
def next_hop_addr(self):
if self._address_family=='ip':
return self.route_info['nh_addr'] or ''
elif self._address_family=='ipv6':
return self.route_info['nh_addr1'] or self.route_info['nh_addr2'] \
or ''
@property
def global_next_hop(self):
if self._address_family=='ip' and bool(self.vrf):
return bool(self.route_info['global'])
elif self._address_family=='ip' and not bool(self.vrf):
return True
elif self._address_family=='ipv6':
## ipv6 uses nexthop_vrf
raise ValueError("[FATAL] ipv6 doesn't support a global_next_hop for '{0}'".format(self.text))
else:
raise ValueError("[FATAL] Could not identify global next-hop for '{0}'".format(self.text))
@property
def nexthop_vrf(self):
if self._address_family=='ipv6':
return self.route_info['nexthop_vrf'] or ''
else:
raise ValueError("[FATAL] ip doesn't support a global_next_hop for '{0}'".format(self.text))
@property
def admin_distance(self):
if self.route_info['ad']:
return int(self.route_info['ad'])
else:
return 1
@property
def multicast(self):
"""Return whether the multicast keyword was specified"""
return bool(self.route_info['mcast'])
@property
def unicast(self):
## FIXME It's unclear how to implement this...
raise NotImplementedError
@property
def route_name(self):
if self._address_family=='ip':
if self.route_info['name']:
return self.route_info['name']
else:
return ''
elif self._address_family=='ipv6':
raise NotImplementedError
@property
def permanent(self):
if self._address_family=='ip':
if self.route_info['permanent']:
return bool(self.route_info['permanent'])
else:
return False
elif self._address_family=='ipv6':
raise NotImplementedError
@property
def tracking_object_name(self):
if self._address_family=='ip':
if bool(self.route_info['track']):
return self.route_info['track']
else:
return ''
elif self._address_family=='ipv6':
raise NotImplementedError
@property
def tag(self):
return self.route_info['tag'] or ''
################################
################################ Groups ###############################
################################
##
##------------- IOS TACACS+ Group
##
class IOSAaaGroupServerLine(BaseCfgLine):
def __init__(self, *args, **kwargs):
super(IOSAaaGroupServerLine, self).__init__(*args, **kwargs)
self.feature = 'aaa | |
<gh_stars>0
# coding=utf-8
from django.test import TestCase
import json
# Create your tests here.
from django.test import override_settings
@override_settings(DEBUG=True)
class TestSimpleCreate(TestCase):
@classmethod
def setUpTestData(cls):
# Set up data for the whole TestCase
cls.user_from = {}
cls.user_from["first_name"] = "Manuel"
cls.user_from["last_name"] = "Gonzalez"
cls.user_from["username"] = "manuggz"
cls.user_from["id"] = "109518141"
cls.chat = {}
cls.chat["first_name"] = "Manuel"
cls.chat["last_name"] = "Gonzalez"
cls.chat["username"] = "manuggz"
cls.chat["type"] = "private"
cls.chat["id"] = "109518141"
cls.consulta = {u'message': {u'text': "", u'from': cls.user_from, u'chat': cls.chat, u'message_id': 905475,
u'date': 1475391962}, u'update_id': 25256647, u'debug': True}
def test_create_sin_imagen_anterior(self):
self.consulta[u'message'][u'text'] = u"/create"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_space(self):
self.consulta[u'message'][u'text'] = u"/create "
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_space_create(self):
self.consulta[u'message'][u'text'] = u" /create"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_space_create_space(self):
self.consulta[u'message'][u'text'] = u" /create "
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_spacex100_create_spacex100(self):
self.consulta[u'message'][u'text'] = " " * 100 + u"/create " + " " * 100
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_spacex100_create_spacex100_create(self):
self.consulta[u'message'][u'text'] = " " * 100 + u"/create " + " " * 100 + " create"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_spacex100_create_spacex100_create_space(self):
self.consulta[u'message'][u'text'] = " " * 100 + u"/create " + " " * 100 + " create "
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_spacex100_create_spacex100_yao_spacex100(self):
self.consulta[u'message'][u'text'] = " " * 100 + u"/create " + " " * 100 + " yao " + " " * 100
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_spacex100_create_spacex100_create_spacex100_create(self):
self.consulta[u'message'][u'text'] = " " * 100 + u"/create " + " " * 100 + " create " + " " * 100 + " create"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_create_forever_alone(self):
self.consulta[u'message'][u'text'] = u"/create Forever Alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_create_no_existe(self):
self.consulta[u'message'][u'text'] = u"/create 123123123123189876761009123781238712989912992"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_double_create(self):
self.consulta[u'message'][u'text'] = u"/create /create"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
# ---------- Todos los anteriores no utilizan imagen anterior
def test_simple_create_im_alone(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_with_anterior(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone_but_with_my_dog(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone - but with my dog"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone_but_with_my_dog_separated(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone - but with my dog"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone_but_with_my_dog_separated_but_with_my_dog_separated_(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone - but with my dog - but with my dog"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone_(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im alone-"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone_(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im alone-"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__especiales(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create @!#$%&/(()~¨--.,ñ{ñ{ñ@@!-!AQW@ł@ł"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone_black(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im Alone, Black"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone_mal_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im Alone, PsyCongree"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone__mal_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im Alone-, PsyCongree"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone__mal_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im Alone-, PsyCongree"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone_mal_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im Alone, PsyCongree"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create_im_alone__buen_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create Im Alone-, Red"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone__buen_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im Alone-, Red"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone_buen_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im Alone, Red"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone_but_buen_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
self.consulta[u'message'][u'text'] = u"/create -Im Alone-but, Red"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", secure=True)
# Check that the response is 200 OK.
self.assertEqual(response.status_code, 200)
def test_simple_create__im_alone__but_buen_color(self):
self.consulta[u'message'][u'text'] = u"forever alone"
response = self.client.post('/BotTelegram/119646075:AAFsQGgw8IaLwvRZX-IBO9mgV3k048NpuMg/',
json.dumps(self.consulta), content_type="text/json", | |
<gh_stars>1-10
import torch
import os
import argparse
from dataset import DataLoader
from utils import MidtoCorner, IoU
from collections import Counter
from model import YOLOv1
# Argparse to start the YOLO training
ap = argparse.ArgumentParser()
ap.add_argument("-tip", "--test_img_files_path", default="bdd100k/images/100k/val/",
help="path to the test image folder")
ap.add_argument("-ttp", "--test_target_files_path",
default="bdd100k_labels_release/bdd100k/labels/det_v2_val_release.json",
help="path to json file containing the test labels")
ap.add_argument("-bs", "--batch_size", default=10, help="batch size")
ap.add_argument("-ls", "--load_size", default=1000,
help="amount of batches which are being loaded in one take")
ap.add_argument("-nb", "--number_boxes", default=2,
help="amount of bounding boxes which should be predicted")
ap.add_argument("-lc", "--lambda_coord", default=5,
help="hyperparameter penalizeing predicted bounding boxes in the loss function")
ap.add_argument("-ln", "--lambda_noobj", default=0.5,
help="hyperparameter penalizeing prediction confidence scores in the loss function")
ap.add_argument("-lmf", "--load_model_file", default="YOLO_bdd100k.pt",
help="name of the file containing the model weights")
ap.add_argument("-ioutn", "--iou_threshold_nms", default=0.9,
help="threshold for the IoU between the predicted boxes and the ground-truth boxes for NMS")
ap.add_argument("-ioutm", "--iou_threshold_map", default=0.7,
help="threshold for the IoU between the predicted boxes and the ground-truth boxes for mAP")
ap.add_argument("-t", "--threshold", default=0.5,
help="threshold for the confidence score of predicted bounding boxes")
ap.add_argument("-unms", "--use_nms", default=1,
help="1 if non max suppression should be used, else 0")
args = ap.parse_args()
# Dataset parameters
test_img_files_path = args.test_img_files_path
test_target_files_path = args.test_target_files_path
category_list = ["other vehicle", "pedestrian", "traffic light", "traffic sign",
"truck", "train", "other person", "bus", "car", "rider", "motorcycle",
"bicycle", "trailer"]
# Hyperparameters
batch_size = int(args.batch_size)
load_size = int(args.load_size)
split_size = 14
num_boxes = int(args.number_boxes)
lambda_coord = float(args.lambda_coord)
lambda_noobj = float(args.lambda_noobj)
iou_threshold_nms = float(args.iou_threshold_nms)
iou_threshold_map = float(args.iou_threshold_map)
threshold = float(args.threshold)
use_nms = int(args.use_nms)
# Other parameters
cell_dim = int(448/split_size)
num_classes = len(category_list)
load_model_file = args.load_model_file
def validate(test_img_files_path, test_target_files_path, category_list, split_size,
batch_size, load_size, model, cell_dim, num_boxes, num_classes, device,
iou_threshold_nms, iou_threshold_map, threshold, use_nms):
"""
Uses the test dataset to validate the performance of the model. Calculates
the mean Average Precision (mAP) for object detection.
Parameters:
test_img_files_path (str): System path to the image directory containing
the test dataset images.
test_target_files_path (str): System path to the json file containing the
ground-truth labels for the test dataset.
category_list (list): A list containing all classes which should be detected.
split_size (int): Size of the grid which is applied to the image.
batch_size (int): Batch size.
load_size (int): Amount of batches which are loaded in one function call.
model (): The YOLOv1-model.
cell_dim (int): The dimension of a single cell.
num_boxes (int): Amount of bounding boxes which are being predicted by
the model.
num_classes (int): Amount of classes which are being predicted.
device (): Device which is used for training and testing the model.
iou_threshold_nms (float): Threshold for the IoU between the predicted boxes
and the ground-truth boxes for non maximum suppression.
iou_threshold_map (float): Threshold for the IoU between the predicted boxes
and the ground-truth boxes for mean average precision.
threshold (float): Threshold for the confidence score of predicted
bounding boxes.
use_nms (bool): Specifies if non max suppression should be applied to the
bounding box predictions.
"""
model.eval()
print("DATA IS BEING LOADED FOR VALIDATION")
print("")
# Initialize the DataLoader for the test dataset
data = DataLoader(test_img_files_path, test_target_files_path, category_list,
split_size, batch_size, load_size)
data.LoadFiles()
# Here will all predicted and ground-truth bounding boxes for the whole test
# dataset be stored. These two lists will be finally used for evaluation.
# Every element of the list will have the following form:
# [image index, class prediction, confidence score, x1, y1, x2, y2]
# Every element of the list represents a single bounding box.
all_pred_boxes = []
all_target_boxes = []
train_idx = 0 # Tracks the sample index for each image in the test dataset
# This while loop is used to fill the two lists all_pred_boxes and all_target_boxes.
while len(data.img_files) > 0:
print("LOADING NEW VALIDATION BATCHES")
print("Remaining validation files:" + str(len(data.img_files)))
print("")
data.LoadData()
for batch_idx, (img_data, target_data) in enumerate(data.data):
img_data = img_data.to(device)
target_data = target_data.to(device)
with torch.no_grad():
predictions = model(img_data)
print('Extracting bounding boxes')
print('Batch: {}/{} ({:.0f}%)'.format(batch_idx+1, len(data.data),
(batch_idx+1) / len(data.data) * 100.))
print('')
pred_boxes = extract_boxes(predictions, num_classes, num_boxes,
cell_dim, threshold)
target_boxes = extract_boxes(target_data, num_classes, 1, cell_dim,
threshold)
for sample_idx in range(len(pred_boxes)):
if use_nms:
# Applies non max suppression to the bounding box predictions
nms_boxes = non_max_suppression(pred_boxes[sample_idx],
iou_threshold_nms)
else:
# Use the same list without changing anything
nms_boxes = pred_boxes[sample_idx]
for nms_box in nms_boxes:
all_pred_boxes.append([train_idx] + nms_box)
for box in target_boxes[sample_idx]:
all_target_boxes.append([train_idx] + box)
train_idx += 1
pred = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:0, 11:0, 12:0, 13:0}
for prediction in all_pred_boxes:
cls_idx = prediction[1]
pred[cls_idx] += 1
print(pred)
pred = {0:0, 1:0, 2:0, 3:0, 4:0, 5:0, 6:0, 7:0, 8:0, 9:0, 10:0, 11:0, 12:0, 13:0}
for prediction in all_target_boxes:
cls_idx = prediction[1]
pred[cls_idx] += 1
print(pred)
"""
print('')
print('##################### Calculating mAP #####################')
print('')
mean_avg_prec = mean_average_precision(all_pred_boxes, all_target_boxes,
iou_threshold_map, box_format="corner",
num_classes = num_classes)
#print(f"Train mAP: {mean_avg_prec}")
"""
def extract_boxes(yolo_tensor, num_classes, num_boxes, cell_dim, threshold):
"""
Extracts all bounding boxes from a given tensor and transforms them into a list.
Removes all bounding boxes which have a confidence score smaller than the
specified threshold.
Parameters:
yolo_tensor (tensor): The tensor from which the bounding boxes need to
be extracted.
num_classes (int): Amount of classes which are being predicted.
num_boxes (int): Amount of bounding boxes which are being predicted.
cell_dim (int): Dimension of a single cell.
threshold (float): Threshold for the confidence score of predicted
bounding boxes.
Returns:
all_bboxes (list): A list where each element is a list representing one
image from the batch. This inner list contains other lists which represent
the bounding boxes within this image.
The box lists are specified as [class_pred, conf_score, x1, y1, x2, y2]
"""
all_bboxes = [] # Stores the final output
for sample_idx in range(yolo_tensor.shape[0]):
bboxes = [] # Stores all bounding boxes of a single image
for cell_h in range(yolo_tensor.shape[1]):
for cell_w in range(yolo_tensor.shape[2]):
# Used to extract the bounding box with the highest confidence
best_box = 0
max_conf = 0.
for box_idx in range(num_boxes):
if yolo_tensor[sample_idx, cell_h, cell_w, box_idx*5] > max_conf:
max_conf = yolo_tensor[sample_idx, cell_h, cell_w, box_idx*5]
best_box = box_idx
conf = yolo_tensor[sample_idx, cell_h, cell_w, best_box*5]
if conf < threshold:
continue
# Used to extract the class with the highest score
best_class = 0
max_conf = 0.
for class_idx in range(num_classes):
if yolo_tensor[sample_idx, cell_h, cell_w, num_boxes*5+class_idx] > max_conf:
max_conf = yolo_tensor[sample_idx, cell_h, cell_w, num_boxes*5+class_idx]
best_class = class_idx
cords = MidtoCorner(yolo_tensor[sample_idx, cell_h, cell_w,
best_box*5+1:best_box*5+5], cell_h, cell_w, cell_dim)
x1 = cords[0]
y1 = cords[1]
x2 = cords[2]
y2 = cords[3]
bboxes.append([best_class, conf, x1, y1, x2, y2])
all_bboxes.append(bboxes)
return all_bboxes
def non_max_suppression(bboxes, iou_threshold):
"""
Applies non maximum suppression to a list of bounding boxes.
Parameters:
bboxes (list): List of lists containing all bboxes with each bboxes
specified as [class_pred, conf_score, x1, y1, x2, y2].
iou_threshold (float): Threshold for the IOU with the ground truth bbox.
Returns:
bboxes_after_nms (list): bboxes after performing NMS given a specific
IoU threshold.
"""
assert type(bboxes) == list
bboxes = sorted(bboxes, key=lambda x: x[1], reverse=True)
bboxes_after_nms = []
while bboxes:
chosen_box = bboxes.pop(0)
bboxes = [
box
for box in bboxes
if box[0] != chosen_box[0]
or IoU(
chosen_box[2:],
box[2:]
)
< iou_threshold
]
bboxes_after_nms.append(chosen_box)
return bboxes_after_nms
def mean_average_precision(pred_boxes, true_boxes, iou_threshold, box_format,
num_classes):
"""
Calculates the mean average precision.
Parameters:
pred_boxes (list): List of lists containing all predicted bboxes with
each bbox specified as [train_idx, class_prediction, prob_score, x1, y1, x2, y2].
true_boxes (list): List of lists containing all ground truth bboxes with
each bbox specified as [train_idx, class_prediction, prob_score, x1, y1, x2, y2].
iou_threshold (float): Threshold for counting a predicted bbox as true positive.
box_format (str): "midpoint" or "corners" used to specify the bbox format.
num_classes (int): Number of classes.
Returns:
float: mAP value across all classes given a specific IoU threshold .
"""
# list storing all AP | |
설명
초기 코드에 주어진 class Node 와 class BinSearchTree 를 기반으로, 이진 탐색 트리 (binary search tree) 에 새로운 원소를 삽입하는 insert(key, data) 연산의 구현을 완성하세요.
class BinSearchTree 에는 이미 insert(key, data) 메서드가 구현되어 있습니다. 이것을 그대로 이용하고, class Node 의 insert(key, data) 메서드를 재귀적 방법으로 구현하세요. 강의에서 언급한 바와 같이, 이미 트리 안에 들어 있는 것과 같은 (중복된) 키를 이용하여 삽입을 시도하는 경우에는 KeyError 예외를 발생시켜야 합니다.
[참고 1] inorder() 메서드의 구현은 그대로 두세요. 테스트에 이용됩니다.
[참고 2] solution() 함수의 구현도 그대로 두세요. 이것을 없애면 테스트가 되지 않습니다.
[참고 3] "코드 실행" 을 눌렀을 때 통과하는 것은 아무런 의미가 없습니다.
'''
class Node:
def __init__(self, key, data):
self.key = key
self.data = data
self.left = None
self.right = None
# 나의 풀이
def insert(self, key, data):
if key < self.key:
if self.left:
self.left.insert(key,data)
else:
self.left = Node(key,data)
elif key > self.key:
if self.right:
self.right.insert(key,data)
else:
self.right = Node(key,data)
else:
raise KeyError("")
def inorder(self):
traversal = []
if self.left:
traversal += self.left.inorder()
traversal.append(self)
if self.right:
traversal += self.right.inorder()
return traversal
class BinSearchTree:
def __init__(self):
self.root = None
def insert(self, key, data):
if self.root:
self.root.insert(key, data)
else:
self.root = Node(key, data)
def inorder(self):
if self.root:
return self.root.inorder()
else:
return []
def solution(x):
return 0
'''
(21) 이진 탐색 트리에서 노드의 삭제 연산 구현
문제 설명
초기 코드에 주어진 class Node 와 class BinSearchTree 를 기반으로, 이진 탐색 트리 (binary search tree) 에서 지정된 원소를 삭제하는 remove(key) 연산의 구현을 완성하세요.
class Node 와 class BinSearchTree 에 이미 구현되어 있는 코드는 수정하지 마세요. 코드 구현의 정확성 평가에 이용됩니다. 초기 코드에 들어 있는 주석을 참고로 하여, BinSearchTree::remove() 메서드의 안에 들어 있는 pass 를 없애고 그 자리에 올바른 코드를 써 넣으면 됩니다.
[참고 1] solution() 함수의 구현은 그대로 두세요. 이것을 없애면 테스트가 되지 않습니다.
[참고 2] "코드 실행" 을 눌렀을 때 통과하는 것은 아무런 의미가 없습니다.
[참고 3] 잘 생각해 보면, 이진 탐색 트리를 구현하지 않고 키 순서대로 정렬된 Python 의 배열을 유지함으로써도 같은 연산을 구현할 수 있습니다.
이 연습문제에서는 효율성 테스트를 하지 않기 때문에 이러한 구현을 오답으로 간주하지 않습니다만, 배열을 이용한 구현과 트리 구조를 이용한 구현은 연산의 복잡도에 큰 차이가 있습니다.
이진 탐색 트리로 구현하여 코드 작성 연습을 하시기 바랍니다.
'''
class Node:
def __init__(self, key, data):
self.key = key
self.data = data
self.left = None
self.right = None
def insert(self, key, data):
if key < self.key:
if self.left:
self.left.insert(key, data)
else:
self.left = Node(key, data)
elif key > self.key:
if self.right:
self.right.insert(key, data)
else:
self.right = Node(key, data)
else:
raise KeyError('Key %s already exists.' % key)
def lookup(self, key, parent=None):
if key < self.key:
if self.left:
return self.left.lookup(key, self)
else:
return None, None
elif key > self.key:
if self.right:
return self.right.lookup(key, self)
else:
return None, None
else:
return self, parent
def inorder(self):
traversal = []
if self.left:
traversal += self.left.inorder()
traversal.append(self)
if self.right:
traversal += self.right.inorder()
return traversal
def countChildren(self):
count = 0
if self.left:
count += 1
if self.right:
count += 1
return count
class BinSearchTree:
def __init__(self):
self.root = None
def insert(self, key, data):
if self.root:
self.root.insert(key, data)
else:
self.root = Node(key, data)
def lookup(self, key):
if self.root:
return self.root.lookup(key)
else:
return None, None
def remove(self, key):
node, parent = self.lookup(key)
if node:
nChildren = node.countChildren()
# The simplest case of no children
if nChildren == 0:
# 만약 parent 가 있으면
if parent:
if parent.left.key == node.key:
parent.left = None
else:
parent.right = None
# node 가 왼쪽 자식인지 오른쪽 자식인지 판단하여
# parent.left 또는 parent.right 를 None 으로 하여
# leaf node 였던 자식을 트리에서 끊어내어 없앱니다.
# 만약 parent 가 없으면 (node 는 root 인 경우)
# self.root 를 None 으로 하여 빈 트리로 만듭니다.
else:
self.root = None
# When the node has only one child
elif nChildren == 1:
# 하나 있는 자식이 왼쪽인지 오른쪽인지를 판단하여
# 그 자식을 어떤 변수가 가리키도록 합니다.
if node.left:
s = node.left
else:
s = node.right
# 만약 parent 가 있으면
# node 가 왼쪽 자식인지 오른쪽 자식인지 판단하여
# 위에서 가리킨 자식을 대신 node 의 자리에 넣습니다.
if parent:
if parent.left.key == node.key:
parent.left = s
s = None
else:
parent.right = s
s = None
# 만약 parent 가 없으면 (node 는 root 인 경우)
# self.root 에 위에서 가리킨 자식을 대신 넣습니다.
else:
self.root = s
# When the node has both left and right children
else:
# 1차 풀이(오답)
parent = node.right
s = parent.left
while s.left:
parent = s
s = s.left
node.key = s.key
node.data = s.data
if s.right:
parent.left = s.right
if s.countChilde() == 0:
parent.left = None
'''
테스트 1 〉 통과 (0.07ms, 16.8MB)
테스트 2 〉 통과 (0.04ms, 16.7MB)
테스트 3 〉 통과 (0.07ms, 16.7MB)
테스트 4 〉 통과 (0.06ms, 16.7MB)
테스트 5 〉 실패 (런타임 에러)
테스트 6 〉 실패 (런타임 에러)
테스트 7 〉 통과 (0.06ms, 16.9MB)
테스트 8 〉 실패 (런타임 에러)
테스트 9 〉 실패 (런타임 에러)
'''
# 2차 풀이(정답)
s = node.right
parent = node
while s.left:
parent = s
s = parent.left
node.key = s.key
node.data = s.data
if parent.right == s: # node 가 곧 parent인 경우, s의 child가 left 가 없는 경우
parent.right = s.right
if parent.left == s:
parent.left = s.right
'''
테스트 1 〉 통과 (0.13ms, 16.8MB)
테스트 2 〉 통과 (0.04ms, 16.7MB)
테스트 3 〉 통과 (0.07ms, 16.7MB)
테스트 4 〉 통과 (0.06ms, 16.8MB)
테스트 5 〉 통과 (0.06ms, 16.8MB)
테스트 6 〉 통과 (0.06ms, 16.7MB)
테스트 7 〉 통과 (0.06ms, 16.8MB)
테스트 8 〉 통과 (0.06ms, 16.7MB)
테스트 9 〉 통과 (0.07ms, 16.7MB)
'''
return True
else:
return False
def inorder(self):
if self.root:
return self.root.inorder()
else:
return []
def solution(x):
return 0
'''
(22) 최대 힙에 새로운 원소 삽입
문제 설명
초기 코드에 주어진 class MaxHeap 에 최대 힙에 새로운 원소를 추가하는 연산인 insert() 메서드의 구현을 완성하세요.
[참고 1] solution() 함수의 구현은 그대로 두세요. 이것을 없애면 테스트가 되지 않습니다.
[참고 2] "코드 실행" 을 눌렀을 때 통과하는 것은 아무런 의미가 없습니다.
'''
class MaxHeap:
def __init__(self):
self.data = [None]
def insert(self, item):
# 나의 풀이
a = self.data
a.append(item)
itemIndex = a.index(item)
while itemIndex != 1:
parentIndex = itemIndex // 2
if a[itemIndex] > a[parentIndex]:
a[itemIndex], a[parentIndex] = a[parentIndex], a[itemIndex]
itemIndex, parentIndex = itemIndex, parentIndex
itemIndex = itemIndex // 2
else:
break
'''
테스트 1 〉 통과 (0.06ms, 16.5MB)
'''
# 다른 풀이
self.data.append(item)
i = len(self.data) - 1
while i != 1:
if self.data[i] > self.data[(i // 2)]:
self.data[i], self.data[(i // 2)] = self.data[(i // 2)], self.data[i]
i = i // 2
else:
break
def solution(x):
return 0
'''
(23) 최대 힙에서의 원소 삭제
문제 설명
초기 코드에 여기 저기 포함된 빈 칸을 채움으로써 class MaxHeap 의 메서드인 maxHeapify() 의 구현을 완성하세요. 이것은 이미 주어져 있는 remove() 메서드와 연결되어 최대 힙에서의 원소 삭제 연산을 구성합니다.
[참고 1] remove() 메서드의 내용은 이미 주어져 있으므로 수정하지 않는 쪽이 좋습니다.
[참고 2] solution() 함수의 구현은 그대로 두세요. 이것을 없애면 테스트가 되지 않습니다.
[참고 3] "코드 실행" 을 눌렀을 때 통과하는 것은 아무런 의미가 없습니다.
'''
class MaxHeap:
def __init__(self):
self.data = [None]
def remove(self):
if len(self.data) > 1:
self.data[1], self.data[-1] = self.data[-1], self.data[1]
data = self.data.pop(-1)
self.maxHeapify(1)
else:
data = None
return data
# 나의 풀이
def maxHeapify(self, i):
# 왼쪽 자식 (left child) 의 인덱스를 계산합니다.
left = 2*i
# 오른쪽 자식 (right child) 의 인덱스를 계산합니다.
right = 2*i +1
smallest = i
# 왼쪽 자식이 존재하는지, 그리고 왼쪽 자식의 (키) 값이 (무엇보다?) 더 큰지를 판단합니다.
if left < len(self.data) and self.data[left] > self.data[i]:
# 조건이 만족하는 경우, smallest 는 왼쪽 자식의 인덱스를 가집니다.
smallest = left
# 오른쪽 자식이 존재하는지, 그리고 오른쪽 자식의 (키) 값이 (무엇보다?) 더 큰지를 판단합니다.
if right < len(self.data) and self.data[right] > self.data[smallest]:
#### ⭐️⭐️ i, right, left 셋 중 최대값(smallest)을 찾는 것인데 처음에 self.data[right] > self.data[i]로 작성했다가 엄청 해맸다...
## 출제자 분이 최대값의 변수 명을 great가 아닌 smallest로 지정해놓으셔서 더 헷갈린 것도 있었던 것 같다.
# 조건이 만족하는 경우, smallest 는 오른쪽 자식의 인덱스를 가집니다.
smallest = right
if smallest != i:
# 현재 | |
import requests
import pandas as pd
import numpy as np
import configparser
from datetime import datetime
from dateutil import relativedelta, parser, rrule
from dateutil.rrule import WEEKLY
class WhoopClient:
'''A class to allow a user to login and store their authorization code,
then perform pulls using the code in order to access different types of data'''
def __init__(self,
auth_code=None,
whoop_id=None,
current_datetime=datetime.utcnow()):
self.auth_code = auth_code
self.whoop_id = whoop_id
self.current_datetime = current_datetime
self.start_datetime = None
self.all_data = None
self.all_activities = None
self.sport_dict = None
self.all_sleep = None
self.all_sleep_events = None
def reset(self):
self.auth_code = None
self.whoop_id = None
self.current_datetime = datetime.utcnow()
self.start_datetime = None
self.all_data = None
self.all_activities = None
self.sport_dict = None
self.all_sleep = None
self.all_sleep_events = None
def pull_api(self, url, df=False):
auth_code = self.auth_code
headers = {'authorization': auth_code}
pull = requests.get(url, headers=headers)
if pull.status_code == 200 and len(pull.content) > 1:
if df:
d = pd.json_normalize(pull.json())
return d
else:
return pull.json()
else:
return "no response"
def pull_sleep_main(self, sleep_id):
athlete_id = self.whoop_id
sleep = self.pull_api(
'https://api-7.whoop.com/users/{}/sleeps/{}'.format(
athlete_id, sleep_id))
main_df = pd.json_normalize(sleep)
return main_df
def pull_sleep_events(self, sleep_id):
athlete_id = self.whoop_id
sleep = self.pull_api(
'https://api-7.whoop.com/users/{}/sleeps/{}'.format(
athlete_id, sleep_id))
events_df = pd.json_normalize(sleep['events'])
events_df['id'] = sleep_id
return events_df
def get_authorization(self, user_ini):
'''
Function to get the authorization token and user id.
This must be completed before a user can query the api
'''
config = configparser.ConfigParser()
config.read(user_ini)
username = config['whoop']['username']
password = config['whoop']['password']
headers = {
"username": username,
"password": password,
"grant_type": "password",
"issueRefresh": False
}
auth = requests.post("https://api-7.whoop.com/oauth/token",
json=headers)
if auth.status_code == 200:
content = auth.json()
user_id = content['user']['id']
token = content['access_token']
start_time = content['user']['profile']['createdAt']
self.whoop_id = user_id
self.auth_code = 'bearer ' + token
self.start_datetime = start_time
print("Whoop: Authentication successful")
else:
print(
"Authentication failed - please double check your credentials")
def get_keydata_all(self):
'''
This function returns a dataframe of WHOOP metrics for each day of WHOOP membership.
In the resulting dataframe, each day is a row and contains strain, recovery, and sleep information
'''
if self.start_datetime:
if self.all_data is not None:
## All data already pulled
return self.all_data
else:
start_date = parser.isoparse(
self.start_datetime).replace(tzinfo=None)
end_time = 'T23:59:59.999Z'
start_time = 'T00:00:00.000Z'
intervals = rrule.rrule(freq=WEEKLY,
interval=1,
until=self.current_datetime,
dtstart=start_date)
date_range = [[
d.strftime('%Y-%m-%d') + start_time,
(d +
relativedelta.relativedelta(weeks=1)).strftime('%Y-%m-%d')
+ end_time
] for d in intervals]
all_data = pd.DataFrame()
for dates in date_range:
cycle_url = 'https://api-7.whoop.com/users/{}/cycles?end={}&start={}'.format(
self.whoop_id, dates[1], dates[0])
data = self.pull_api(cycle_url, df=True)
all_data = pd.concat([all_data, data])
all_data.reset_index(drop=True, inplace=True)
## fixing the day column so it's not a list
all_data['days'] = all_data['days'].map(lambda d: d[0])
all_data.rename(columns={"days": 'day'}, inplace=True)
## Putting all time into minutes instead of milliseconds
sleep_cols = [
'qualityDuration', 'needBreakdown.baseline',
'needBreakdown.debt', 'needBreakdown.naps',
'needBreakdown.strain', 'needBreakdown.total'
]
for sleep_col in sleep_cols:
all_data['sleep.' + sleep_col] = all_data[
'sleep.' + sleep_col].astype(float).apply(
lambda x: np.nan if np.isnan(x) else x / 60000)
## Making nap variable
all_data['nap_duration'] = all_data['sleep.naps'].apply(
lambda x: x[0]['qualityDuration'] / 60000
if len(x) == 1 else (sum([
y['qualityDuration'] for y in x
if y['qualityDuration'] is not None
]) / 60000 if len(x) > 1 else 0))
all_data.drop(['sleep.naps'], axis=1, inplace=True)
## dropping duplicates subsetting because of list columns
all_data.drop_duplicates(subset=['day', 'sleep.id'],
inplace=True)
self.all_data = all_data
return all_data
else:
print("Please run the authorization function first")
def get_activities_all(self):
'''
Activity data is pulled through the get_keydata functions so if the data pull is present, this function
just transforms the activity column into a dataframe of activities, where each activity is a row.
If it has not been pulled, this function runs the key data function then returns the activity dataframe'''
if self.sport_dict:
sport_dict = self.sport_dict
else:
sports = self.pull_api('https://api-7.whoop.com/sports')
sport_dict = {sport['id']: sport['name'] for sport in sports}
self.sport_dict = self.sport_dict
if self.start_datetime:
## process activity data
if self.all_data is not None:
## use existing
data = self.all_data
else:
## pull all data to process activities
data = self.get_keydata_all()
## now process activities data
act_data = pd.json_normalize(
data[data['strain.workouts'].apply(len) > 0]
['strain.workouts'].apply(lambda x: x[0]))
act_data[['during.upper', 'during.lower'
]] = act_data[['during.upper',
'during.lower']].apply(pd.to_datetime)
act_data['total_minutes'] = act_data.apply(
lambda x:
(x['during.upper'] - x['during.lower']).total_seconds() / 60.0,
axis=1)
for z in range(0, 6):
act_data['zone{}_minutes'.format(
z + 1)] = act_data['zones'].apply(lambda x: x[z] / 60000.)
act_data['sport_name'] = act_data.sportId.apply(
lambda x: sport_dict[x])
act_data['day'] = act_data['during.lower'].dt.strftime('%Y-%m-%d')
act_data.drop(['zones', 'during.bounds'], axis=1, inplace=True)
act_data.drop_duplicates(inplace=True)
self.all_activities = act_data
return act_data
else:
print("Whoop: Please run the authorization function first")
def get_sleep_all(self):
'''
This function returns all sleep metrics in a data frame, for the duration of user's WHOOP membership.
Each row in the data frame represents one night of sleep
'''
if self.auth_code:
if self.all_data is not None:
## use existing
data = self.all_data
else:
## pull timeframe data
data = self.get_keydata_all()
## getting all the sleep ids
if self.all_sleep is not None:
## All sleep data already pulled
return self.all_sleep
else:
sleep_ids = data['sleep.id'].values.tolist()
sleep_list = [int(x) for x in sleep_ids if pd.isna(x) == False]
all_sleep = pd.DataFrame()
for s in sleep_list:
m = self.pull_sleep_main(s)
all_sleep = pd.concat([all_sleep, m])
## Cleaning sleep data
sleep_update = [
'qualityDuration', 'latency', 'debtPre', 'debtPost',
'needFromStrain', 'sleepNeed', 'habitualSleepNeed',
'timeInBed', 'lightSleepDuration', 'slowWaveSleepDuration',
'remSleepDuration', 'wakeDuration', 'arousalTime',
'noDataDuration', 'creditFromNaps', 'projectedSleep'
]
for col in sleep_update:
all_sleep[col] = all_sleep[col].astype(float).apply(
lambda x: np.nan if np.isnan(x) else x / 60000)
all_sleep.drop(['during.bounds'], axis=1, inplace=True)
self.all_sleep = all_sleep.copy(deep=True)
all_sleep.drop(['events'], axis=1, inplace=True)
return all_sleep
else:
print("Whoop: Please run the authorization function first")
def get_sleep_events_all(self):
'''
This function returns all sleep events in a data frame, for the duration of user's WHOOP membership.
Each row in the data frame represents an individual sleep event within an individual night of sleep.
Sleep events can be joined against the sleep or main datasets by sleep id.
All sleep times are returned in minutes.
'''
if self.auth_code:
if self.all_data is not None:
## use existing
data = self.all_data
else:
## pull timeframe data
data = self.get_keydata_all()
## getting all the sleep ids
if self.all_sleep_events is not None:
## All sleep data already pulled
return self.all_sleep_events
else:
if self.all_sleep is not None:
sleep_events = self.all_sleep[['activityId', 'events']]
all_sleep_events = pd.concat([
pd.concat([
pd.json_normalize(events),
pd.DataFrame({'id': len(events) * [sleep]})
],
axis=1) for events, sleep in
zip(sleep_events['events'], sleep_events['activityId'])
])
else:
sleep_ids = data['sleep.id'].values.tolist()
sleep_list = [
int(x) for x in sleep_ids if pd.isna(x) == False
]
all_sleep_events = pd.DataFrame()
for s in sleep_list:
events = self.pull_sleep_events(s)
all_sleep_events = pd.concat(
[all_sleep_events, events])
## Cleaning sleep events data
all_sleep_events['during.lower'] = pd.to_datetime(
all_sleep_events['during.lower'])
all_sleep_events['during.upper'] = pd.to_datetime(
all_sleep_events['during.upper'])
all_sleep_events.drop(['during.bounds'], axis=1, inplace=True)
all_sleep_events['total_minutes'] = all_sleep_events.apply(
lambda x: (x['during.upper'] - x['during.lower']
).total_seconds() / 60.0,
axis=1)
self.all_sleep_events = all_sleep_events
return all_sleep_events
else:
print("Whoop: Please run the authorization function first")
#returnTYpe = df, json
def get_hr_all(self, returnType=None):
'''
This function will pull every heart rate measurement recorded for the life of WHOOP membership.
The default return for this function is a list of lists, where each "row" contains the date, time, and hr value.
The measurements are spaced out every ~6 seconds on average.
To return a dataframe, set df=True. This will take a bit longer, but will return a data frame.
NOTE: This api pull takes about 6 seconds per week of data ... or 1 minutes for 10 weeks of data,
so be careful when you pull, it may take a while.
'''
if self.start_datetime:
athlete_id = self.whoop_id
start_date = parser.isoparse(
self.start_datetime).replace(tzinfo=None)
end_time = 'T23:59:59.999Z'
start_time = 'T00:00:00.000Z'
intervals = rrule.rrule(freq=WEEKLY,
interval=1,
until=self.current_datetime,
dtstart=start_date)
date_range = [[
d.strftime('%Y-%m-%d') + start_time,
(d + relativedelta.relativedelta(weeks=1)).strftime('%Y-%m-%d')
+ end_time
] for d in intervals]
hr_list = []
for dates in date_range:
start = dates[0]
end = dates[1]
ul = '''https://api-7.whoop.com/users/{}/metrics/heart_rate?end={}&order=t&start={}&step=6'''.format(
athlete_id, end, start)
hr_vals = self.pull_api(ul)['values']
hr_values = [[
datetime.utcfromtimestamp(h['time'] / 1e3).date(),
datetime.utcfromtimestamp(h['time'] / 1e3).time(),
h['data']
] for h in hr_vals]
hr_list.extend(hr_values)
if returnType == "df":
hr_df = pd.DataFrame(hr_list)
hr_df.columns = ['date', 'time', 'hr']
return hr_df
elif returnType == "json":
hr_json = [{
'datetime': str(h[0]) + 'T' + str(h[1]),
'hr': h[2]
} for h in hr_list]
return hr_json
else:
return hr_list
else:
print("Please run the authorization function first")
def get_keydata_timeframe(self,
start,
end=datetime.strftime(datetime.utcnow(),
"%Y-%m-%d")):
'''
This function returns a dataframe of WHOOP metrics for each day in a | |
_x_max = _df_kde_i[_x_name].iloc[-1]
_x_i = np.extract((_x > _x_min) & (_x < _x_max), _x)
_mean, _std = stats.norm.fit(_x_i)
_df_kde_ex['mean'].loc[_index] = _mean
_df_kde_ex['std'].loc[_index] = _std
_df_kde_ex['range'].loc[_index] = _x_max - _x_min
_df_kde_ex['range_min'].loc[_index] = _x_min
_df_kde_ex['range_max'].loc[_index] = _x_max
_df_kde_ex['value_min'].loc[_index] = _df_kde_i['value'].iloc[0]
_df_kde_ex['value_max'].loc[_index] = _df_kde_i['value'].iloc[-1]
return _df_kde, _df_kde_ex
# wrapper to quickly aggregate df
def qagg(df: pd.DataFrame, groupby, columns=None, agg=None, reset_index=True):
if agg is None:
agg = ['mean', 'std']
if columns is None:
columns = df.select_dtypes(include=np.number).columns
_df_agg = df.groupby(groupby).agg({_: agg for _ in columns})
_df_agg = _df_agg.set_axis(flatten([[_ + '_mean', _ + '_std'] for _ in columns]), axis=1, inplace=False)
if reset_index:
_df_agg = _df_agg.reset_index()
return _df_agg
@export
def mahalanobis(point: Union[pd.DataFrame, pd.Series, np.ndarray], df: pd.DataFrame = None, params: List[str] = None,
do_print: bool = True) -> Union[float, List[float]]:
"""
Calculates the Mahalanobis distance for a single point or a DataFrame of points
:param point: The point(s) to calculate the Mahalanobis distance for
:param df: The reference DataFrame against which to calculate the Mahalanobis distance
:param params: The columns to calculate the Mahalanobis distance for
:param do_print: Whether to print intermediate steps to the console
:return: if a single point is passed: Mahalanobis distance as float, else a list of floats
"""
if df is None:
df = point
_df = df.copy()
del df
if params is None:
params = _df.columns
else:
_df = _df[params]
try:
_vi = np.linalg.inv(_df.cov())
except np.linalg.LinAlgError:
return np.nan
_y = _df.mean().values
if isinstance(point, pd.DataFrame):
_out = []
_it = -1
for _index, _row in point.iterrows():
_it += 1
if do_print:
progressbar(_it, point.shape[0])
_x = _row[params].values
_out.append(distance.mahalanobis(_x, _y, _vi))
if do_print:
progressbar()
return _out
elif isinstance(point, pd.Series):
_x = point[params].values
else:
_x = np.array(point)
return distance.mahalanobis(_x, _y, _vi)
def multi_melt(df, cols, suffixes, id_vars, var_name='variable', sep='_', **kwargs):
# for multi melt to work the columns must share common suffixes
_df = df.copy()
del df
_df_out = []
for _col in cols:
_value_vars = ['{}{}{}'.format(_col, sep, _suffix) for _suffix in suffixes]
_df_out_i = _df.melt(id_vars=id_vars, value_vars=_value_vars, value_name=_col, var_name=var_name, **kwargs)
_df_out_i[var_name] = _df_out_i[var_name].str.slice(len(_col) + len(sep))
_df_out_i = _df_out_i.sort_values(by=assert_list(id_vars) + [var_name]).reset_index(drop=True)
_df_out.append(_df_out_i)
_df_out = pd.concat(_df_out, axis=1).pipe(drop_duplicate_cols)
return _df_out
# for resampling integer indexes
def resample(df, rule=1, on=None, groupby=None, agg='mean', columns=None, adj_column_names=True, factor=1, **kwargs):
assert isinstance(df, pd.DataFrame), 'df must be a DataFrame'
_df = df.copy()
del df
if on is not None:
_df = _df.set_index(on)
if columns is None:
_columns = _df.select_dtypes(include=np.number).columns
else:
_columns = columns
if groupby is not None:
_columns = [_ for _ in _columns if _ not in assert_list(groupby)]
_df = _df.groupby(groupby)
# convert int to seconds to be able to use .resample
_df.index = pd.to_datetime(_df.index * factor, unit='s')
# resample as time series
_df = _df.resample('{}s'.format(rule), **kwargs)
# agg
_adj_column_names = False
if agg == 'mean':
_df = _df.mean()
elif agg == 'median':
_df = _df.median()
elif agg == 'sum':
_df = _df.sum()
else:
_df = _df.agg({_: agg for _ in _columns})
if adj_column_names:
_adj_column_names = True
# back to int
_df.index = ((_df.index - pd.to_datetime('1970-01-01')).total_seconds() / factor)
if _adj_column_names:
_column_names = []
for _col in _columns:
for _agg in assert_list(agg):
_column_names += ['{}_{}'.format(_col, _agg)]
_df.columns = _column_names
return _df
@docstr
@export
def df_count(x: str, df: pd.DataFrame, hue: Optional[str] = None, sort_by_count: bool = True, top_nr: int = 5,
x_base: Optional[float] = None, x_min: Optional[float] = None, x_max: Optional[float] = None,
other_name: str = 'other', other_to_na: bool = False, na: Union[bool, str] = 'drop') -> pd.DataFrame:
"""
Create a DataFrame of value counts. Supports hue levels and is therefore useful for plots, for an application
see :func:`~hhpy.plotting.countplot`
:param x: %(x)s
:param df: %(df)s
:param hue: %(hue)s
:param sort_by_count: Whether to sort the DataFrame by value counts [optional]
:param top_nr: %(top_nr)s
:param x_base: if supplied: cast x to integer multiples of x_base, useful when you have float data that would
result in many unique counts for close numbers [optional]
:param x_min: limit the range of valid numeric x values to be greater than or equal to x_min [optional]
:param x_max: limit the range of valid numeric x values to be less than or equal to x_max [optional]
:param other_name: %(other_name)s
:param other_to_na: %(other_to_na)s
:param na: whether to keep (True, 'keep') na values and implicitly cast to string
or drop (False, 'drop') them [optional]
:return: pandas DataFrame containing the counts by x (and by hue if it is supplied)
"""
# -- init
# avoid inplace operations
df = assert_df(df)
# if applicable: drop NaN
if (not na) or (na == 'drop'):
# true NaN
df = df.dropna(subset=[x])
# string NaN
df = df[~df[x].isin(STRING_NAN)]
if hue is not None:
# true NaN
df = df.dropna(subset=[hue])
# string NaN
df = df[~df[hue].isin(STRING_NAN)]
# in case the original column is already called count it is renamed to count_org
if x == 'count':
x = 'count_org'
df = df.rename({'count': 'count_org'}, axis=1)
# -- preprocessing
if x_base:
# round to multiples of x_int
df[x] = np.round(df[x] / x_base) * x_base
if isinstance(x_base, int):
df[x] = df[x].astype(int)
# apply x limits
if x_min is None:
x_min = df[x].min()
if x_max is None:
x_max = df[x].max()
_df_xs = pd.DataFrame({x: range(x_min, x_max, x_base)})
_xs_on = [x]
# init hues
if hue is not None:
_df_hues = df[[hue]].drop_duplicates().reset_index().assign(_dummy=1)
_df_xs = pd.merge(_df_xs.assign(_dummy=1), _df_hues, on='_dummy').drop(['_dummy'], axis=1)
_xs_on = _xs_on + [hue]
else:
# apply x limits (ignored if not numeric)
if x in df.select_dtypes(np.number):
if x_min:
df[x] = df[x].where(lambda _: _ >= x_min, x_min)
if x_max:
df[x] = df[x].where(lambda _: _ <= x_max, x_max)
# to string
df[x] = df[x].astype(str)
if hue is not None:
df[hue] = df[hue].astype(str)
# if applicable: apply top_n_coding (both x and hue)
if top_nr:
df[x] = top_n_coding(s=df[x], n=top_nr, other_name=other_name, other_to_na=other_to_na)
if hue is not None:
df[hue] = top_n_coding(s=df[hue], n=top_nr, other_name=other_name, other_to_na=other_to_na)
# init groupby
_groupby = [x]
if hue is not None:
_groupby = _groupby + [hue]
# we use a dummy column called count and sum over it by group to retain the original x column values
_df_count = df.assign(count=1).groupby(_groupby).agg({'count': 'sum'}).reset_index()
# if applicable: append 0 entries for numerical x inside x_range
if x_base:
# was already called with same if before
# noinspection PyUnboundLocalVariable
_df_count = pd.merge(_df_count, _df_xs, on=_xs_on, how='outer')
_df_count['count'] = _df_count['count'].fillna(0)
# create total count (for perc)
_count_x = 'count_{}'.format(x)
_count_hue = 'count_{}'.format(hue)
if hue is None:
_df_count[_count_hue] = _df_count['count'].sum()
_df_count[_count_x] = _df_count['count']
else:
_df_count[_count_x] = _df_count.groupby(x)['count'].transform(pd.Series.sum)
_df_count[_count_hue] = _df_count.groupby(hue)['count'].transform(pd.Series.sum)
# sort
if sort_by_count:
_df_count = _df_count.sort_values([_count_x], ascending=False).reset_index(drop=True)
# add perc columns
_df_count[f"perc_{x}"] = np.round(_df_count['count'] / _df_count[_count_x] * 100, 2)
_df_count[f"perc_{hue}"] = np.round(_df_count['count'] / _df_count[_count_hue] * 100, 2)
return _df_count
# return prediction accuracy in percent
def get_accuracy(class_true, class_pred):
return np.where(class_true.astype(str) == class_pred.astype(str), 1, 0).sum() / len(class_true)
# takes a numeric pandas series and splits it into groups, the groups are labeled by INTEGER multiples of the step value
def numeric_to_group(pd_series, step=None, outer_limit=4, suffix=None, use_abs=False, use_standard_scaler=True):
# outer limit is given in steps, only INTEGER values allowed
outer_limit = int(outer_limit)
# make a copy to avoid inplace effects
_series = pd.Series(deepcopy(pd_series))
# use standard scaler to center around mean with std +- 1
if use_standard_scaler:
_series = StandardScaler().fit(_series.values.reshape(-1, 1)).transform(_series.values.reshape(-1, 1)).flatten()
# if step is none: use 1 as step
if step is None:
step = 1
if suffix is None:
if use_standard_scaler:
suffix = 'std'
else:
suffix = 'step'
if suffix != '':
suffix = '_' + suffix
# to absolute
if use_abs:
_series = np.abs(_series)
else:
# gather the +0 and -0 group to 0
_series = np.where(np.abs(_series) < step, 0, _series)
# group
# get sign
_series_sign = np.sign(_series)
# divide by step, floor and integer
_series = (np.floor(np.abs(_series) / step)).astype(int) * np.sign(_series).astype(int)
# apply outer limit
if outer_limit is not None:
_series = np.where(_series > outer_limit, outer_limit, _series)
_series = np.where(_series < -outer_limit, -outer_limit, _series)
# make a pretty string
# noinspection PyTypeChecker
_series = pd.Series(_series).apply(lambda x: '{0:n}'.format(x)).astype('str') + suffix
# to cat
_series = _series.astype('category')
return _series
@export
def top_n(s: Sequence, n: Union[int, str] = None, w: Optional[Sequence] = None, | |
struct OPCITEMHEADER1
{
OPCHANDLE hClient;
DWORD dwValueOffset;
WORD wQuality;
WORD wReserved;
FILETIME ftTimeStampItem;
};
"""
SetLocalType(-1, OPCITEMHEADER1_str, 0)
Til2Idb(-1, "OPCITEMHEADER1")
OPCITEMHEADER2_str = """
struct OPCITEMHEADER2
{
OPCHANDLE hClient;
DWORD dwValueOffset;
WORD wQuality;
WORD wReserved;
};
"""
SetLocalType(-1, OPCITEMHEADER2_str, 0)
Til2Idb(-1, "OPCITEMHEADER2")
OPCGROUPHEADERWRITE_str = """
struct OPCGROUPHEADERWRITE
{
DWORD dwItemCount;
OPCHANDLE hClientGroup;
DWORD dwTransactionID;
HRESULT hrStatus;
};
"""
SetLocalType(-1, OPCGROUPHEADERWRITE_str, 0)
Til2Idb(-1, "OPCGROUPHEADERWRITE")
OPCITEMHEADERWRITE_str = """
struct OPCITEMHEADERWRITE
{
OPCHANDLE hClient;
HRESULT dwError;
};
"""
SetLocalType(-1, OPCITEMHEADERWRITE_str, 0)
Til2Idb(-1, "OPCITEMHEADERWRITE")
OPCITEMSTATE_str = """
struct OPCITEMSTATE
{
OPCHANDLE hClient;
FILETIME ftTimeStamp;
WORD wQuality;
WORD wReserved;
VARIANT vDataValue;
};
"""
SetLocalType(-1, OPCITEMSTATE_str, 0)
Til2Idb(-1, "OPCITEMSTATE")
OPCSERVERSTATUS_str = """
struct OPCSERVERSTATUS
{
FILETIME ftStartTime;
FILETIME ftCurrentTime;
FILETIME ftLastUpdateTime;
OPCSERVERSTATE dwServerState;
DWORD dwGroupCount;
DWORD dwBandWidth;
WORD wMajorVersion;
WORD wMinorVersion;
WORD wBuildNumber;
WORD wReserved;
LPWSTR szVendorInfo;
};
"""
SetLocalType(-1, OPCSERVERSTATUS_str, 0)
Til2Idb(-1, "OPCSERVERSTATUS")
OPCITEMDEF_str = """
struct OPCITEMDEF
{
LPWSTR szAccessPath;
LPWSTR szItemID;
BOOL bActive;
OPCHANDLE hClient;
DWORD dwBlobSize;
BYTE *pBlob;
VARTYPE vtRequestedDataType;
WORD wReserved;
};
"""
SetLocalType(-1, OPCITEMDEF_str, 0)
Til2Idb(-1, "OPCITEMDEF")
OPCITEMATTRIBUTES_str = """
struct OPCITEMATTRIBUTES
{
LPWSTR szAccessPath;
LPWSTR szItemID;
BOOL bActive;
OPCHANDLE hClient;
OPCHANDLE hServer;
DWORD dwAccessRights;
DWORD dwBlobSize;
BYTE *pBlob;
VARTYPE vtRequestedDataType;
VARTYPE vtCanonicalDataType;
OPCEUTYPE dwEUType;
VARIANT vEUInfo;
};
"""
SetLocalType(-1, OPCITEMATTRIBUTES_str, 0)
Til2Idb(-1, "OPCITEMATTRIBUTES")
OPCITEMRESULT_str = """
struct OPCITEMRESULT
{
OPCHANDLE hServer;
VARTYPE vtCanonicalDataType;
WORD wReserved;
DWORD dwAccessRights;
DWORD dwBlobSize;
BYTE *pBlob;
};
"""
SetLocalType(-1, OPCITEMRESULT_str, 0)
Til2Idb(-1, "OPCITEMRESULT")
OPCITEMPROPERTY_str = """
struct OPCITEMPROPERTY
{
VARTYPE vtDataType;
WORD wReserved;
DWORD dwPropertyID;
LPWSTR szItemID;
LPWSTR szDescription;
VARIANT vValue;
HRESULT hrErrorID;
DWORD dwReserved;
};
"""
SetLocalType(-1, OPCITEMPROPERTY_str, 0)
Til2Idb(-1, "OPCITEMPROPERTY")
OPCITEMPROPERTIES_str = """
struct OPCITEMPROPERTIES
{
HRESULT hrErrorID;
DWORD dwNumProperties;
OPCITEMPROPERTY *pItemProperties;
DWORD dwReserved;
};
"""
SetLocalType(-1, OPCITEMPROPERTIES_str, 0)
Til2Idb(-1, "OPCITEMPROPERTIES")
OPCBROWSEELEMENT_str = """
struct OPCBROWSEELEMENT
{
LPWSTR szName;
LPWSTR szItemID;
DWORD dwFlagValue;
DWORD dwReserved;
OPCITEMPROPERTIES ItemProperties;
};
"""
SetLocalType(-1, OPCBROWSEELEMENT_str, 0)
Til2Idb(-1, "OPCBROWSEELEMENT")
OPCITEMVQT_str = """
struct OPCITEMVQT
{
VARIANT vDataValue;
BOOL bQualitySpecified;
WORD wQuality;
WORD wReserved;
BOOL bTimeStampSpecified;
DWORD dwReserved;
FILETIME ftTimeStamp;
};
"""
SetLocalType(-1, OPCITEMVQT_str, 0)
Til2Idb(-1, "OPCITEMVQT")
enum_id = AddEnum(-1, 'OPCBROWSEFILTER', 0)
AddConstEx(enum_id, 'OPC_BROWSE_FILTER_ALL', 1, -1)
AddConstEx(enum_id, 'OPC_BROWSE_FILTER_BRANCHES', 2, -1)
AddConstEx(enum_id, 'OPC_BROWSE_FILTER_ITEMS', 3, -1)
IOPCServer_str = """
struct IOPCServer
{
struct IOPCServerVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCServer_str, 0)
Til2Idb(-1, "IOPCServer")
IOPCServerVtbl_str = """
struct IOPCServerVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCServer * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCServer * This);
ULONG (__stdcall *Release)(IOPCServer * This);
HRESULT (__stdcall *AddGroup)(IOPCServer * This, LPCWSTR szName, BOOL bActive, DWORD dwRequestedUpdateRate, OPCHANDLE hClientGroup, LONG *pTimeBias, FLOAT *pPercentDeadband, DWORD dwLCID, OPCHANDLE *phServerGroup, DWORD *pRevisedUpdateRate, IID * riid, LPUNKNOWN *ppUnk);
HRESULT (__stdcall *GetErrorString)(IOPCServer * This, HRESULT dwError, LCID dwLocale, LPWSTR *ppString);
HRESULT (__stdcall *GetGroupByName)(IOPCServer * This, LPCWSTR szName, IID * riid, LPUNKNOWN *ppUnk);
HRESULT (__stdcall *GetStatus)(IOPCServer * This, OPCSERVERSTATUS **ppServerStatus);
HRESULT (__stdcall *RemoveGroup)(IOPCServer * This, OPCHANDLE hServerGroup, BOOL bForce);
HRESULT (__stdcall *CreateGroupEnumerator)(IOPCServer * This, OPCENUMSCOPE dwScope, IID * riid, LPUNKNOWN *ppUnk);
};
"""
SetLocalType(-1, IOPCServerVtbl_str, 0)
Til2Idb(-1, "IOPCServerVtbl")
IOPCServerPublicGroups_str = """
struct IOPCServerPublicGroups
{
struct IOPCServerPublicGroupsVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCServerPublicGroups_str, 0)
Til2Idb(-1, "IOPCServerPublicGroups")
IOPCServerPublicGroupsVtbl_str = """
struct IOPCServerPublicGroupsVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCServerPublicGroups * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCServerPublicGroups * This);
ULONG (__stdcall *Release)(IOPCServerPublicGroups * This);
HRESULT (__stdcall *GetPublicGroupByName)(IOPCServerPublicGroups * This, LPCWSTR szName, IID * riid, LPUNKNOWN *ppUnk);
HRESULT (__stdcall *RemovePublicGroup)(IOPCServerPublicGroups * This, OPCHANDLE hServerGroup, BOOL bForce);
};
"""
SetLocalType(-1, IOPCServerPublicGroupsVtbl_str, 0)
Til2Idb(-1, "IOPCServerPublicGroupsVtbl")
IOPCBrowseServerAddressSpace_str = """
struct IOPCBrowseServerAddressSpace
{
struct IOPCBrowseServerAddressSpaceVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCBrowseServerAddressSpace_str, 0)
Til2Idb(-1, "IOPCBrowseServerAddressSpace")
IOPCBrowseServerAddressSpaceVtbl_str = """
struct IOPCBrowseServerAddressSpaceVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCBrowseServerAddressSpace * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCBrowseServerAddressSpace * This);
ULONG (__stdcall *Release)(IOPCBrowseServerAddressSpace * This);
HRESULT (__stdcall *QueryOrganization)(IOPCBrowseServerAddressSpace * This, OPCNAMESPACETYPE *pNameSpaceType);
HRESULT (__stdcall *ChangeBrowsePosition)(IOPCBrowseServerAddressSpace * This, OPCBROWSEDIRECTION dwBrowseDirection, LPCWSTR szString);
HRESULT (__stdcall *BrowseOPCItemIDs)(IOPCBrowseServerAddressSpace * This, OPCBROWSETYPE dwBrowseFilterType, LPCWSTR szFilterCriteria, VARTYPE vtDataTypeFilter, DWORD dwAccessRightsFilter, LPENUMSTRING *ppIEnumString);
HRESULT (__stdcall *GetItemID)(IOPCBrowseServerAddressSpace * This, LPWSTR szItemDataID, LPWSTR *szItemID);
HRESULT (__stdcall *BrowseAccessPaths)(IOPCBrowseServerAddressSpace * This, LPCWSTR szItemID, LPENUMSTRING *ppIEnumString);
};
"""
SetLocalType(-1, IOPCBrowseServerAddressSpaceVtbl_str, 0)
Til2Idb(-1, "IOPCBrowseServerAddressSpaceVtbl")
IOPCGroupStateMgt_str = """
struct IOPCGroupStateMgt
{
struct IOPCGroupStateMgtVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCGroupStateMgt_str, 0)
Til2Idb(-1, "IOPCGroupStateMgt")
IOPCGroupStateMgtVtbl_str = """
struct IOPCGroupStateMgtVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCGroupStateMgt * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCGroupStateMgt * This);
ULONG (__stdcall *Release)(IOPCGroupStateMgt * This);
HRESULT (__stdcall *GetState)(IOPCGroupStateMgt * This, DWORD *pUpdateRate, BOOL *pActive, LPWSTR *ppName, LONG *pTimeBias, FLOAT *pPercentDeadband, DWORD *pLCID, OPCHANDLE *phClientGroup, OPCHANDLE *phServerGroup);
HRESULT (__stdcall *SetState)(IOPCGroupStateMgt * This, DWORD *pRequestedUpdateRate, DWORD *pRevisedUpdateRate, BOOL *pActive, LONG *pTimeBias, FLOAT *pPercentDeadband, DWORD *pLCID, OPCHANDLE *phClientGroup);
HRESULT (__stdcall *SetName)(IOPCGroupStateMgt * This, LPCWSTR szName);
HRESULT (__stdcall *CloneGroup)(IOPCGroupStateMgt * This, LPCWSTR szName, IID * riid, LPUNKNOWN *ppUnk);
};
"""
SetLocalType(-1, IOPCGroupStateMgtVtbl_str, 0)
Til2Idb(-1, "IOPCGroupStateMgtVtbl")
IIOPCSyncIO_str = """
struct IOPCSyncIO
{
struct IOPCSyncIOVtbl *lpVtbl;
};
"""
SetLocalType(-1, IIOPCSyncIO_str, 0)
Til2Idb(-1, "IOPCSyncIO")
IOPCSyncIOVtbl_str = """
struct IOPCSyncIOVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCSyncIO * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCSyncIO * This);
ULONG (__stdcall *Release)(IOPCSyncIO * This);
HRESULT (__stdcall *Read)(IOPCSyncIO * This, OPCDATASOURCE dwSource, DWORD dwCount, OPCHANDLE *phServer, OPCITEMSTATE **ppItemValues, HRESULT **ppErrors);
HRESULT (__stdcall *Write)(IOPCSyncIO * This, DWORD dwCount, OPCHANDLE *phServer, VARIANT *pItemValues, HRESULT **ppErrors);
};
"""
SetLocalType(-1, IOPCSyncIOVtbl_str, 0)
Til2Idb(-1, "IOPCSyncIOVtbl")
IOPCAsyncIO_str = """
struct IOPCAsyncIO
{
struct IOPCAsyncIOVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCAsyncIO_str, 0)
Til2Idb(-1, "IOPCAsyncIO")
IOPCAsyncIOVtbl_str = """
struct IOPCAsyncIOVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCAsyncIO * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCAsyncIO * This);
ULONG (__stdcall *Release)(IOPCAsyncIO * This);
HRESULT (__stdcall *Read)(IOPCAsyncIO * This, DWORD dwConnection, OPCDATASOURCE dwSource, DWORD dwCount, OPCHANDLE *phServer, DWORD *pTransactionID, HRESULT **ppErrors);
HRESULT (__stdcall *Write)(IOPCAsyncIO * This, DWORD dwConnection, DWORD dwCount, OPCHANDLE *phServer, VARIANT *pItemValues, DWORD *pTransactionID, HRESULT **ppErrors);
HRESULT (__stdcall *Refresh)(IOPCAsyncIO * This, DWORD dwConnection, OPCDATASOURCE dwSource, DWORD *pTransactionID);
HRESULT (__stdcall *Cancel)(IOPCAsyncIO * This, DWORD dwTransactionID);
};
"""
SetLocalType(-1, IOPCAsyncIOVtbl_str, 0)
Til2Idb(-1, "IOPCAsyncIOVtbl")
IOPCItemMgt_str = """
struct IOPCItemMgt
{
struct IOPCItemMgtVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCItemMgt_str, 0)
Til2Idb(-1, "IOPCItemMgt")
IOPCItemMgtVtbl_str = """
struct IOPCItemMgtVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCItemMgt * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCItemMgt * This);
ULONG (__stdcall *Release)(IOPCItemMgt * This);
HRESULT (__stdcall *AddItems)(IOPCItemMgt * This, DWORD dwCount, OPCITEMDEF *pItemArray, OPCITEMRESULT **ppAddResults, HRESULT **ppErrors);
HRESULT (__stdcall *ValidateItems)(IOPCItemMgt * This, DWORD dwCount, OPCITEMDEF *pItemArray, BOOL bBlobUpdate, OPCITEMRESULT **ppValidationResults, HRESULT **ppErrors);
HRESULT (__stdcall *RemoveItems)(IOPCItemMgt * This, DWORD dwCount, OPCHANDLE *phServer, HRESULT **ppErrors);
HRESULT (__stdcall *SetActiveState)(IOPCItemMgt * This, DWORD dwCount, OPCHANDLE *phServer, BOOL bActive, HRESULT **ppErrors);
HRESULT (__stdcall *SetClientHandles)(IOPCItemMgt * This, DWORD dwCount, OPCHANDLE *phServer, OPCHANDLE *phClient, HRESULT **ppErrors);
HRESULT (__stdcall *SetDatatypes)(IOPCItemMgt * This, DWORD dwCount, OPCHANDLE *phServer, VARTYPE *pRequestedDatatypes, HRESULT **ppErrors);
HRESULT (__stdcall *CreateEnumerator)(IOPCItemMgt * This, IID * riid, LPUNKNOWN *ppUnk);
};
"""
SetLocalType(-1, IOPCItemMgtVtbl_str, 0)
Til2Idb(-1, "IOPCItemMgtVtbl")
IEnumOPCItemAttributes_str = """
struct IEnumOPCItemAttributes
{
struct IEnumOPCItemAttributesVtbl *lpVtbl;
};
"""
SetLocalType(-1, IEnumOPCItemAttributes_str, 0)
Til2Idb(-1, "IEnumOPCItemAttributes")
IEnumOPCItemAttributesVtbl_str = """
struct IEnumOPCItemAttributesVtbl
{
HRESULT (__stdcall *QueryInterface)(IEnumOPCItemAttributes * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IEnumOPCItemAttributes * This);
ULONG (__stdcall *Release)(IEnumOPCItemAttributes * This);
HRESULT (__stdcall *Next)(IEnumOPCItemAttributes * This, ULONG celt, OPCITEMATTRIBUTES **ppItemArray, ULONG *pceltFetched);
HRESULT (__stdcall *Skip)(IEnumOPCItemAttributes * This, ULONG celt);
HRESULT (__stdcall *Reset)(IEnumOPCItemAttributes * This);
HRESULT (__stdcall *Clone)(IEnumOPCItemAttributes * This, IEnumOPCItemAttributes **ppEnumItemAttributes);
};
"""
SetLocalType(-1, IEnumOPCItemAttributesVtbl_str, 0)
Til2Idb(-1, "IEnumOPCItemAttributesVtbl")
IOPCDataCallback_str = """
struct IOPCDataCallback
{
struct IOPCDataCallbackVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCDataCallback_str, 0)
Til2Idb(-1, "IOPCDataCallback")
IOPCDataCallbackVtbl_str = """
struct IOPCDataCallbackVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCDataCallback * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCDataCallback * This);
ULONG (__stdcall *Release)(IOPCDataCallback * This);
HRESULT (__stdcall *OnDataChange)(IOPCDataCallback * This, DWORD dwTransid, OPCHANDLE hGroup, HRESULT hrMasterquality, HRESULT hrMastererror, DWORD dwCount, OPCHANDLE *phClientItems, VARIANT *pvValues, WORD *pwQualities, FILETIME *pftTimeStamps, HRESULT *pErrors);
HRESULT (__stdcall *OnReadComplete)(IOPCDataCallback * This, DWORD dwTransid, OPCHANDLE hGroup, HRESULT hrMasterquality, HRESULT hrMastererror, DWORD dwCount, OPCHANDLE *phClientItems, VARIANT *pvValues, WORD *pwQualities, FILETIME *pftTimeStamps, HRESULT *pErrors);
HRESULT (__stdcall *OnWriteComplete )(IOPCDataCallback * This, DWORD dwTransid, OPCHANDLE hGroup, HRESULT hrMastererr, DWORD dwCount, OPCHANDLE *pClienthandles, HRESULT *pErrors);
HRESULT ( __stdcall *OnCancelComplete )(IOPCDataCallback * This, DWORD dwTransid, OPCHANDLE hGroup);
};
"""
SetLocalType(-1, IOPCDataCallbackVtbl_str, 0)
Til2Idb(-1, "IOPCDataCallbackVtbl")
IOPCAsyncIO2_str = """
struct IOPCAsyncIO2
{
struct IOPCAsyncIO2Vtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCAsyncIO2_str, 0)
Til2Idb(-1, "IOPCAsyncIO2")
IOPCAsyncIO2Vtbl_str = """
struct IOPCAsyncIO2Vtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCAsyncIO2 * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCAsyncIO2 * This);
ULONG (__stdcall *Release)(IOPCAsyncIO2 * This);
HRESULT (__stdcall *Read)(IOPCAsyncIO2 * This, DWORD dwCount, OPCHANDLE *phServer, DWORD dwTransactionID, DWORD *pdwCancelID, HRESULT **ppErrors);
HRESULT (__stdcall *Write)(IOPCAsyncIO2 * This, DWORD dwCount, OPCHANDLE *phServer, VARIANT *pItemValues, DWORD dwTransactionID, DWORD *pdwCancelID, HRESULT **ppErrors);
HRESULT (__stdcall *Refresh2)(IOPCAsyncIO2 * This, OPCDATASOURCE dwSource, DWORD dwTransactionID, DWORD *pdwCancelID);
HRESULT (__stdcall *Cancel2)(IOPCAsyncIO2 * This, DWORD dwCancelID);
HRESULT (__stdcall *SetEnable)(IOPCAsyncIO2 * This, BOOL bEnable);
HRESULT (__stdcall *GetEnable)(IOPCAsyncIO2 * This, BOOL *pbEnable);
};
"""
SetLocalType(-1, IOPCAsyncIO2Vtbl_str, 0)
Til2Idb(-1, "IOPCAsyncIO2Vtbl")
IOPCItemProperties_str = """
struct IOPCItemProperties
{
struct IOPCItemPropertiesVtbl *lpVtbl;
};
"""
SetLocalType(-1, IOPCItemProperties_str, 0)
Til2Idb(-1, "IOPCItemProperties")
IOPCItemPropertiesVtbl_str = """
struct IOPCItemPropertiesVtbl
{
HRESULT (__stdcall *QueryInterface)(IOPCItemProperties * This, IID * riid, void **ppvObject);
ULONG (__stdcall *AddRef)(IOPCItemProperties * | |
from django.shortcuts import render_to_response, get_object_or_404, redirect
from django.http import HttpResponseRedirect, Http404, HttpResponse, HttpResponseForbidden
from django.template import RequestContext
from django.core.urlresolvers import reverse
from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required
from django.contrib.auth.forms import UserCreationForm
from django.conf import settings
from django.db.models import Q
from django.forms.formsets import formset_factory
from django.forms.models import modelformset_factory
from django.core.mail import send_mail
from django.core import serializers
from django.conf import settings
from decimal import *
from datetime import datetime, timedelta
from clusters.models import *
from clusters.forms import *
from clusters.utils import *
def cluster_params(cluster):
template_params = {}
linked_efs = []
resources = []
efs = EconomicFunction.objects.filter(cluster=cluster)
for ef in efs:
inputs = ef.inputs()
if inputs:
linked_efs.append(ef)
for inp in inputs:
resources.append(inp.resource_type)
outputs = ef.outputs()
if outputs:
linked_efs.append(ef)
for output in outputs:
resources.append(output.resource_type)
efs = list(set(linked_efs))
resources = list(set(resources))
agents = {}
for ef in efs:
for agent in ef.agents.all():
#agents.setdefault(ef.node_id(), []).append(agent.agent.name)
agents.setdefault(ef, []).append(agent.agent)
root = cluster.root()
frtable = function_resource_table(cluster, "qty")
template_params = {
"cluster": cluster,
"functions": efs,
"resources": resources,
"function_agents": agents,
"root": root,
"frtable": frtable,
}
return template_params
def explore_params(cluster):
template_params = {}
linked_efs = []
resources = []
efs = EconomicFunction.objects.filter(cluster=cluster)
for ef in efs:
inputs = ef.inputs()
if inputs:
linked_efs.append(ef)
for inp in inputs:
resources.append(inp.resource_type)
outputs = ef.outputs()
if outputs:
linked_efs.append(ef)
for output in outputs:
resources.append(output.resource_type)
efs = list(set(linked_efs))
resources = list(set(resources))
agents = {}
for ef in efs:
for agent in ef.agents.all():
agents.setdefault(ef, []).append(agent.agent)
root = cluster.root()
template_params = {
"cluster": cluster,
"functions": efs,
"resources": resources,
"function_agents": agents,
"root": root,
}
return template_params
class FlowResource(object):
def __init__(self, resource_type):
self.resource_type = resource_type
# does not work; FlowResource objects cannot fake it for FunctionResourceTypes
def flow_radial_graph_params(cluster):
template_params = {}
flows = FunctionResourceFlow.objects.filter(
from_function__cluster=cluster)
functions = []
resources = []
edges = []
for flow in flows:
from_fn = flow.from_function
try:
len(from_fn.inputs)
except TypeError:
from_fn.inputs = []
from_fn.inputs.append(FlowResource(flow.resource_type))
to_fn = flow.to_function
try:
len(from_fn.outputs)
except TypeError:
to_fn.outputs = []
to_fn.outputs.append(FlowResource(flow.resource_type))
functions.extend([from_fn, to_fn])
resources.append(flow.resource_type)
functions = list(set(functions))
resources = list(set(resources))
agents = {}
for ef in functions:
for agent in ef.agents.all():
#agents.setdefault(ef.node_id(), []).append(agent.agent.name)
agents.setdefault(ef, []).append(agent.agent)
root = cluster.root()
template_params = {
"cluster": cluster,
"functions": functions,
"resources": resources,
"function_agents": agents,
"root": root,
}
return template_params
def clusters(request):
user = request.user
if user.is_active:
communities = [cm.community for cm in user.communities.all()]
cids = [c.id for c in communities]
communities.extend(list(Community.objects.exclude(id__in=cids)))
else:
communities = Community.objects.all()
return render_to_response("clusters/clusters.html", {
"communities": communities,
}, context_instance=RequestContext(request))
def cluster(request, cluster_id, location="agt"):
cluster = get_object_or_404(Cluster, pk=cluster_id)
community = cluster.community
#import pdb; pdb.set_trace()
location_form = None
if community.agent_geographic_area_name:
init = {"location": location,}
location_form = AgentAreaForm(community=community, initial=init, data=request.POST or None)
if request.method == "POST":
if location_form:
if location_form.is_valid():
location = location_form.cleaned_data["location"]
return HttpResponseRedirect('/%s/%s/%s/'
% ('clusters/cluster', cluster_id, location))
if location == "agt":
agents = [agent for agent in cluster.agents() if agent.latitude]
for agent in agents:
agent.all_functions = agent.functions.filter(
function__cluster=cluster)
#import pdb; pdb.set_trace()
else:
agents = cluster.regions()
color_functions = cluster.function_colors()
map_center = ",".join([str(community.latitude), str(community.longitude)])
map_key = settings.GOOGLE_API_KEY
return render_to_response("clusters/cluster.html", {
"cluster": cluster,
"agents": agents,
"map_center": map_center,
"map_key": map_key,
"zoom_level": community.map_zoom_level,
"location_form": location_form,
"color_functions": color_functions,
}, context_instance=RequestContext(request))
def cluster_agents(request, cluster_id):
cluster = get_object_or_404(Cluster, pk=cluster_id)
#import pdb; pdb.set_trace()
agents = cluster.agents()
for agent in agents:
agent.form = AgentTextForm()
#import pdb; pdb.set_trace()
return render_to_response("clusters/cluster_agents.html", {
"cluster": cluster,
"agents": agents,
}, context_instance=RequestContext(request))
def edit_cluster_agents(request, cluster_id):
cluster = get_object_or_404(Cluster, pk=cluster_id)
#import pdb; pdb.set_trace()
agents = cluster.agents()
for agent in agents:
agent.cluster_functions = agent.functions.filter(function__cluster=cluster)
for cf in agent.cluster_functions:
cf.rsrcs = cf.function.resources.all()
if cf.rsrcs:
for res in cf.rsrcs:
res.agent_resource_list = res.function_resources_for_agent(agent)
else:
cf.agent_resources = cf.function_resources.all()
outliers = []
candidates = cf.function_resources.all()
for c in candidates:
if c.is_outlier():
outliers.append(c)
cf.outliers = outliers
#import pdb; pdb.set_trace()
return render_to_response("clusters/edit_cluster_agents.html", {
"cluster": cluster,
"agents": agents,
}, context_instance=RequestContext(request))
@login_required
def edit_cluster_functions(request, cluster_id):
cluster = get_object_or_404(Cluster, pk=cluster_id)
community = cluster.community
symbol = "$"
try:
symbol = community.unit_of_value.symbol
except:
pass
new_function_form = EconomicFunctionForm(prefix="function")
new_resource_form = EconomicResourceTypeForm(prefix="resource")
functions = cluster.functions.all()
for fun in functions:
fun.form = FunctionResourceTypeForm(community=cluster.community)
resources = cluster.resources()
for res in resources:
res.my_consumers = res.cluster_consumers(cluster)
res.my_producers = res.cluster_producers(cluster)
used = [cr.resource_type.id for cr in community.resources.all()]
resource_names = ';'.join([
res.name for res in EconomicResourceType.objects.all().exclude(id__in=used)])
template_params = network_params(cluster, "qty")
template_params["symbol"] = symbol
template_params["functions"] = functions
template_params["resources"] = resources
template_params["new_function_form"] = new_function_form
template_params["new_resource_form"] = new_resource_form
template_params["resource_names"] = resource_names
function_aspect_name = cluster.function_aspect_name
resource_aspect_name = cluster.community.resource_aspect_name
template_params["function_aspect_name"] = function_aspect_name
template_params["resource_aspect_name"] = resource_aspect_name
return render_to_response("clusters/edit_cluster_functions.html",
template_params,
context_instance=RequestContext(request))
@login_required
def edit_flows(request, cluster_id):
cluster = get_object_or_404(Cluster, pk=cluster_id)
if not cluster.permits("edit", request.user):
return HttpResponseForbidden("Uh-uh, you don't have permission to do that")
new_function_form = EconomicFunctionForm(prefix="function")
new_resource_form = EconomicResourceTypeForm(prefix="resource")
flows = FunctionResourceFlow.objects.filter(
from_function__cluster=cluster)
FlowFormSet = modelformset_factory(
FunctionResourceFlow,
form=FunctionResourceFlowForm,
can_delete=True,
extra=4,
)
formset = FlowFormSet(
queryset=FunctionResourceFlow.objects.filter(
from_function__cluster=cluster),
data=request.POST or None,
)
function_choices = [('', '----------')] + [
(fn.id, fn.name) for fn in cluster.functions.all()
]
resource_choices = [('', '----------')] + [
(cr.resource_type.id, cr.resource_type.name) for cr in cluster.community.resources.all()
]
for form in formset.forms:
form.fields['from_function'].choices = function_choices
form.fields['to_function'].choices = function_choices
form.fields['resource_type'].choices = resource_choices
used = [cr.resource_type.id for cr in cluster.community.resources.all()]
resource_names = ';'.join([
res.name for res in EconomicResourceType.objects.all().exclude(id__in=used)])
if request.method == "POST":
#import pdb; pdb.set_trace()
for form in formset.forms:
if form.is_valid():
delete = form.cleaned_data["DELETE"]
if delete:
#todo: this delete code is odd.
#First, I expected formsets to delete automatically id DELETE is True.
#Second, returning an object when requesting id is nice
#but smells like it might break in the future.
#import pdb; pdb.set_trace()
deleted = form.cleaned_data["id"]
deleted.delete()
else:
form.save()
return HttpResponseRedirect('/%s/%s/'
% ('clusters/editflows', cluster.id))
template_params = flow_params(cluster, "qty")
template_params["new_function_form"] = new_function_form
template_params["new_resource_form"] = new_resource_form
template_params["resource_names"] = resource_names
function_aspect_name = cluster.function_aspect_name
resource_aspect_name = cluster.community.resource_aspect_name
template_params["function_aspect_name"] = function_aspect_name
template_params["resource_aspect_name"] = resource_aspect_name
template_params["formset"] = formset
return render_to_response("clusters/edit_flows.html",
template_params,
context_instance=RequestContext(request))
@login_required
def edit_agent_flows(request, cluster_id):
cluster = get_object_or_404(Cluster, pk=cluster_id)
if not cluster.permits("edit", request.user):
return HttpResponseForbidden("Uh-uh, you don't have permission to do that")
new_function_form = InlineAgentFunctionForm(cluster=cluster, prefix="function")
new_resource_form = EconomicResourceTypeForm(prefix="resource")
flows = list(AgentResourceFlow.objects.filter(
from_function__function__cluster=cluster))
flows.extend(list(AgentResourceFlow.objects.filter(
to_function__function__cluster=cluster)))
FlowFormSet = modelformset_factory(
AgentResourceFlow,
form=AgentResourceFlowForm,
can_delete=True,
extra=3,
)
formset = FlowFormSet(
queryset=AgentResourceFlow.objects.filter(
from_function__function__cluster=cluster),
data=request.POST or None,
)
agent_functions = AgentFunction.objects.filter(
function__cluster=cluster)
function_choices = [('', '----------')] + [
(fn.id, fn) for fn in agent_functions]
resources = cluster.community.resources.all()
resource_choices = [('', '----------')] + [
(cr.resource_type.id, cr.resource_type.name) for cr in resources
]
for form in formset.forms:
form.fields['from_function'].choices = function_choices
form.fields['to_function'].choices = function_choices
form.fields['resource_type'].choices = resource_choices
used = [cr.resource_type.id for cr in resources]
erts = EconomicResourceType.objects.all().exclude(id__in=used)
resource_names = '~'.join([res.name for res in erts])
function_names = '~'.join([fn.name for fn in cluster.functions.all()])
if request.method == "POST":
#import pdb; pdb.set_trace()
for form in formset.forms:
if form.is_valid():
delete = form.cleaned_data["DELETE"]
if delete:
#todo: this delete code is odd.
#First, I expected formsets to delete automatically id DELETE is True.
#Second, returning an object when requesting id is nice
#but smells like it might break in the future.
#import pdb; pdb.set_trace()
deleted = form.cleaned_data["id"]
deleted.delete()
else:
form.save()
return HttpResponseRedirect('/%s/%s/'
% ('clusters/editagentflows', cluster.id))
template_params = agent_flow_params(cluster, "qty")
template_params["new_function_form"] = new_function_form
template_params["new_resource_form"] = new_resource_form
template_params["resource_names"] = resource_names
template_params["function_names"] = function_names
function_aspect_name = cluster.function_aspect_name
resource_aspect_name = cluster.community.resource_aspect_name
template_params["function_aspect_name"] = function_aspect_name
template_params["resource_aspect_name"] = resource_aspect_name
template_params["formset"] = formset
return render_to_response("clusters/edit_agent_flows.html",
template_params,
context_instance=RequestContext(request))
def featured_cluster(request):
cluster = get_featured_cluster()
template_params = {}
if cluster:
template_params = cluster_params(cluster)
toggle = "qty"
template_params.update(sankey_params(cluster, toggle))
return render_to_response("clusters/featured_cluster.html",
template_params,
context_instance=RequestContext(request))
def radial_graph(request, cluster_id):
cluster = get_object_or_404(Cluster, pk=cluster_id)
template_params = cluster_params(cluster)
return render_to_response("clusters/radial_graph.html",
template_params,
context_instance=RequestContext(request))
class Edge(object):
def __init__(self, from_node, to_node, quantity, label, width=1):
self.from_node = from_node
self.to_node = to_node
self.quantity = quantity
self.label = label
self.width = width
def agent_network_params(cluster, toggle):
template_params = {}
frts = AgentFunctionResourceType.objects.filter(
agent_function__function__cluster=cluster)
symbol = "$"
if toggle == "val" or toggle == "price":
try:
symbol = cluster.community.unit_of_value.symbol
except:
pass
edges = []
rtypes = []
if toggle == "price":
total = Decimal("0.00")
else:
total = 0.0
if frts:
nodes = list(cluster.agents())
for agt in nodes:
for v in agt.function_inputs(cluster):
rtypes.append(v.resource_type)
if toggle == "val":
value = v.get_value()
total += value
val_string = "".join([symbol, split_thousands(value)])
edges.append(Edge(v.resource_type, agt, value, val_string))
elif toggle == "price":
total += v.price
p_string = "".join([symbol, str(v.price.quantize(Decimal(".01")))])
edges.append(Edge(v.resource_type, agt, v.price, p_string))
else:
total += | |
c_key.kind() != "Conference":
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
conf = c_key.get()
if email in conf.followedBy:
raise ConflictException(
"You already follow this conference")
if conf.seatsAvailable > 0:
retVal = False
else:
conf.followedBy.append(email)
conf.put()
return BooleanMessage(data=retVal)
# - - - Conference Sessions - - - - - - - - - - - - - - - - - - -
def _createSessionObject(self, request):
""" Create Session Object
If a speaker is specified, check validity and add his key to the session
"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
wsck = request.websafeConferenceKey
del data['websafeKey']
conf_key = ndb.Key(urlsafe=wsck)
conf = conf_key.get()
# check that conference exists
if not conf or conf_key.kind() != 'Conference':
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can update the conference.')
# Create the Session Object from Input
# add default values for those missing (both data model & outbound Message)
for df in SESS_DEFAULTS:
if data[df] in (None, []):
data[df] = SESS_DEFAULTS[df]
setattr(request, df, SESS_DEFAULTS[df])
# convert dates from strings to Date and Time objects respectively
if data['date']:
data['date'] = datetime.strptime(data['date'][:10], "%Y-%m-%d").date()
if data['startTime']:
data['startTime'] = datetime.strptime(data['startTime'][:5], "%H:%M").time()
c_key = conf.key
s_id = Session.allocate_ids(size=1, parent=c_key)[0]
s_key = ndb.Key(Session, s_id, parent=c_key)
data['key'] = s_key
# check if speaker is provided and exists
if data['speaker']:
speaker = self._getSpeaker(data['speaker'])
data['speaker'] = speaker.key
# abort if no speaker
if not speaker:
raise endpoints.NotFoundException('No speaker found with key: %s' % data['speaker'])
# add the task for featured speaker
taskqueue.add(params={'wsck': wsck, 'speaker': speaker.fullName},
url='/tasks/featured_speaker')
del data['websafeConferenceKey']
Session(**data).put()
return self._copySessionToForm(request)
@ndb.transactional(xg=True)
def _updateSessionObject(self, request):
""" Update Session Object. Only conf owner can update.
If a speaker is specified append the session key (urlsafe)
to speaker's featured sessions.
"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# copy SessionForm/ProtoRPC Message into dict
wssk = request.websafeSessionKey
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
k = ndb.Key(urlsafe=wssk)
session = k.get()
# check that conference exists
if not session or k.kind() != 'Session':
raise endpoints.NotFoundException(
'No session found with key: %s' % wssk)
conf = session.conference
wsck = conf.key.urlsafe()
# check that user is owner
if user_id != conf.organizerUserId:
raise endpoints.ForbiddenException(
'Only the owner can update the conference.')
# check if speaker is provided and exists
if data['speaker']:
# abort if speaker
speaker = self._getSpeaker(data['speaker'])
if not speaker:
raise endpoints.NotFoundException('No speaker found with key: %s' % data['speaker'])
# add the task for featured speaker
taskqueue.add(params={'wsck': wsck, 'speaker': speaker.fullName},
url='/tasks/featured_speaker')
for field in request.all_fields():
data = getattr(request, field.name)
# only copy fields where we get data
if data not in (None, []):
# special handling for dates (convert string to Date)
if field.name == 'startTime':
data = datetime.strptime(data, "%H:%M").time()
if field.name == 'date':
data = datetime.strptime(data, "%Y-%m-%d").date()
if field.name == 'speaker':
data = speaker.key
# write to Conference object
setattr(session, field.name, data)
session.put()
return self._copySessionToForm(request)
# Helper to Copy relevant fields from Session to SessionForm."""
def _copySessionToForm(self, sess):
"""Copy relevant fields from Session to SessionForm."""
sf = SessionForm()
for field in sf.all_fields():
if hasattr(sess, field.name):
# convert Date to date string; just copy others
if field.name == 'date':
setattr(sf, field.name, str(getattr(sess, field.name)))
elif field.name == 'speaker':
sp_key = getattr(sess, field.name)
if sp_key:
setattr(sf, field.name, str(sp_key))
elif field.name == 'startTime':
setattr(sf, field.name, str(getattr(sess, field.name)))
else:
setattr(sf, field.name, getattr(sess, field.name))
elif field.name == "websafeKey":
setattr(sf, field.name, sess.key.urlsafe())
# Checks that all required fields are initialized.
sf.check_initialized()
return sf
# Given a conference, return all sessions
@endpoints.method(CONF_GET_REQUEST, SessionForms,
path='conference/sessions/{websafeConferenceKey}',
http_method='GET', name='getConferenceSessions')
def getConferenceSessions(self, request):
"""Return all sessions by conference (by websafeConferenceKey)."""
# get Conference object from request; bail if not found
wsck = request.websafeConferenceKey
conf = ndb.Key(urlsafe=wsck)
if conf.kind() != "Conference":
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
sessions = conf.get().sessions
sessions = sessions.order(Session.date, Session.startTime, Session.name)
# return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(sess)
for sess in sessions])
# Given a conference, return all sessions of a specified type
@endpoints.method(SESS_GET_REQUEST, SessionForms,
path='conference/sessions/{websafeConferenceKey}/type/{typeOfSession}',
http_method='GET', name='getConferenceSessionsByType')
def getConferenceSessionsByType(self, request):
"""Query sessions for a specified type (by websafeConferenceKey)."""
wsck = request.websafeConferenceKey
conf = ndb.Key(urlsafe=wsck)
if not conf:
raise endpoints.NotFoundException(
'No conference found with key: %s' % wsck)
sessions = Session.query(ancestor=conf)
sessions = sessions.filter(Session.typeOfSession == request.typeOfSession)
sessions = sessions.order(Session.date, Session.startTime, Session.name)
return SessionForms(
items=[self._copySessionToForm(sess)
for sess in sessions]
)
@endpoints.method(SP_GET_REQUEST, SessionForms,
path='speakers/{websafeSpeakerKey}/sessions',
http_method='GET', name='getSessionsBySpeaker')
def getSessionsBySpeaker(self, request):
"""Given a speaker, return all sessions given by this particular speaker,
across all conferences (by speaker's fullname).
"""
wsspk = request.websafeSpeakerKey
sp_key = ndb.Key(urlsafe=wsspk)
speaker = sp_key.get()
if not speaker or sp_key.kind() != 'Speaker':
raise endpoints.NotFoundException(
'No speaker found by the key: %s' % wsspk)
sessions = speaker.featuredSessions.fetch()
return SessionForms(
items=[self._copySessionToForm(sess)
for sess in sessions]
)
# Update Session Endpoint
@endpoints.method(SESS_PUT_REQUEST, SessionForm,
path='conference/sessions/update/{websafeSessionKey}',
http_method='PUT', name='updateSession')
def updateSession(self, request):
"""Update a session in conference (by websafeConferenceKey, websafeSessionKey)."""
return self._updateSessionObject(request)
@endpoints.method(SESS_POST_REQUEST, SessionForm,
path='conference/sessions/{websafeConferenceKey}',
http_method='POST', name='createSession')
def createSession(self, request):
"""Create new session in conference (by websafeConferenceKey)."""
return self._createSessionObject(request)
# Return all sessions which are not workshop and are before 7 AM.
@endpoints.method(message_types.VoidMessage, SessionForms,
path='sessions/query',
http_method='GET', name='getSessionsProblematicQuery')
def getSessionsProblematicQuery(self, request):
"""Query sessions with two inequallite filters"""
q = Session.query()
# get time limits
time_up = datetime.strptime('19:00', '%H:%M').time()
# ndb filter one inequality ( typeOfSession)
q = q.filter(Session.typeOfSession != "workshop")
# This has to be first
q = q.order(Session.typeOfSession)
q = q.order(Session.date, Session.startTime, Session.name)
# filter out sessions by time limits
sessions = [sess for sess in q if sess.startTime and sess.startTime < time_up]
return SessionForms(items=[self._copySessionToForm(sess)
for sess in sessions])
@endpoints.method(USER_SESSIONS_POST, SessionForms,
path='sessions/schedule',
http_method='GET', name='getUserSessionsSchedule')
def getUserSessionsSchedule(self, request):
"""query sessions given a date for conferences the user has registered"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
p_key = ndb.Key(Profile, user_id)
profile = p_key.get()
c_keys = [ndb.Key(urlsafe=wsck) for wsck in profile.conferenceKeysToAttend]
confs = ndb.get_multi(c_keys)
if not confs:
raise endpoints.NotFoundException('You haven\'t registered in any conference')
q = Session.query()
date = datetime.strptime(request.date[:10], "%Y-%m-%d").date()
# if given 2 dates search in date range, else only for that specific day
if request.dateTo:
dateTo = datetime.strptime(request.dateTo[:10], "%Y-%m-%d").date()
q = q.filter(Session.date >= date)
q = q.filter(Session.date <= dateTo)
else:
q = q.filter(Session.date == date)
q = q.order(Session.date, Session.startTime, Session.name)
# filter sessions
sessions = [sess for sess in q if sess.key.parent() in c_keys]
return SessionForms(
items=[self._copySessionToForm(sess)
for sess in sessions]
)
# confs = [conf for conf in confs if conf.startDate <= date and conf.endDate >= date]
# - - - Speaker - - - - - - - - - - - - - - - - - - -
# helper used on create session
def _getSpeaker(self, wsspk):
"""Get Speaker from datastore
If the speaker doesn't exist create an entry
return:
Speaker
"""
k = ndb.Key(urlsafe=wsspk)
sp = k.get()
# check if key provided is a Speaker Key
if k.kind() != 'Speaker':
raise endpoints.NotFoundException("No speaker with key %s" % wsspk)
# return Speaker
return sp
# used from PUT and POST speaker endpoints
def _createSpeakerObject(self, request):
"""Create SpeakerObject"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.fullName:
raise endpoints.BadRequestException("Speaker's 'fullName' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
del data['websafeKey']
sp_id = Speaker.allocate_ids(size=1)[0]
sp_key = ndb.Key(Speaker, sp_id)
data['key'] = sp_key
# create Conference, send email to organizer confirming
# creation of Conference & return (modified) ConferenceForm
Speaker(**data).put()
return self._copySpeakerToForm(request)
def _copySpeakerToForm(self, speaker):
"""Copy relevant fields from Session to SessionForm."""
sf = SpeakerForm()
for field in sf.all_fields():
if hasattr(speaker, field.name):
setattr(sf, field.name, getattr(speaker, field.name))
elif field.name == "websafeKey":
setattr(sf, field.name, speaker.key.urlsafe())
sf.check_initialized()
return sf
@staticmethod
def _cacheFeaturedSpeaker(wsck, speakers_name):
"""Create Featured Speaker & assign to memcache; used by
getFeaturedSpeaker().
"""
# | |
1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-2', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-3', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-3', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-4', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-4', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-5', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-5', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-6', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-6', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-7', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-7', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-8', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-8', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-9', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-9', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-10', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-10', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-11', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-11', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-12', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-12', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-13', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-13', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Tu-22ME', 'Shipwreck 2-14', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Shipwreck 2-14', '2 Kh-22MP;1 Kh-22MP;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-1', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-1', '4 R-27R;2 R-77;4 R-27R;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-2', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-2', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-3', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-3', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-4', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-4', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-5', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-5', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-6', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-6', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-7', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-7', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-8', 2)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-8', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-9', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-9', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-10', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-10', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-11', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-11', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-12', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-12', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-13', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-13', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-14', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-14', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-15', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-15', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-16', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-16', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-17', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-17', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-18', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-18', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-19', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-19', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-20', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-20', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-21', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-21', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-22', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-22', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-23', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-23', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
SM.AddUnitToFlightDeck('Kevlavik', 'Su-27', 'Wall-24', 1)
SM.SetFlightDeckUnitLoadout('Kevlavik', 'Wall-24', '3 Kh-31P;2 R-77;4 Kh-31P;25 Flare-1;25 Chaff-1;')
FP = UI.GetFlightPortInfo()
base_track = UI.GetTrackById(UI.GetPlatformId())
mission_id = FP.AddGenericMission()
FP.AddAircraftToMission(mission_id, 'Wall-1')
FP.AddAircraftToMission(mission_id, 'Wall-2')
FP.AddAircraftToMission(mission_id, 'Wall-3')
FP.AddAircraftToMission(mission_id, 'Wall-4')
FP.AddAircraftToMission(mission_id, 'Wall-5')
FP.AddAircraftToMission(mission_id, 'Wall-6')
FP.AddAircraftToMission(mission_id, 'Wall-7')
FP.AddAircraftToMission(mission_id, 'Wall-8')
FP.AddAircraftToMission(mission_id, 'Wall-9')
FP.AddAircraftToMission(mission_id, 'Wall-10')
FP.AddAircraftToMission(mission_id, 'Wall-11')
FP.AddAircraftToMission(mission_id, 'Wall-12')
FP.SetMissionLaunchTime(mission_id, '13:00:08+0m+R2.0')
FP.SetMissionDatum(mission_id, 0.0000000, 0.0000000)
FP.SetMissionLandingTarget(mission_id, '')
FP.SetMissionWaveQuantity(mission_id, 4)
FP.SetMissionType(mission_id, '')
FP.SetMissionPatrolArea(mission_id, '-0.3966131,1.1144481,-0.3817177,1.1139344,-0.3817177,1.1113020,-0.3957142,1.1115075,')
FP.AddMissionWaypointAdvanced(mission_id, -0.3888970, 1.1164531, 2000.0, 200.0)
FP.SetMissionWaypointTasks(mission_id, 0, 'WaitForGroup,EngageAll')
FP.AddMissionWaypointAdvanced(mission_id, -0.3895190, 1.1136150, 3000.0, 300.0)
FP.SetMissionWaypointTasks(mission_id, 1, 'AirPatrolArea,EngageAll')
mission_id = FP.AddGenericMission()
FP.AddAircraftToMission(mission_id, 'Wall-13')
FP.AddAircraftToMission(mission_id, 'Wall-14')
FP.AddAircraftToMission(mission_id, 'Wall-15')
FP.AddAircraftToMission(mission_id, 'Wall-16')
FP.AddAircraftToMission(mission_id, 'Wall-17')
FP.AddAircraftToMission(mission_id, 'Wall-18')
FP.AddAircraftToMission(mission_id, 'Wall-19')
FP.AddAircraftToMission(mission_id, 'Wall-20')
FP.AddAircraftToMission(mission_id, 'Wall-21')
FP.AddAircraftToMission(mission_id, 'Wall-22')
FP.AddAircraftToMission(mission_id, 'Wall-23')
FP.AddAircraftToMission(mission_id, 'Wall-24')
FP.SetMissionLaunchTime(mission_id, '13:00:08+0m+R2.0')
FP.SetMissionDatum(mission_id, 0.0000000, 0.0000000)
FP.SetMissionLandingTarget(mission_id, '')
FP.SetMissionWaveQuantity(mission_id, 4)
FP.SetMissionType(mission_id, '')
FP.SetMissionPatrolArea(mission_id, '0.0035024,0.0001601,0.0035684,-0.0008994,-0.0032615,0.0005575,-0.0024091,0.0014547,')
FP.SetMissionPatrolAnchor(mission_id, 'Kevlavik', 2)
FP.AddMissionWaypointAdvanced(mission_id, -0.3888970, 1.1164531, 2000.0, 200.0)
FP.SetMissionWaypointTasks(mission_id, 0, 'WaitForGroup,EngageAll')
FP.AddMissionWaypointAdvanced(mission_id, -0.3901000, 1.1150531, 3000.0, 300.0)
FP.SetMissionWaypointTasks(mission_id, 1, 'AirPatrolArea,EngageAll')
mission_id = FP.AddGenericMission()
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-15')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-6')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-7')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-8')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-9')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-10')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-11')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-12')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-13')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-14')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-15')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-16')
FP.SetMissionLaunchTime(mission_id, '13:00:08+0m+R2.0')
FP.SetMissionDatum(mission_id, 0.0000000, 0.0000000)
FP.SetMissionLandingTarget(mission_id, '')
FP.SetMissionWaveQuantity(mission_id, 4)
FP.SetMissionType(mission_id, 'Standby-ASuW')
mission_id = FP.AddGenericMission()
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-16')
FP.AddAircraftToMission(mission_id, 'Shipwreck 1-20')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-1')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-2')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-3')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-4')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-5')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-6')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-7')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-8')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-9')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-10')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-11')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-12')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-13')
FP.AddAircraftToMission(mission_id, 'Shipwreck 2-14')
FP.SetMissionLaunchTime(mission_id, '12:00:08+0m+R2.0')
FP.SetMissionDatum(mission_id, 0.0000000, 0.0000000)
FP.SetMissionLandingTarget(mission_id, '')
FP.SetMissionWaveQuantity(mission_id, 8)
FP.SetMissionType(mission_id, 'Standby-ASuW')
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "Hammer 1"
unit.SetPosition(-32.584050, 55.516823, 14000.0)
unit.heading = 66.29
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.030556')
BB.Write('StationLongitude', '-0.392433')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "Hammer 2"
unit.SetPosition(-32.168371, 55.198724, 14000.0)
unit.heading = 66.29
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.028579')
BB.Write('StationLongitude', '-0.377806')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "Hammer 4"
unit.SetPosition(-32.128469, 55.697659, 14000.0)
unit.heading = 66.29
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.036880')
BB.Write('StationLongitude', '-0.400791')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "Hammer 3"
unit.SetPosition(-31.673336, 55.422092, 14000.0)
unit.heading = 66.29
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.032137')
BB.Write('StationLongitude', '-0.404274')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "Hammer 7"
unit.SetPosition(-16.107389, 55.375940, 14000.0)
unit.heading = 312.62
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.030348')
BB.Write('StationLongitude', '-0.333093')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "<NAME>"
unit.SetPosition(-16.225302, 54.909432, 14000.0)
unit.heading = 312.62
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.026914')
BB.Write('StationLongitude', '-0.337174')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "<NAME>"
unit.SetPosition(-15.432983, 55.408261, 14000.0)
unit.heading = 312.62
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.033322')
BB.Write('StationLongitude', '-0.301887')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "Hammer 6"
unit.SetPosition(-15.233573, 54.814413, 14000.0)
unit.heading = 312.62
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.025417')
BB.Write('StationLongitude', '-0.294922')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName = "<NAME>"
unit.SetPosition(-9.785666, 64.295426, 14000.0)
unit.heading = 253.54
unit.speed = 877.7
SM.AddUnitToAlliance(unit, 2)
SM.SetUnitLauncherItem(unit.unitName, 0, 'Kh-22M', 2)
SM.SetUnitLauncherItem(unit.unitName, 1, 'Kh-22M', 1)
SM.SetUnitLauncherItem(unit.unitName, 2, 'Flare-1', 25)
SM.SetUnitLauncherItem(unit.unitName, 3, 'Chaff-1', 25)
UI = SM.GetUnitInterface(unit.unitName)
UI.AddTask('AirEvade', 3.000000, 3)
UI.AddTask('EngageAll', 2.000000, 0)
UI.AddTask('PatrolCircle', 1.000000, 0)
UI.AddTask('RTB', 2.000000, 3)
BB = UI.GetBlackboardInterface()
BB.Write('StationLatitude', '1.066212')
BB.Write('StationLongitude', '-0.358760')
UI.SetThrottle(0.338669)
unit = SM.GetDefaultUnit()
unit.className = 'Tu-22ME'
unit.unitName | |
\text{other})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
other : Union[dragon.vm.torch.Tensor, number]
The tensor to compare.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _binary_func(input, other, 'Equal', out)
def exp(input, out=None):
r"""Compute the exponential of input.
.. math:: \text{out} = \exp(\text{input})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'Exp', out)
def floor(input, out=None):
r"""Compute the largest integer not greater than input.
.. math:: \text{out} = \lfloor \text{input} \rfloor
Examples:
```python
x = torch.tensor([0.9, 1.4, 1.9])
print(torch.floor(x)) # [0., 1., 1.]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'Floor', out)
def ge(input, other, out=None):
r"""Compute the element-wise greater-equal comparison.
.. math:: \text{out} = (\text{input} \geq \text{other})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
other : Union[dragon.vm.torch.Tensor, number]
The tensor to compare.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _binary_func(input, other, 'GreaterEqual', out)
def gt(input, other, out=None):
r"""Compute the element-wise greater comparison.
.. math:: \text{out} = (\text{input} > \text{other})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
other : Union[dragon.vm.torch.Tensor, number]
The tensor to compare.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output byte tensor.
"""
return _binary_func(input, other, 'Greater', out)
def isfinite(input):
r"""Check if the elements of input are finite.
.. math:: \text{out} = \text{isfinite}(\text{input})
Examples:
```python
x = torch.tensor([0., float('nan'), float('inf')])
print(torch.isfinite(x)) # [True, False, False]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'IsFinite')
def isinf(input):
r"""Check if the elements of input are infinite.
.. math:: \text{out} = \text{isinf}(\text{input})
Examples:
```python
x = torch.tensor([0., 1., float('inf')])
print(torch.isinf(x)) # [False, False, True]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'IsInf')
def isnan(input):
r"""Check if the elements of input are NaN.
.. math:: \text{out} = \text{isnan}(\text{input})
Examples:
```python
x = torch.tensor([0., 1., float('nan')])
print(torch.isnan(x)) # [False, False, True]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'IsNaN')
def le(input, other, out=None):
r"""Compute the element-wise less-equal comparison.
.. math:: \text{out} = (\text{input} \leq \text{other})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
other : Union[dragon.vm.torch.Tensor, number]
The tensor to compare.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output byte tensor.
"""
return _binary_func(input, other, 'LessEqual', out)
def log(input, out=None):
r"""Compute the natural logarithm of input.
.. math:: \text{out} = \log(\text{input})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'Log', out)
def logical_and(input, other, out=None):
r"""Compute the element-wise AND logical operation.
.. math:: \text{out} = \text{input} \mathbin{\&} \text{other}
Examples:
```python
a = torch.tensor([False, True, False, True])
b = torch.tensor([False, True, True, False])
c = torch.Tensor([0, 1, 0, 2])
d = torch.Tensor([0, 3, 4, 0])
print(torch.logical_and(a, b)) # [False, True, False, False]
print(torch.logical_and(c, d)) # [False, True, False, False]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The first input tensor.
other : dragon.vm.torch.Tensor
The second input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _binary_func(input, other, 'And', out)
def logical_not(input, out=None):
r"""Compute the element-wise NOT logical operation.
.. math:: \text{out} = \,\,\sim \text{input}
Examples:
```python
a = torch.tensor([False, True, True])
b = torch.tensor([0, 1, 2])
print(torch.logical_not(a)) # [True, False, False]
print(torch.logical_not(b)) # [True, False, False]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _unary_func(input, 'Not', out)
def logical_or(input, other, out=None):
r"""Compute the element-wise OR logical operation.
.. math:: \text{out} = \text{input} \mathbin{|} \text{other}
Examples:
```python
a = torch.tensor([False, True, False, True])
b = torch.tensor([False, True, True, False])
c = torch.Tensor([0, 1, 0, 2])
d = torch.Tensor([0, 3, 4, 0])
print(torch.logical_or(a, b)) # [False, True, True, True]
print(torch.logical_or(c, d)) # [False, True, True, True]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The first input tensor.
other : dragon.vm.torch.Tensor
The second input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _binary_func(input, other, 'Or', out)
def logical_xor(input, other, out=None):
r"""Compute the element-wise XOR logical operation.
.. math:: \text{out} = \text{input} \oplus \text{other}
Examples:
```python
a = torch.tensor([False, True, False, True])
b = torch.tensor([False, True, True, False])
c = torch.Tensor([0, 1, 0, 2])
d = torch.Tensor([0, 3, 4, 0])
print(torch.logical_xor(a, b)) # [False, False, True, True]
print(torch.logical_xor(c, d)) # [False, False, True, True]
```
Parameters
----------
input : dragon.vm.torch.Tensor
The first input tensor.
other : dragon.vm.torch.Tensor
The second input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _binary_func(input, other, 'Xor', out)
def logsumexp(input, dim, keepdim=False, out=None):
r"""Apply the composite of log, sum, and exp to input.
.. math:: \text{out}_{i} = \log\sum_{j}\exp(\text{input}_{ij})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
dim : Union[int, Sequence[int]]
The dimension(s) to reduce.
keepdim : bool, optional, default=False
Whether the output tensor has dim retained or not.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return log(exp(input).sum(dim, keepdim), out)
def lt(input, other, out=None):
r"""Compute the element-wise less comparison.
.. math:: \text{out} = (\text{input} < \text{other})
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
other : Union[dragon.vm.torch.Tensor, number]
The tensor to compare.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output byte tensor.
"""
return _binary_func(input, other, 'Less', out)
def matmul(input, other, out=None):
r"""Compute the matrix multiplication.
.. math:: \text{out} = \text{input} \times \text{other}
The behavior depends on the shape of input tensors:
* If both tensors are 1d, computes the vector product.
* If tensors are 1d and >=2d, computes the vector-matrix multiplication.
* If tensors are >=2d and 1d, computes the matrix-vector multiplication.
* If both tensors are >= 2d, computes the matrix-matrix multiplication.
* If one tensor is >= 3d, applies batching and broadcasting to the computation.
Examples:
```python
# Vector x Vector
a = torch.ones(2)
b = torch.ones(2)
print(torch.matmul(a, b))
# Vector x Matrix
a = torch.ones(2)
b = torch.ones(2, 3)
print(torch.matmul(a, b))
# Matrix x Vector
a = torch.ones(3, 2)
b = torch.ones(2)
print(torch.matmul(a, b))
# Matrix x Matrix
a = torch.ones(2, 3)
b = torch.ones(3, 2)
print(torch.matmul(a, b))
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
other : dragon.vm.torch.Tensor
The tensor to multiply.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return Function.apply(
'MatMul', input.device, [input, other], outputs=[out])
def max(input, dim=None, keepdim=False, out=None):
"""Compute the max value of elements along the given dimension.
:attr:`dim` could be negative or ``None``:
```python
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
# A negative dimension is the last-k dimension
print(torch.max(x, dim=1))
print(torch.max(x, dim=-1)) # Equivalent
# If dimension is None, reduce input as a vector
# and return a scalar result
print(torch.max(x)) # 6
# Also, dimension could be a sequence of integers
print(torch.max(x, (0, 1))) # 6
```
Parameters
----------
input : dragon.vm.torch.Tensor
The input tensor.
dim : Union[int, Sequence[int]], optional
The dimension to reduce.
keepdim : bool, optional, default=False
Keep the reduced dimension or not.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
keepdim = keepdim if dim is not None else False
dim = nest.flatten(dim) if dim is not None else dim
return Function.apply(
'ReduceMax', input.device, [input], outputs=[out],
axes=dim, keepdims=keepdim)
def maximum(input, other, out=None):
r"""Compute the maximum value of inputs.
.. math:: \text{out} = \max(\text{input}, \text{other})
Parameters
----------
input : Union[dragon.vm.torch.Tensor, number]
The first input tensor.
other : Union[dragon.vm.torch.Tensor, number]
The second input tensor.
out : dragon.vm.torch.Tensor, optional
The output tensor.
Returns
-------
dragon.vm.torch.Tensor
The output tensor.
"""
return _binary_func(input, | |
import argparse
import sys
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import re
from collections import defaultdict
from math import log10
import matplotlib.patches as mpatches
import statistics
NO_THREADS_BASELINE = "DEFAULT"
def main():
font = {'font.family': 'normal',
# 'font.weight' : 'bold',
'font.size': 18}
plt.rcParams.update(font)
blue_patch = mpatches.Patch(color='blue', label='Original')
x_ticks_labels = ['f', 'fa', 'd', 'da']
# set parameters for original-to-implementation comparison for all three logs
chosen_delta = 0.01
chosen_alpha = 0.99
chosen_epsilon = 0.01
chosen_k = 0.2
# BPI 2012#
bpi2012_baseline = pd.read_csv("./csv/BPI_Challenge_2012_baseline.csv", sep=';')
bpi2012_fitness = pd.read_csv("./csv/BPI_Challenge_2012_fitness.csv", sep=';')
bpi2012_fitnessApprox = pd.read_csv("./csv/BPI_Challenge_2012_fitnessApprox.csv", sep=';')
bpi2012_deviations = pd.read_csv("./csv/BPI_Challenge_2012_deviations.csv", sep=';')
bpi2012_deviationsApprox = pd.read_csv("./csv/BPI_Challenge_2012_deviationsApprox.csv", sep=';')
bpi2012_fitness = bpi2012_fitness.loc[
(bpi2012_fitness["delta"] == chosen_delta) & (bpi2012_fitness["alpha"] == chosen_alpha) & (
bpi2012_fitness["epsilon"] == chosen_epsilon)]
bpi2012_fitnessApprox = bpi2012_fitnessApprox.loc[
(bpi2012_fitnessApprox["delta"] == chosen_delta) & (bpi2012_fitnessApprox["alpha"] == chosen_alpha) & (
bpi2012_fitnessApprox["epsilon"] == chosen_epsilon) & (bpi2012_fitnessApprox["k"] == chosen_k)]
bpi2012_deviations = bpi2012_deviations.loc[
(bpi2012_deviations["delta"] == chosen_delta) & (bpi2012_deviations["alpha"] == chosen_alpha) & (
bpi2012_deviations["epsilon"] == chosen_epsilon)]
bpi2012_deviationsApprox = bpi2012_deviationsApprox.loc[
(bpi2012_deviationsApprox["delta"] == chosen_delta) & (bpi2012_deviationsApprox["alpha"] == chosen_alpha) & (
bpi2012_deviationsApprox["epsilon"] == chosen_epsilon) & (
bpi2012_deviationsApprox["k"] == chosen_k) & (
bpi2012_deviationsApprox["approximationMode"] == "NONALIGNING_KNOWN")]
# BPI 2014#
bpi2014_baseline = pd.read_csv("./csv/Detail_Incident_Activity_baseline.csv", sep=';')
bpi2014_fitness = pd.read_csv("./csv/Detail_Incident_Activity_fitness.csv", sep=';')
bpi2014_fitnessApprox = pd.read_csv("./csv/Detail_Incident_Activity_fitnessApprox.csv", sep=';')
bpi2014_deviations = pd.read_csv("./csv/Detail_Incident_Activity_deviations.csv", sep=';')
bpi2014_deviationsApprox = pd.read_csv("./csv/Detail_Incident_Activity_deviationsApprox.csv", sep=';')
bpi2014_fitness = bpi2014_fitness.loc[
(bpi2014_fitness["delta"] == chosen_delta) & (bpi2014_fitness["alpha"] == chosen_alpha) & (
bpi2014_fitness["epsilon"] == chosen_epsilon)]
bpi2014_fitnessApprox = bpi2014_fitnessApprox.loc[
(bpi2014_fitnessApprox["delta"] == chosen_delta) & (bpi2014_fitnessApprox["alpha"] == chosen_alpha) & (
bpi2014_fitnessApprox["epsilon"] == chosen_epsilon) & (bpi2014_fitnessApprox["k"] == chosen_k)]
bpi2014_deviations = bpi2014_deviations.loc[
(bpi2014_deviations["delta"] == chosen_delta) & (bpi2014_deviations["alpha"] == chosen_alpha) & (
bpi2014_deviations["epsilon"] == chosen_epsilon)]
bpi2014_deviationsApprox = bpi2014_deviationsApprox.loc[
(bpi2014_deviationsApprox["delta"] == chosen_delta) & (bpi2014_deviationsApprox["alpha"] == chosen_alpha) & (
bpi2014_deviationsApprox["epsilon"] == chosen_epsilon) & (
bpi2014_deviationsApprox["k"] == chosen_k) & (
bpi2014_deviationsApprox["approximationMode"] == "NONALIGNING_KNOWN")]
# road traffic fines
road_traffic_baseline = pd.read_csv("./csv/Road_Traffic_Fines_Management_Process_baseline.csv",
sep=';')
road_traffic_fitness = pd.read_csv("./csv/Road_Traffic_Fines_Management_Process_fitness.csv", sep=';')
road_traffic_fitnessApprox = pd.read_csv(
"./csv/Road_Traffic_Fines_Management_Process_fitnessApprox.csv", sep=';')
road_traffic_deviations = pd.read_csv("./csv/Road_Traffic_Fines_Management_Process_deviations.csv",
sep=';')
road_traffic_deviationsApprox = pd.read_csv(
"./csv/Road_Traffic_Fines_Management_Process_deviationsApprox.csv", sep=';')
road_traffic_fitness = road_traffic_fitness.loc[
(road_traffic_fitness["delta"] == chosen_delta) & (road_traffic_fitness["alpha"] == chosen_alpha) & (
road_traffic_fitness["epsilon"] == chosen_epsilon)]
road_traffic_fitnessApprox = road_traffic_fitnessApprox.loc[
(road_traffic_fitnessApprox["delta"] == chosen_delta) & (
road_traffic_fitnessApprox["alpha"] == chosen_alpha) & (
road_traffic_fitnessApprox["epsilon"] == chosen_epsilon) & (
road_traffic_fitnessApprox["k"] == chosen_k)]
road_traffic_deviations = road_traffic_deviations.loc[
(road_traffic_deviations["delta"] == chosen_delta) & (road_traffic_deviations["alpha"] == chosen_alpha) & (
road_traffic_deviations["epsilon"] == chosen_epsilon)]
road_traffic_deviationsApprox = road_traffic_deviationsApprox.loc[
(road_traffic_deviationsApprox["delta"] == chosen_delta) & (
road_traffic_deviationsApprox["alpha"] == chosen_alpha) & (
road_traffic_deviationsApprox["epsilon"] == chosen_epsilon) & (
road_traffic_deviationsApprox["k"] == chosen_k) & (
road_traffic_deviationsApprox["approximationMode"] == "NONALIGNING_KNOWN")]
#reference road traffic fines
rdRTF_baseline = pd.read_csv("./csv/RTFM_model2_baseline.csv",
sep=';')
rdRTF_fitness = pd.read_csv("./csv/RTFM_model2_fitness.csv", sep=';')
rdRTF_fitnessApprox = pd.read_csv(
"./csv/RTFM_model2_fitnessApprox.csv", sep=';')
rdRTF_deviations = pd.read_csv("./csv/RTFM_model2_deviations.csv",
sep=';')
rdRTF_deviationsApprox = pd.read_csv(
"./csv/RTFM_model2_deviationsApprox.csv", sep=';')
rdRTF_fitness = rdRTF_fitness.loc[
(rdRTF_fitness["delta"] == chosen_delta) & (rdRTF_fitness["alpha"] == chosen_alpha) & (
rdRTF_fitness["epsilon"] == chosen_epsilon)]
rdRTF_fitnessApprox = rdRTF_fitnessApprox.loc[
(rdRTF_fitnessApprox["delta"] == chosen_delta) & (
rdRTF_fitnessApprox["alpha"] == chosen_alpha) & (
rdRTF_fitnessApprox["epsilon"] == chosen_epsilon) & (
rdRTF_fitnessApprox["k"] == chosen_k)]
rdRTF_deviations = rdRTF_deviations.loc[
(rdRTF_deviations["delta"] == chosen_delta) & (rdRTF_deviations["alpha"] == chosen_alpha) & (
rdRTF_deviations["epsilon"] == chosen_epsilon)]
rdRTF_deviationsApprox = rdRTF_deviationsApprox.loc[
(rdRTF_deviationsApprox["delta"] == chosen_delta) & (
rdRTF_deviationsApprox["alpha"] == chosen_alpha) & (
rdRTF_deviationsApprox["epsilon"] == chosen_epsilon) & (
rdRTF_deviationsApprox["k"] == chosen_k) & (
rdRTF_deviationsApprox["approximationMode"] == "NONALIGNING_KNOWN")]
# plot computing time comparisons
bpi2012_orig_mean = bpi2012_baseline["time"].mean()
bpi2012_list = []
bpi2012_list.append(bpi2012_fitness["time"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_fitnessApprox["time"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviations["time"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviationsApprox["time"].values / bpi2012_orig_mean)
bpi2014_orig_mean = bpi2014_baseline["time"].mean()
bpi2014_list = []
bpi2014_list.append(bpi2014_fitness["time"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_fitnessApprox["time"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviations["time"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviationsApprox["time"].values / bpi2014_orig_mean)
road_traffic_orig_mean = road_traffic_baseline["time"].mean()
road_traffic_list = []
road_traffic_list.append(road_traffic_fitness["time"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_fitnessApprox["time"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviations["time"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviationsApprox["time"].values / road_traffic_orig_mean)
f, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True)
ax1.set_yscale('log')
ax1.set_ylabel('Runtime (relative)')
ax1.set_ylim(0.0007, 10)
ax1.set_yticks([0.001, 0.01, 0.1, 1.0])
ax1.set_yticklabels(["0.1%", "1%", "10%", "100%"])
ax1.set_title('BPI-12', fontsize=18)
ax1.boxplot(bpi2012_list)
# print(bpi2012_list)
# ax1.axhline(1, color='b', linestyle='--')
ax1.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4, width=1)
ax2.set_title('BPI-14', fontsize=18)
ax2.boxplot(bpi2014_list)
# ax2.axhline(1, color='b', linestyle='--')
ax2.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4, width=1)
ax3.set_title('Traffic Fines', fontsize=18)
ax3.boxplot(road_traffic_list)
# ax3.axhline(1, color='b', linestyle='--')
ax3.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax3.tick_params(length=6, width=2)
ax3.tick_params(which='minor', length=4, width=1)
#f.show()
f.savefig("./real_computing_time.pdf", bbox_inches='tight')
plt.clf()
# plot sampled trace comparisons
bpi2012_orig_mean = bpi2012_baseline["logSize"].mean()
bpi2012_list = []
bpi2012_list.append(bpi2012_fitness["logSize"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_fitnessApprox["logSize"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviations["logSize"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviationsApprox["logSize"].values / bpi2012_orig_mean)
bpi2014_orig_mean = bpi2014_baseline["logSize"].mean()
bpi2014_list = []
bpi2014_list.append(bpi2014_fitness["logSize"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_fitnessApprox["logSize"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviations["logSize"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviationsApprox["logSize"].values / bpi2014_orig_mean)
road_traffic_orig_mean = road_traffic_baseline["logSize"].mean()
road_traffic_list = []
road_traffic_list.append(road_traffic_fitness["logSize"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_fitnessApprox["logSize"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviations["logSize"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviationsApprox["logSize"].values / road_traffic_orig_mean)
f, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True)
# f.legend(handles=[blue_patch],loc='upper right')
# f.set_size_inches(6,5)
ax1.set_yscale('log')
ax1.set_ylabel('Sampled traces')
ax1.set_ylim(0.0007, 3)
ax1.set_yticks([0.001, 0.01, 0.1, 1.0])
ax1.set_yticklabels(["0.1%", "1%", "10%", "100%"])
ax1.set_title('BPI-12', fontsize=18)
ax1.boxplot(bpi2012_list)
# ax1.axhline(1, color='b', linestyle='--')
ax1.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4, width=1)
ax2.set_title('BPI-14', fontsize=18)
ax2.boxplot(bpi2014_list)
# ax2.axhline(1, color='b', linestyle='--')
ax2.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4, width=1)
ax3.set_title('Traffic Fines', fontsize=18)
ax3.boxplot(road_traffic_list)
# ax3.axhline(1, color='b', linestyle='--')
ax3.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax3.tick_params(length=6, width=2)
ax3.tick_params(which='minor', length=4, width=1)
#f.show()
f.savefig("./real_traces.pdf", bbox_inches='tight')
plt.clf()
# plot fitness comparisons
bpi2012_orig_mean = bpi2012_baseline["fitness"].mean()
bpi2012_list = []
bpi2012_list.append(bpi2012_fitness["fitness"].values)
bpi2012_list.append(bpi2012_fitnessApprox["fitness"].values)
bpi2014_orig_mean = bpi2014_baseline["fitness"].mean()
bpi2014_list = []
bpi2014_list.append(bpi2014_fitness["fitness"].values)
bpi2014_list.append(bpi2014_fitnessApprox["fitness"].values)
road_traffic_orig_mean = road_traffic_baseline["fitness"].mean()
road_traffic_list = []
road_traffic_list.append(road_traffic_fitness["fitness"].values)
road_traffic_list.append(road_traffic_fitnessApprox["fitness"].values)
f, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True)
# f.set_size_inches(6,4)
# f.legend(handles=[blue_patch],loc='upper right')
ax1.set_ylabel('Fitness')
ax1.set_yticks([0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
ax1.set_ylim(0.49, 1.01)
ax1.boxplot(bpi2012_list)
ax1.axhline(bpi2012_orig_mean, color='b', linestyle='--')
ax1.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4, width=1)
ax1.set_title('BPI-12', fontsize=18)
ax2.boxplot(bpi2014_list)
ax2.axhline(bpi2014_orig_mean, color='b', linestyle='--')
ax2.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4, width=1)
ax2.set_title('BPI-14', fontsize=18)
ax3.boxplot(road_traffic_list)
ax3.axhline(road_traffic_orig_mean, color='b', linestyle='--')
ax3.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax3.tick_params(length=6, width=2)
ax3.tick_params(which='minor', length=4, width=1)
ax3.set_title('Traffic Fines', fontsize=18)
#f.show()
f.savefig("./real_fitness.pdf", bbox_inches='tight')
plt.clf()
#construct plots for all 4 datasets
bpi2012_orig_mean = bpi2012_baseline["time"].mean()
bpi2012_list = []
bpi2012_list.append(bpi2012_fitness["time"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_fitnessApprox["time"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviations["time"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviationsApprox["time"].values / bpi2012_orig_mean)
bpi2014_orig_mean = bpi2014_baseline["time"].mean()
bpi2014_list = []
bpi2014_list.append(bpi2014_fitness["time"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_fitnessApprox["time"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviations["time"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviationsApprox["time"].values / bpi2014_orig_mean)
road_traffic_orig_mean = road_traffic_baseline["time"].mean()
road_traffic_list = []
road_traffic_list.append(road_traffic_fitness["time"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_fitnessApprox["time"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviations["time"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviationsApprox["time"].values / road_traffic_orig_mean)
rdRTF_orig_mean = rdRTF_baseline["time"].mean()
rdRTF_list = []
rdRTF_list.append(rdRTF_fitness["time"].values / rdRTF_orig_mean)
rdRTF_list.append(rdRTF_fitnessApprox["time"].values / rdRTF_orig_mean)
rdRTF_list.append(rdRTF_deviations["time"].values / rdRTF_orig_mean)
rdRTF_list.append(rdRTF_deviationsApprox["time"].values / rdRTF_orig_mean)
f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, sharey=True)
ax1.set_yscale('log')
ax1.set_ylabel('Runtime (relative)')
ax1.set_ylim(0.0007, 11)
ax1.set_yticks([0.001, 0.01, 0.1, 1.0, 10.0])
ax1.set_yticklabels(["0.1%", "1%", "10%", "100%", "1000%"])
ax1.set_title('BPI-12', fontsize=18)
ax1.boxplot(bpi2012_list)
# print(bpi2012_list)
# ax1.axhline(1, color='b', linestyle='--')
ax1.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4, width=1)
ax2.set_title('BPI-14', fontsize=18)
ax2.boxplot(bpi2014_list)
# ax2.axhline(1, color='b', linestyle='--')
ax2.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4, width=1)
ax3.set_title('RTF', fontsize=18)
ax3.boxplot(road_traffic_list)
# ax3.axhline(1, color='b', linestyle='--')
ax3.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax3.tick_params(length=6, width=2)
ax3.tick_params(which='minor', length=4, width=1)
ax4.set_title('RTFr', fontsize=18)
ax4.boxplot(rdRTF_list)
# ax4.axhline(1, color='b', linestyle='--')
ax4.set_xticklabels(x_ticks_labels, rotation=0, fontsize=18)
ax4.tick_params(length=6, width=2)
ax4.tick_params(which='minor', length=4, width=1)
#f.show()
f.savefig("./real4_computing_time.pdf", bbox_inches='tight')
plt.clf()
bpi2012_orig_mean = bpi2012_baseline["logSize"].mean()
bpi2012_list = []
bpi2012_list.append(bpi2012_fitness["logSize"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_fitnessApprox["logSize"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviations["logSize"].values / bpi2012_orig_mean)
bpi2012_list.append(bpi2012_deviationsApprox["logSize"].values / bpi2012_orig_mean)
bpi2014_orig_mean = bpi2014_baseline["logSize"].mean()
bpi2014_list = []
bpi2014_list.append(bpi2014_fitness["logSize"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_fitnessApprox["logSize"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviations["logSize"].values / bpi2014_orig_mean)
bpi2014_list.append(bpi2014_deviationsApprox["logSize"].values / bpi2014_orig_mean)
road_traffic_orig_mean = road_traffic_baseline["logSize"].mean()
road_traffic_list = []
road_traffic_list.append(road_traffic_fitness["logSize"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_fitnessApprox["logSize"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviations["logSize"].values / road_traffic_orig_mean)
road_traffic_list.append(road_traffic_deviationsApprox["logSize"].values / road_traffic_orig_mean)
rdRTF_orig_mean = rdRTF_baseline["logSize"].mean()
rdRTF_list = []
rdRTF_list.append(rdRTF_fitness["logSize"].values / rdRTF_orig_mean)
rdRTF_list.append(rdRTF_fitnessApprox["logSize"].values / rdRTF_orig_mean)
rdRTF_list.append(rdRTF_deviations["logSize"].values / rdRTF_orig_mean)
rdRTF_list.append(rdRTF_deviationsApprox["logSize"].values / rdRTF_orig_mean)
f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, sharey=True)
# f.legend(handles=[blue_patch],loc='upper right')
# f.set_size_inches(6,5)
ax1.set_yscale('log')
ax1.set_ylabel('Sampled traces')
ax1.set_ylim(0.0007, 3)
ax1.set_yticks([0.001, 0.01, 0.1, 1.0])
ax1.set_yticklabels(["0.1%", "1%", "10%", "100%"])
ax1.set_title('BPI-12', fontsize=18)
ax1.boxplot(bpi2012_list)
# ax1.axhline(1, color='b', linestyle='--')
ax1.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4, width=1)
ax2.set_title('BPI-14', fontsize=18)
ax2.boxplot(bpi2014_list)
# ax2.axhline(1, color='b', linestyle='--')
ax2.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4, width=1)
ax3.set_title('RTF', fontsize=18)
ax3.boxplot(road_traffic_list)
# ax3.axhline(1, color='b', linestyle='--')
ax3.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax3.tick_params(length=6, width=2)
ax3.tick_params(which='minor', length=4, width=1)
ax4.set_title('RTFr', fontsize=18)
ax4.boxplot(rdRTF_list)
# ax4.axhline(1, color='b', linestyle='--')
ax4.set_xticklabels(x_ticks_labels, rotation='horizontal', fontsize=18)
ax4.tick_params(length=6, width=2)
#f.show()
f.savefig("./real4_traces.pdf", bbox_inches='tight')
# plot fitness comparisons
bpi2012_orig_mean = bpi2012_baseline["fitness"].mean()
bpi2012_list = []
bpi2012_list.append(bpi2012_fitness["fitness"].values)
bpi2012_list.append(bpi2012_fitnessApprox["fitness"].values)
bpi2014_orig_mean = bpi2014_baseline["fitness"].mean()
bpi2014_list = []
bpi2014_list.append(bpi2014_fitness["fitness"].values)
bpi2014_list.append(bpi2014_fitnessApprox["fitness"].values)
road_traffic_orig_mean = road_traffic_baseline["fitness"].mean()
road_traffic_list = []
road_traffic_list.append(road_traffic_fitness["fitness"].values)
road_traffic_list.append(road_traffic_fitnessApprox["fitness"].values)
rdRTF_orig_mean = rdRTF_baseline["fitness"].mean()
rdRTF_list = []
rdRTF_list.append(rdRTF_fitness["fitness"].values)
rdRTF_list.append(rdRTF_fitnessApprox["fitness"].values)
f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, sharey=True)
# f.set_size_inches(6,4)
# f.legend(handles=[blue_patch],loc='upper right')
ax1.set_ylabel('Fitness')
ax1.set_yticks([0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
ax1.set_ylim(0.49, 1.01)
ax1.boxplot(bpi2012_list)
ax1.axhline(bpi2012_orig_mean, color='b', linestyle='--')
ax1.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax1.tick_params(length=6, width=2)
ax1.tick_params(which='minor', length=4, width=1)
ax1.set_title('BPI-12', fontsize=18)
ax2.boxplot(bpi2014_list)
ax2.axhline(bpi2014_orig_mean, color='b', linestyle='--')
ax2.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax2.tick_params(length=6, width=2)
ax2.tick_params(which='minor', length=4, width=1)
ax2.set_title('BPI-14', fontsize=18)
ax3.boxplot(road_traffic_list)
ax3.axhline(road_traffic_orig_mean, color='b', linestyle='--')
ax3.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax3.tick_params(length=6, width=2)
ax3.tick_params(which='minor', length=4, width=1)
ax3.set_title('RTF', fontsize=18)
ax4.boxplot(rdRTF_list)
ax4.axhline(rdRTF_orig_mean, color='b', linestyle='--')
ax4.set_xticklabels(x_ticks_labels[:2], rotation='horizontal', fontsize=18)
ax4.tick_params(length=6, width=2)
ax4.tick_params(which='minor', length=4, width=1)
ax4.set_title('RTFr', fontsize=18)
#f.show()
f.savefig("./real4_fitness.pdf", bbox_inches='tight')
def convert_to_log(input):
to_return | |
"metadataonly",
("prop", "1909:9"): "metadataonly",
("prop", "1909:90"): "metadataonly",
("prop", "1909:91"): "metadataonly",
("prop", "1909:92"): "metadataonly",
("prop", "1909:93"): "metadataonly",
("prop", "1909:94"): "metadataonly",
("prop", "1909:95"): "metadataonly",
("prop", "1909:96"): "metadataonly",
("prop", "1909:97"): "metadataonly",
("prop", "1909:98"): "metadataonly",
("prop", "1909:99"): "metadataonly",
("prop", "1910:1"): "metadataonly",
("prop", "1910:10"): "metadataonly",
("prop", "1910:100"): "metadataonly",
("prop", "1910:101"): "metadataonly",
("prop", "1910:102"): "metadataonly",
("prop", "1910:103"): "metadataonly",
("prop", "1910:104"): "metadataonly",
("prop", "1910:105"): "metadataonly",
("prop", "1910:106"): "metadataonly",
("prop", "1910:107"): "metadataonly",
("prop", "1910:108"): "metadataonly",
("prop", "1910:109"): "metadataonly",
("prop", "1910:11"): "metadataonly",
("prop", "1910:110"): "metadataonly",
("prop", "1910:111"): "metadataonly",
("prop", "1910:112"): "metadataonly",
("prop", "1910:113"): "metadataonly",
("prop", "1910:114"): "metadataonly",
("prop", "1910:115"): "metadataonly",
("prop", "1910:116"): "metadataonly",
("prop", "1910:117"): "metadataonly",
("prop", "1910:118"): "metadataonly",
("prop", "1910:119"): "metadataonly",
("prop", "1910:12"): "metadataonly",
("prop", "1910:120"): "metadataonly",
("prop", "1910:121"): "metadataonly",
("prop", "1910:122"): "metadataonly",
("prop", "1910:123"): "metadataonly",
("prop", "1910:124"): "metadataonly",
("prop", "1910:125"): "metadataonly",
("prop", "1910:126"): "metadataonly",
("prop", "1910:127"): "metadataonly",
("prop", "1910:128"): "metadataonly",
("prop", "1910:129"): "metadataonly",
("prop", "1910:13"): "metadataonly",
("prop", "1910:130"): "metadataonly",
("prop", "1910:131"): "metadataonly",
("prop", "1910:132"): "metadataonly",
("prop", "1910:133"): "metadataonly",
("prop", "1910:134"): "metadataonly",
("prop", "1910:135"): "metadataonly",
("prop", "1910:136"): "metadataonly",
("prop", "1910:137"): "metadataonly",
("prop", "1910:138"): "metadataonly",
("prop", "1910:139"): "metadataonly",
("prop", "1910:14"): "metadataonly",
("prop", "1910:140"): "metadataonly",
("prop", "1910:141"): "metadataonly",
("prop", "1910:142"): "metadataonly",
("prop", "1910:143"): "metadataonly",
("prop", "1910:144"): "metadataonly",
("prop", "1910:145"): "metadataonly",
("prop", "1910:146"): "metadataonly",
("prop", "1910:147"): "metadataonly",
("prop", "1910:148"): "metadataonly",
("prop", "1910:149"): "metadataonly",
("prop", "1910:15"): "metadataonly",
("prop", "1910:150"): "metadataonly",
("prop", "1910:151"): "metadataonly",
("prop", "1910:152"): "metadataonly",
("prop", "1910:153"): "metadataonly",
("prop", "1910:154"): "metadataonly",
("prop", "1910:155"): "metadataonly",
("prop", "1910:156"): "metadataonly",
("prop", "1910:157"): "metadataonly",
("prop", "1910:158"): "metadataonly",
("prop", "1910:159"): "metadataonly",
("prop", "1910:16"): "metadataonly",
("prop", "1910:160"): "metadataonly",
("prop", "1910:161"): "metadataonly",
("prop", "1910:162"): "metadataonly",
("prop", "1910:163"): "metadataonly",
("prop", "1910:164"): "metadataonly",
("prop", "1910:165"): "metadataonly",
("prop", "1910:166"): "metadataonly",
("prop", "1910:167"): "metadataonly",
("prop", "1910:168"): "metadataonly",
("prop", "1910:169"): "metadataonly",
("prop", "1910:17"): "metadataonly",
("prop", "1910:170"): "metadataonly",
("prop", "1910:171"): "metadataonly",
("prop", "1910:172"): "metadataonly",
("prop", "1910:173"): "metadataonly",
("prop", "1910:174"): "metadataonly",
("prop", "1910:175"): "metadataonly",
("prop", "1910:176"): "metadataonly",
("prop", "1910:177"): "metadataonly",
("prop", "1910:178"): "metadataonly",
("prop", "1910:179"): "metadataonly",
("prop", "1910:18"): "metadataonly",
("prop", "1910:180"): "metadataonly",
("prop", "1910:181"): "metadataonly",
("prop", "1910:182"): "metadataonly",
("prop", "1910:183"): "metadataonly",
("prop", "1910:184"): "metadataonly",
("prop", "1910:185"): "metadataonly",
("prop", "1910:186"): "metadataonly",
("prop", "1910:187"): "metadataonly",
("prop", "1910:188"): "metadataonly",
("prop", "1910:189"): "metadataonly",
("prop", "1910:19"): "metadataonly",
("prop", "1910:190"): "metadataonly",
("prop", "1910:191"): "metadataonly",
("prop", "1910:194"): "metadataonly",
("prop", "1910:195"): "metadataonly",
("prop", "1910:197"): "metadataonly",
("prop", "1910:198"): "metadataonly",
("prop", "1910:199"): "metadataonly",
("prop", "1910:2"): "metadataonly",
("prop", "1910:200"): "metadataonly",
("prop", "1910:201"): "metadataonly",
("prop", "1910:202"): "metadataonly",
("prop", "1910:203"): "metadataonly",
("prop", "1910:204"): "metadataonly",
("prop", "1910:205"): "metadataonly",
("prop", "1910:206"): "metadataonly",
("prop", "1910:207"): "metadataonly",
("prop", "1910:208"): "metadataonly",
("prop", "1910:209"): "metadataonly",
("prop", "1910:21"): "metadataonly",
("prop", "1910:210"): "metadataonly",
("prop", "1910:211"): "metadataonly",
("prop", "1910:212"): "metadataonly",
("prop", "1910:213"): "metadataonly",
("prop", "1910:214"): "metadataonly",
("prop", "1910:215"): "metadataonly",
("prop", "1910:216"): "metadataonly",
("prop", "1910:217"): "metadataonly",
("prop", "1910:218"): "metadataonly",
("prop", "1910:219"): "metadataonly",
("prop", "1910:22"): "metadataonly",
("prop", "1910:220"): "metadataonly",
("prop", "1910:221"): "metadataonly",
("prop", "1910:222"): "metadataonly",
("prop", "1910:23"): "metadataonly",
("prop", "1910:24"): "metadataonly",
("prop", "1910:25"): "metadataonly",
("prop", "1910:26"): "metadataonly",
("prop", "1910:27"): "metadataonly",
("prop", "1910:28"): "metadataonly",
("prop", "1910:29"): "metadataonly",
("prop", "1910:3"): "metadataonly",
("prop", "1910:30"): "metadataonly",
("prop", "1910:31"): "metadataonly",
("prop", "1910:32"): "metadataonly",
("prop", "1910:33"): "metadataonly",
("prop", "1910:34"): "metadataonly",
("prop", "1910:35"): "metadataonly",
("prop", "1910:36"): "metadataonly",
("prop", "1910:37"): "metadataonly",
("prop", "1910:38"): "metadataonly",
("prop", "1910:39"): "metadataonly",
("prop", "1910:4"): "metadataonly",
("prop", "1910:40"): "metadataonly",
("prop", "1910:41"): "metadataonly",
("prop", "1910:42"): "metadataonly",
("prop", "1910:43"): "metadataonly",
("prop", "1910:44"): "metadataonly",
("prop", "1910:45"): "metadataonly",
("prop", "1910:46"): "metadataonly",
("prop", "1910:47"): "metadataonly",
("prop", "1910:48"): "metadataonly",
("prop", "1910:49"): "metadataonly",
("prop", "1910:5"): "metadataonly",
("prop", "1910:50"): "metadataonly",
("prop", "1910:51"): "metadataonly",
("prop", "1910:52"): "metadataonly",
("prop", "1910:55"): "metadataonly",
("prop", "1910:56"): "metadataonly",
("prop", "1910:57"): "metadataonly",
("prop", "1910:58"): "metadataonly",
("prop", "1910:59"): "metadataonly",
("prop", "1910:6"): "metadataonly",
("prop", "1910:60"): "metadataonly",
("prop", "1910:61"): "metadataonly",
("prop", "1910:62"): "metadataonly",
("prop", "1910:63"): "metadataonly",
("prop", "1910:64"): "metadataonly",
("prop", "1910:65"): "metadataonly",
("prop", "1910:66"): "metadataonly",
("prop", "1910:67"): "metadataonly",
("prop", "1910:68"): "metadataonly",
("prop", "1910:69"): "metadataonly",
("prop", "1910:7"): "metadataonly",
("prop", "1910:70"): "metadataonly",
("prop", "1910:71"): "metadataonly",
("prop", "1910:72"): "metadataonly",
("prop", "1910:73"): "metadataonly",
("prop", "1910:74"): "metadataonly",
("prop", "1910:75"): "metadataonly",
("prop", "1910:76"): "metadataonly",
("prop", "1910:77"): "metadataonly",
("prop", "1910:78"): "metadataonly",
("prop", "1910:79"): "metadataonly",
("prop", "1910:8"): "metadataonly",
("prop", "1910:80"): "metadataonly",
("prop", "1910:81"): "metadataonly",
("prop", "1910:82"): "metadataonly",
("prop", "1910:83"): "metadataonly",
("prop", "1910:84"): "metadataonly",
("prop", "1910:85"): "metadataonly",
("prop", "1910:86"): "metadataonly",
("prop", "1910:87"): "metadataonly",
("prop", "1910:89"): "metadataonly",
("prop", "1910:9"): "metadataonly",
("prop", "1910:91"): "metadataonly",
("prop", "1910:92"): "metadataonly",
("prop", "1910:93"): "metadataonly",
("prop", "1910:94"): "metadataonly",
("prop", "1910:95"): "metadataonly",
("prop", "1910:97"): "metadataonly",
("prop", "1910:98"): "metadataonly",
("prop", "1910:99"): "metadataonly",
("prop", "1911:1"): "metadataonly",
("prop", "1911:10"): "metadataonly",
("prop", "1911:100"): "metadataonly",
("prop", "1911:101"): "metadataonly",
("prop", "1911:102"): "metadataonly",
("prop", "1911:103"): "metadataonly",
("prop", "1911:104"): "metadataonly",
("prop", "1911:105"): "metadataonly",
("prop", "1911:106"): "metadataonly",
("prop", "1911:107"): "metadataonly",
("prop", "1911:108"): "metadataonly",
("prop", "1911:109"): "metadataonly",
("prop", "1911:11"): "metadataonly",
("prop", "1911:110"): "metadataonly",
("prop", "1911:111"): "metadataonly",
("prop", "1911:112"): "metadataonly",
("prop", "1911:113"): "metadataonly",
("prop", "1911:114"): "metadataonly",
("prop", "1911:115"): "metadataonly",
("prop", "1911:116"): "metadataonly",
("prop", "1911:117"): "metadataonly",
("prop", "1911:118"): "metadataonly",
("prop", "1911:119"): "metadataonly",
("prop", "1911:12"): "metadataonly",
("prop", "1911:120"): "metadataonly",
("prop", "1911:121"): "metadataonly",
("prop", "1911:122"): "metadataonly",
("prop", "1911:123"): "metadataonly",
("prop", "1911:124"): "metadataonly",
("prop", "1911:125"): "metadataonly",
("prop", "1911:126"): "metadataonly",
("prop", "1911:127"): "metadataonly",
("prop", "1911:128"): "metadataonly",
("prop", "1911:129"): "metadataonly",
("prop", "1911:13"): "metadataonly",
("prop", "1911:130"): "metadataonly",
("prop", "1911:131"): "metadataonly",
("prop", "1911:132"): "metadataonly",
("prop", "1911:133"): "metadataonly",
("prop", "1911:134"): "metadataonly",
("prop", "1911:135"): "metadataonly",
("prop", "1911:136"): "metadataonly",
("prop", "1911:137"): "metadataonly",
("prop", "1911:138"): "metadataonly",
("prop", "1911:139"): "metadataonly",
("prop", "1911:14"): "metadataonly",
("prop", "1911:140"): "metadataonly",
("prop", "1911:141"): "metadataonly",
("prop", "1911:142"): "metadataonly",
("prop", "1911:143"): "metadataonly",
("prop", "1911:144"): "metadataonly",
("prop", "1911:145"): "metadataonly",
("prop", "1911:146"): "metadataonly",
("prop", "1911:147"): "metadataonly",
("prop", "1911:148"): "metadataonly",
("prop", "1911:149"): "metadataonly",
("prop", "1911:15"): "metadataonly",
("prop", "1911:150"): "metadataonly",
("prop", "1911:151"): "metadataonly",
("prop", "1911:152"): "metadataonly",
("prop", "1911:153"): "metadataonly",
("prop", "1911:154"): "metadataonly",
("prop", "1911:155"): "metadataonly",
("prop", "1911:156"): "metadataonly",
("prop", "1911:157"): "metadataonly",
("prop", "1911:158"): "metadataonly",
("prop", "1911:159"): "metadataonly",
("prop", "1911:16"): "metadataonly",
("prop", "1911:160"): "metadataonly",
("prop", "1911:161"): "metadataonly",
("prop", "1911:162"): "metadataonly",
("prop", "1911:163"): "metadataonly",
("prop", "1911:164"): "metadataonly",
("prop", "1911:165"): "metadataonly",
("prop", "1911:166"): "metadataonly",
("prop", "1911:167"): "metadataonly",
("prop", "1911:168"): "metadataonly",
("prop", "1911:169"): "metadataonly",
("prop", "1911:17"): "metadataonly",
("prop", "1911:170"): "metadataonly",
("prop", "1911:171"): "metadataonly",
("prop", "1911:172"): "metadataonly",
("prop", "1911:173"): "metadataonly",
("prop", "1911:174"): "metadataonly",
("prop", "1911:175"): "metadataonly",
("prop", "1911:176"): "metadataonly",
("prop", "1911:177"): "metadataonly",
("prop", "1911:178"): "metadataonly",
("prop", "1911:179"): "metadataonly",
("prop", "1911:18"): "metadataonly",
("prop", "1911:180"): "metadataonly",
("prop", "1911:181"): "metadataonly",
("prop", "1911:182"): "metadataonly",
("prop", "1911:183"): "metadataonly",
("prop", "1911:184"): "metadataonly",
("prop", "1911:185"): "metadataonly",
("prop", "1911:186"): "metadataonly",
("prop", "1911:187"): "metadataonly",
("prop", "1911:188"): "metadataonly",
("prop", "1911:189"): "metadataonly",
("prop", "1911:19"): "metadataonly",
("prop", "1911:190"): "metadataonly",
("prop", "1911:191"): "metadataonly",
("prop", "1911:192"): "metadataonly",
("prop", "1911:193"): "metadataonly",
("prop", "1911:194"): "metadataonly",
("prop", "1911:195"): "metadataonly",
("prop", "1911:196"): "metadataonly",
("prop", "1911:197"): "metadataonly",
("prop", "1911:198"): "metadataonly",
("prop", "1911:199"): "metadataonly",
("prop", "1911:2"): "metadataonly",
("prop", "1911:20"): "metadataonly",
("prop", "1911:200"): "metadataonly",
("prop", "1911:201"): "metadataonly",
("prop", "1911:202"): "metadataonly",
("prop", "1911:203"): "metadataonly",
("prop", "1911:204"): "metadataonly",
("prop", "1911:205"): "metadataonly",
("prop", "1911:206"): "metadataonly",
("prop", "1911:207"): "metadataonly",
("prop", "1911:208"): "metadataonly",
("prop", "1911:209"): "metadataonly",
("prop", "1911:21"): "metadataonly",
("prop", "1911:210"): "metadataonly",
("prop", "1911:211"): "metadataonly",
("prop", "1911:212"): "metadataonly",
("prop", "1911:213"): "metadataonly",
("prop", "1911:214"): "metadataonly",
("prop", "1911:215"): "metadataonly",
("prop", "1911:216"): "metadataonly",
("prop", "1911:217"): "metadataonly",
("prop", "1911:218"): "metadataonly",
("prop", "1911:219"): "metadataonly",
("prop", "1911:22"): "metadataonly",
("prop", "1911:220"): "metadataonly",
("prop", "1911:221"): "metadataonly",
("prop", "1911:222"): "metadataonly",
("prop", "1911:223"): "metadataonly",
("prop", "1911:224"): "metadataonly",
("prop", "1911:225"): "metadataonly",
("prop", "1911:226"): "metadataonly",
("prop", "1911:227"): "metadataonly",
("prop", "1911:228"): "metadataonly",
("prop", "1911:229"): "metadataonly",
("prop", "1911:23"): "metadataonly",
("prop", "1911:24"): "metadataonly",
("prop", "1911:25"): "metadataonly",
("prop", "1911:26"): "metadataonly",
("prop", "1911:27"): "metadataonly",
("prop", "1911:28"): "metadataonly",
("prop", "1911:29"): "metadataonly",
("prop", "1911:3"): "metadataonly",
("prop", "1911:30"): "metadataonly",
("prop", "1911:31"): "metadataonly",
("prop", "1911:32"): "metadataonly",
("prop", "1911:33"): "metadataonly",
("prop", "1911:34"): "metadataonly",
("prop", "1911:35"): "metadataonly",
("prop", "1911:36"): "metadataonly",
("prop", "1911:37"): "metadataonly",
("prop", "1911:38"): "metadataonly",
("prop", "1911:39"): "metadataonly",
("prop", "1911:4"): "metadataonly",
("prop", "1911:40"): "metadataonly",
("prop", "1911:41"): "metadataonly",
("prop", "1911:42"): "metadataonly",
("prop", "1911:44"): "metadataonly",
("prop", "1911:45"): "metadataonly",
("prop", "1911:46"): "metadataonly",
("prop", "1911:47"): "metadataonly",
("prop", "1911:49"): "metadataonly",
("prop", "1911:5"): "metadataonly",
("prop", "1911:50"): "metadataonly",
("prop", "1911:51"): "metadataonly",
("prop", "1911:52"): "metadataonly",
("prop", "1911:53"): "metadataonly",
("prop", "1911:54"): "metadataonly",
("prop", "1911:55"): "metadataonly",
("prop", "1911:56"): "metadataonly",
("prop", "1911:57"): "metadataonly",
("prop", "1911:58"): "metadataonly",
("prop", "1911:59"): "metadataonly",
("prop", "1911:6"): "metadataonly",
("prop", "1911:60"): "metadataonly",
("prop", "1911:61"): "metadataonly",
("prop", "1911:62"): "metadataonly",
("prop", "1911:63"): "metadataonly",
("prop", "1911:64"): "metadataonly",
("prop", "1911:65"): "metadataonly",
("prop", "1911:66"): "metadataonly",
("prop", "1911:67"): "metadataonly",
("prop", "1911:68"): "metadataonly",
("prop", "1911:69"): "metadataonly",
("prop", "1911:7"): "metadataonly",
("prop", "1911:70"): "metadataonly",
("prop", "1911:71"): "metadataonly",
("prop", "1911:72"): "metadataonly",
("prop", "1911:73"): "metadataonly",
("prop", "1911:74"): "metadataonly",
("prop", "1911:75"): "metadataonly",
("prop", "1911:76"): "metadataonly",
("prop", | |
<gh_stars>1-10
"""
This file is part of the TheLMA (THe Laboratory Management Application) project.
See LICENSE.txt for licensing, CONTRIBUTORS.txt for contributor information.
Tools involved the execution of library creation worklists.
AAB
"""
from everest.entities.utils import get_root_aggregate
from thelma.tools.semiconstants import RESERVOIR_SPECS_NAMES
from thelma.tools.semiconstants import get_384_rack_shape
from thelma.tools.base import BaseTool
from thelma.tools.libcreation.base import LibraryBaseLayoutConverter
from thelma.tools.libcreation.base import LibraryLayout
from thelma.tools.libcreation.base import NUMBER_SECTORS
from thelma.tools.semiconstants import PIPETTING_SPECS_NAMES
from thelma.tools.worklists.series import SampleTransferJob
from thelma.tools.worklists.series import RackSampleTransferJob
from thelma.tools.libcreation.generation \
import LibraryCreationWorklistGenerator
from thelma.tools.libcreation.writer import LibraryCreationWorklistWriter
from thelma.tools.utils.converters import LibraryLayoutConverter
from thelma.tools.utils.racksector import QuadrantIterator
from thelma.tools.utils.racksector import RackSectorTranslator
from thelma.tools.utils.racksector import get_sector_positions
from thelma.interfaces import ITubeRack
from thelma.entities.iso import ISO_STATUS
from thelma.entities.iso import StockSampleCreationIso
from thelma.entities.liquidtransfer import ExecutedWorklist
from thelma.entities.rack import TubeRack
from thelma.entities.user import User
__docformat__ = 'reStructuredText en'
__all__ = ['LibraryCreationExecutor',
'LibraryCreationStockRackVerifier',
'LibraryCreationBufferWorklistTransferJobCreator']
#TODO: create stock samples
class LibraryCreationExecutor(BaseTool):
"""
Executes the worklist file for a pool stock sample creation ISO (including
tube handler worklists). This comprises:
- tube handler worklist execution (requires file upload)
- execution of all worklist files
:Note: The stock samples for the pool are created externally.
**Return Value:** the updated ISO
"""
NAME = 'LibraryCreationXL20Executor'
def __init__(self, stock_sample_creation_iso, user, parent=None):
"""
Constructor:
:param stock_sample_creation_iso: The pool stock sample creation ISO
for which to execute the worklists.
:type stock_sample_creation_iso:
:class:`thelma.entities.iso.StockSampleCreationIso`
:param user: The user conducting the execution.
:type user: :class:`thelma.entities.user.User`
"""
BaseTool.__init__(self, parent=parent)
#: The stock sample creation ISO for which to execute the worklists.
self.stock_sample_creation_iso = stock_sample_creation_iso
#: The user conducting the execution.
self.user = user
#: The library layout for this ISO.
self.__library_layout = None
#: Maps library position onto sector indices.
self.__library_sectors = None
#: The ISO sample stock racks mapped onto sector indices.
self.__sample_stock_racks = None
#: Maps tube racks (for 1 molecule design stock racks) onto sector
#: indices.
self.__stock_rack_map = None
#: The library source (preparation) plates (plate entities) mapped
#: onto sector indices.
self.__library_source_plates = None
#: The executed stock transfer worklists (mapped onto job indices;
#: refers to transfer from single molecule design to pool stock rack).
#: Required for reporting.
self.__stock_transfer_worklists = None
#: The transfer jobs for the series executor.
self.__transfer_jobs = None
#: The indices for the rack transfer jobs mapped onto the worklist
#: they belong to.
self.__rack_transfer_indices = None
#: Position with transfers but without library position (96-well,
#: mapped onto sectors).
self.__ignore_positions_96 = None
def reset(self):
BaseTool.reset(self)
self.__library_layout = None
self.__library_sectors = None
self.__sample_stock_racks = dict()
self.__stock_rack_map = dict()
self.__library_source_plates = dict()
self.__stock_transfer_worklists = dict()
self.__transfer_jobs = dict()
self.__rack_transfer_indices = dict()
self.__ignore_positions_96 = dict()
def run(self):
"""
Executes the library creation worklists.
"""
self.reset()
self.add_info('Start execution ...')
self.__check_input()
if not self.has_errors(): self.__get_library_layout()
if not self.has_errors():
self.__get_sample_stock_racks()
self.__get_library_source_plates()
if not self.has_errors(): self.__verify_single_md_stock_racks()
if not self.has_errors(): self.__find_ignored_positions()
if not self.has_errors(): self.__create_buffer_transfer_jobs()
if not self.has_errors(): self.__create_stock_transfer_jobs()
if not self.has_errors(): self.__create_preparation_transfer_jobs()
if not self.has_errors(): self.__create_aliquot_transfer_jobs()
if not self.has_errors(): self.__execute_transfer_jobs()
if not self.has_errors():
self.stock_sample_creation_iso.status = ISO_STATUS.DONE
self.return_value = self.stock_sample_creation_iso
self.add_info('Transfer execution completed.')
def get_executed_stock_worklists(self):
"""
Returns the executed worklists that *deal with the stock transfer*
(for stock transfer reporting).
"""
if self.return_value is None: return None
return self.__stock_transfer_worklists
def get_working_layout(self):
"""
Returns the working layout containing the molecule design pool ID data
(for reporting).
"""
if self.return_value is None: return None
return self.__library_layout
@property
def entity(self):
"""
Returns the ISO. Required for reporting.
"""
return self.stock_sample_creation_iso
def __check_input(self):
"""
Checks the initialisation values.
"""
self.add_debug('Check input values ...')
if self._check_input_class('stock sample creation ISO',
self.stock_sample_creation_iso, StockSampleCreationIso):
status = self.stock_sample_creation_iso.status
if not status == ISO_STATUS.QUEUED:
msg = 'Unexpected ISO status: "%s"' % (status)
self.add_error(msg)
self._check_input_class('user', self.user, User)
def __get_library_layout(self):
"""
Fetches the library layout and sorts its positions into quadrants.
"""
self.add_debug('Fetch library layout ...')
converter = LibraryLayoutConverter(
self.stock_sample_creation_iso.rack_layout,
parent=self)
self.__library_layout = converter.get_result()
if self.__library_layout is None:
msg = 'Error when trying to convert library layout.'
self.add_error(msg)
else:
self.__library_sectors = QuadrantIterator.sort_into_sectors(
working_layout=self.__library_layout,
number_sectors=NUMBER_SECTORS)
del_sectors = []
for sector_index, positions in self.__library_sectors.iteritems():
if len(positions) < 1: del_sectors.append(sector_index)
for sector_index in del_sectors:
del self.__library_sectors[sector_index]
def __get_sample_stock_racks(self):
"""
Fetches the ISO sample stock racks and the single molecule stock racks
(barcodes are found in the worklist labels).
"""
self.add_debug('Fetch stock racks')
writer_cls = LibraryCreationWorklistWriter
tube_rack_agg = get_root_aggregate(ITubeRack)
not_found = []
for issr in self.stock_sample_creation_iso.iso_sector_stock_racks:
self.__sample_stock_racks[issr.sector_index] = issr
label = issr.planned_worklist.label
starting_index = len(writer_cls.SAMPLE_STOCK_WORKLIST_LABEL)
barcode_str = label[starting_index:]
barcodes = barcode_str.split(writer_cls.\
SAMPLE_STOCK_WORKLIST_DELIMITER)
racks = []
for barcode in barcodes:
rack = tube_rack_agg.get_by_slug(barcode)
if rack is None:
not_found.append(barcode)
else:
racks.append(rack)
self.__stock_rack_map[issr.sector_index] = racks
if len(not_found) > 0:
msg = 'The following single molecule design source stock racks ' \
'have not been found in the DB: %s!' \
% (', '.join(sorted(not_found)))
self.add_error(msg)
def __get_library_source_plates(self):
"""
Fetches the library source plates for this ISO and maps them onto
sector indices.
"""
self.add_debug('Get library source plates ...')
for lsp in self.stock_sample_creation_iso.library_source_plates:
self.__library_source_plates[lsp.sector_index] = lsp.plate
def __verify_single_md_stock_racks(self):
"""
Makes sure we have all the molecule designs present and in the right
positions and no additional tubes in the single molecule design
stock racks.
"""
verifier = LibraryCreationStockRackVerifier(self.__library_layout,
self.__stock_rack_map,
parent=self)
compatible = verifier.get_result()
if compatible is None:
msg = 'Error in the verifier!'
self.add_error(msg)
elif not compatible:
msg = 'The stock racks with the single molecule designs are not ' \
'compatible to the expected layout!'
self.add_error(msg)
def __find_ignored_positions(self):
"""
Finds positions that are planned in the worklists but which are not
in the library layout (because there were not enough pools during
optimization). The positions are found by comparison with the
base layout.
"""
self.add_debug('Find empty plate positions ...')
for sector_index in self.__library_sectors.keys():
self.__ignore_positions_96[sector_index] = []
converter = LibraryBaseLayoutConverter(
self.stock_sample_creation_iso.iso_request.iso_layout,
parent=self)
base_layout = converter.get_result()
if base_layout is None:
msg = 'Error when trying to convert library base layout.'
self.add_error(msg)
elif not len(base_layout) == len(self.__library_layout):
lib_positions = self.__library_layout.get_positions()
ignore_positions_384 = []
for rack_pos in base_layout.get_positions():
if not rack_pos in lib_positions:
ignore_positions_384.append(rack_pos)
self.__find_ignored_sector_positions(ignore_positions_384)
def __find_ignored_sector_positions(self, ignore_positions_384):
"""
Converts the position in the ignored position list for the 384-well
layout into 96-well position.
Positions for sectors that are not required (might be the case on the
last plate) are not checked.
"""
for sector_index in range(NUMBER_SECTORS):
if not self.__library_sectors.has_key(sector_index): continue
sector_positions = get_sector_positions(sector_index=sector_index,
rack_shape=get_384_rack_shape(),
number_sectors=NUMBER_SECTORS)
translator = RackSectorTranslator(number_sectors=NUMBER_SECTORS,
source_sector_index=sector_index,
target_sector_index=0,
enforce_type=RackSectorTranslator.ONE_TO_MANY)
for sector_pos in sector_positions:
if sector_pos in ignore_positions_384:
rack_pos_96 = translator.translate(sector_pos)
self.__ignore_positions_96[sector_index].append(rack_pos_96)
def __create_buffer_transfer_jobs(self):
"""
Creates the transfer jobs for the buffer worklists.
"""
self.add_debug('Create buffer transfer jobs ...')
stock_racks = dict()
for sector_index, issr in self.__sample_stock_racks.iteritems():
rack = issr.rack
stock_racks[sector_index] = rack
creator = LibraryCreationBufferWorklistTransferJobCreator(
self.stock_sample_creation_iso,
stock_racks,
self.__ignore_positions_96,
parent=self)
self.__transfer_jobs = creator.get_result()
if self.__transfer_jobs is None:
msg = 'Unable to get buffer transfer jobs!'
self.add_error(msg)
def __create_stock_transfer_jobs(self):
"""
Creates the transfer jobs for the pool creation. We do not need
to regard potential empty (ignored) positions here, because the
worklist creation is already base on the library layout.
"""
self.add_debug('Create pool creation transfer jobs ...')
current_index = max(self.__transfer_jobs.keys())
for sector_index, issr in self.__sample_stock_racks.iteritems():
racks = self.__stock_rack_map[sector_index]
for rack in racks:
current_index += 1
ctj = SampleTransferJob(current_index,
issr.planned_worklist,
issr.rack,
rack)
ctj.min_transfer_volume = 1
self.__transfer_jobs[current_index] = ctj
self.__stock_transfer_worklists[current_index] = None
def __create_preparation_transfer_jobs(self):
"""
Creates the transfer jobs for the rack transfers (transfer from pool
stock racks to preparation (source) plates).
"""
self.add_debug('Create preparation transfer jobs ...')
current_index = max(self.__transfer_jobs.keys())
worklist_series = self.stock_sample_creation_iso.iso_request.worklist_series
marker = LibraryCreationWorklistGenerator.\
STOCK_TO_PREP_TRANSFER_WORKLIST_LABEL[2:]
rt_worklist = None
rack_transfer = None
for worklist in worklist_series:
if not marker in worklist.label: continue
if len(worklist.planned_transfers) != 1:
msg = 'The worklist for the transfer from pool stock ' \
'rack preparation plate has an unexpected length: ' \
'%i (expected: 1).' % (len(worklist.planned_transfers))
self.add_error(msg)
else:
rack_transfer = worklist.planned_transfers[0]
rt_worklist = worklist
break
if self.has_errors():
pass
elif rack_transfer is None:
msg = 'Unable to find worklist for the transfer from pool stock ' \
'racks to library source (prepraration) plates.'
self.add_error(msg)
else:
job_indices = []
for sector_index, issr in self.__sample_stock_racks.iteritems():
stock_rack = issr.rack
prep_plate = self.__library_source_plates[sector_index]
current_index += 1
rtj = RackSampleTransferJob(current_index,
rack_transfer,
prep_plate,
stock_rack)
self.__transfer_jobs[current_index] = rtj
job_indices.append(current_index)
self.__rack_transfer_indices[rt_worklist] = job_indices
def __create_aliquot_transfer_jobs(self):
"""
Creates the transfer jobs for the rack transfers (transfer from
preparation (source) plates | |
#
# This file is part of Brazil Data Cube Collection Builder.
# Copyright (C) 2019-2020 INPE.
#
# Brazil Data Cube Collection Builder is free software; you can redistribute it and/or modify it
# under the terms of the MIT License; see LICENSE file for more details.
#
"""Define Brazil Data Cube utils."""
# Python Native
import datetime
import logging
import shutil
import tarfile
from json import loads as json_parser
from os import path as resource_path
from os import remove as resource_remove
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import List, Tuple
from zipfile import BadZipfile, ZipFile
from zlib import error as zlib_error
# 3rdparty
import boto3
import numpy
import rasterio
import rasterio.features
import rasterio.warp
import shapely
import shapely.geometry
from bdc_catalog.models import Band, Collection, Provider, db
from bdc_catalog.utils import multihash_checksum_sha256
from bdc_collectors.base import BaseProvider
from botocore.exceptions import ClientError
from flask import current_app
from rasterio.warp import Resampling
from rio_cogeo.cogeo import cog_translate
from rio_cogeo.profiles import cog_profiles
# Builder
from werkzeug.exceptions import abort
from ..config import CURRENT_DIR, Config
def get_or_create_model(model_class, defaults=None, engine=None, **restrictions):
"""Get or create Brazil Data Cube model.
Utility method for looking up an object with the given restrictions, creating one if necessary.
Args:
model_class (BaseModel) - Base Model of Brazil Data Cube DB
defaults (dict) - Values to fill out model instance
restrictions (dict) - Query Restrictions
Returns:
BaseModel Retrieves model instance
"""
if not engine:
engine = db
instance = engine.session.query(model_class).filter_by(**restrictions).first()
if instance:
return instance, False
params = dict((k, v) for k, v in restrictions.items())
params.update(defaults or {})
instance = model_class(**params)
engine.session.add(instance)
return instance, True
def load_img(img_path):
"""Load an image."""
try:
with rasterio.open(img_path) as dataset:
img = dataset.read(1).flatten()
return img
except:
logging.error('Cannot find {}'.format(img_path))
raise RuntimeError('Cannot find {}'.format(img_path))
def extractall(file, destination=None):
"""Extract zipfile."""
archive = ZipFile(file, 'r')
if destination is None:
destination = resource_path.dirname(file)
archive.extractall(destination)
archive.close()
def get_credentials():
"""Retrieve global secrets with credentials."""
file = resource_path.join(resource_path.dirname(CURRENT_DIR), 'secrets.json')
with open(file) as f:
return json_parser(f.read())
def generate_cogs(input_data_set_path, file_path, profile='deflate', profile_options=None, **options):
"""Generate Cloud Optimized GeoTIFF files (COG).
Example:
>>> tif_file = '/path/to/tif'
>>> generate_cogs(tif_file, '/tmp/cog.tif')
Args:
input_data_set_path (str) - Path to the input data set
file_path (str) - Target data set filename
profile (str) - A COG profile based in `rio_cogeo.profiles`.
profile_options (dict) - Custom options to the profile.
Returns:
Path to COG.
"""
if profile_options is None:
profile_options = dict()
output_profile = cog_profiles.get(profile)
output_profile.update(dict(BIGTIFF="IF_SAFER"))
output_profile.update(profile_options)
# Add option to generate Cloud Optimized GeoTIFF file in memory instead inline temp file.
options.setdefault('in_memory', True)
# Dataset Open option (see gdalwarp `-oo` option)
config = dict(
GDAL_NUM_THREADS="ALL_CPUS",
GDAL_TIFF_INTERNAL_MASK=True,
GDAL_TIFF_OVR_BLOCKSIZE="128",
)
cog_translate(
str(input_data_set_path),
str(file_path),
output_profile,
config=config,
quiet=True,
**options,
)
return str(file_path)
def is_valid_compressed(file):
"""Check tar gz or zip is valid."""
try:
archive = ZipFile(file, 'r')
try:
corrupt = archive.testzip()
except zlib_error:
corrupt = True
archive.close()
except BadZipfile:
corrupt = True
return not corrupt
def extract_and_get_internal_name(zip_file_name, extract_to=None):
"""Extract zipfile and return internal folder path."""
# Check if file is valid
valid = is_valid_compressed(zip_file_name)
if not valid:
raise IOError('Invalid zip file "{}"'.format(zip_file_name))
else:
extractall(zip_file_name, destination=extract_to)
# Get extracted zip folder name
with ZipFile(zip_file_name) as zipObj:
listOfiles = zipObj.namelist()
extracted_file_path = listOfiles[0].split('/')[0] if listOfiles[0].endswith('/') else listOfiles[0]
return extracted_file_path
def upload_file(file_name, bucket='bdc-ds-datacube', object_name=None):
"""Upload a file to an S3 bucket.
Adapted code from boto3 example.
Args:
file_name (str|_io.TextIO): File to upload
bucket (str): Bucket to upload to
object_name (str): S3 object name. If not specified then file_name is used
"""
# If S3 object_name was not specified, use file_name
if object_name is None:
object_name = file_name
# Upload the file
s3_client = boto3.client('s3', region_name=Config.AWS_REGION_NAME, aws_access_key_id=Config.AWS_ACCESS_KEY_ID, aws_secret_access_key=Config.AWS_SECRET_ACCESS_KEY)
try:
s3_client.upload_file(file_name, bucket, object_name)
except ClientError as e:
logging.error(e)
return False
return True
def remove_file(file_path: str):
"""Remove file if exists.
Throws Error when user doesn't have access to the file at given path
"""
if resource_path.exists(file_path):
resource_remove(file_path)
def create_asset_definition(href: str, mime_type: str, role: List[str], absolute_path: str,
created=None, is_raster=False):
"""Create a valid asset definition for collections.
TODO: Generate the asset for `Item` field with all bands
Args:
href - Relative path to the asset
mime_type - Asset Mime type str
role - Asset role. Available values are: ['data'], ['thumbnail']
absolute_path - Absolute path to the asset. Required to generate check_sum
created - Date time str of asset. When not set, use current timestamp.
is_raster - Flag to identify raster. When set, `raster_size` and `chunk_size` will be set to the asset.
"""
fmt = '%Y-%m-%dT%H:%M:%S'
_now_str = datetime.datetime.utcnow().strftime(fmt)
if created is None:
created = _now_str
elif isinstance(created, datetime.datetime):
created = created.strftime(fmt)
asset = {
'href': str(href),
'type': mime_type,
'bdc:size': Path(absolute_path).stat().st_size,
'checksum:multihash': multihash_checksum_sha256(str(absolute_path)),
'roles': role,
'created': created,
'updated': _now_str
}
if is_raster:
with rasterio.open(str(absolute_path)) as data_set:
asset['bdc:raster_size'] = dict(
x=data_set.shape[1],
y=data_set.shape[0],
)
chunk_x, chunk_y = data_set.profile.get('blockxsize'), data_set.profile.get('blockxsize')
if chunk_x is None or chunk_x is None:
return asset
asset['bdc:chunk_size'] = dict(x=chunk_x, y=chunk_y)
return asset
def raster_extent(file_path: str, epsg='EPSG:4326') -> shapely.geometry.Polygon:
"""Get raster extent in arbitrary CRS.
Args:
file_path (str): Path to image
epsg (str): EPSG Code of result crs
Returns:
dict: geojson-like geometry
"""
with rasterio.open(str(file_path)) as data_set:
_geom = shapely.geometry.mapping(shapely.geometry.box(*data_set.bounds))
return shapely.geometry.shape(rasterio.warp.transform_geom(data_set.crs, epsg, _geom, precision=6))
def raster_convexhull(file_path: str, epsg='EPSG:4326', no_data=None) -> dict:
"""Get raster image footprint.
Args:
file_path (str): image file
epsg (str): geometry EPSG
no_data: Use custom no data value. Default is dataset.nodata
See:
https://rasterio.readthedocs.io/en/latest/topics/masks.html
"""
with rasterio.open(str(file_path)) as data_set:
# Read raster data, masking nodata values
data = data_set.read(1, masked=True)
if no_data is not None:
data[data == no_data] = numpy.ma.masked
data[data != numpy.ma.masked] = 1
data[data == numpy.ma.masked] = 0
data = data.astype(numpy.uint8)
# Create mask, which 1 represents valid data and 0 nodata
geoms = []
for geom, _ in rasterio.features.shapes(data, mask=data, transform=data_set.transform):
geom = rasterio.warp.transform_geom(data_set.crs, epsg, geom, precision=6)
geoms.append(shapely.geometry.shape(geom))
if len(geoms) == 1:
return geoms[0].convex_hull
multi_polygons = shapely.geometry.MultiPolygon(geoms)
return multi_polygons.convex_hull
def post_processing(quality_file_path: str, collection: Collection, scenes: dict, resample_to=None):
"""Stack the merge bands in order to apply a filter on the quality band.
We have faced some issues regarding `nodata` value in spectral bands, which was resulting
in wrong provenance date on STACK data cubes, since the Fmask tells the pixel is valid (0) but a nodata
value is found in other bands.
To avoid that, we read all the others bands, seeking for `nodata` value. When found, we set this to
nodata in Fmask output::
Quality Nir Quality
0 0 2 4 702 876 7000 9000 => 0 0 2 4
0 0 0 0 687 987 1022 1029 => 0 0 0 0
0 2 2 4 -9999 7100 7322 9564 => 255 2 2 4
Notes:
It may take too long to execute for a large grid.
Args:
quality_file_path: Path to the cloud masking file.
collection: The collection instance.
scenes: Map of band and file path
resample_to: Resolution to re-sample. Default is None, which uses default value.
"""
quality_file_path = Path(quality_file_path)
band_names = [band_name for band_name in scenes.keys() if band_name.lower() not in ('ndvi', 'evi', 'fmask4')]
bands = Band.query().filter(
Band.collection_id == collection.id,
Band.name.in_(band_names)
).all()
options = dict()
with TemporaryDirectory() as tmp:
temp_file = Path(tmp) / quality_file_path.name
# Copy to temp dir
shutil.copyfile(quality_file_path, temp_file)
if resample_to:
with rasterio.open(str(quality_file_path)) as ds:
ds_transform = ds.profile['transform']
options.update(ds.meta.copy())
factor = ds_transform[0] / resample_to
options['width'] = ds.profile['width'] * factor
options['height'] = ds.profile['height'] * factor
transform = ds.transform * ds.transform.scale((ds.width / options['width']), (ds.height / options['height']))
options['transform'] = transform
nodata = options.get('nodata') or 255
options['nodata'] = nodata
raster = ds.read(
out_shape=(
ds.count,
int(options['height']),
int(options['width'])
),
resampling=Resampling.nearest
)
with rasterio.open(str(temp_file), mode='w', **options) as temp_ds:
temp_ds.write_band(1, raster[0])
# Build COG
generate_cogs(str(temp_file), str(temp_file))
with rasterio.open(str(temp_file), **options) as quality_ds:
blocks = list(quality_ds.block_windows())
profile = quality_ds.profile
nodata = profile.get('nodata') or 255
raster_merge = quality_ds.read(1)
for _, block in blocks:
nodata_positions = []
row_offset = block.row_off + block.height
col_offset = block.col_off + block.width
for band in bands:
band_file = scenes[band.name]
with rasterio.open(str(band_file)) as ds:
raster = ds.read(1, window=block)
nodata_found = numpy.where(raster == -9999)
raster_nodata_pos = numpy.ravel_multi_index(nodata_found, raster.shape)
nodata_positions = numpy.union1d(nodata_positions, raster_nodata_pos)
if len(nodata_positions):
raster_merge[block.row_off: row_offset, block.col_off: col_offset][
numpy.unravel_index(nodata_positions.astype(numpy.int64), raster.shape)] = nodata
save_as_cog(str(temp_file), raster_merge, **profile)
# Move right place
shutil.move(str(temp_file), str(quality_file_path))
def save_as_cog(destination: str, raster, mode='w', **profile):
"""Save the raster file as Cloud Optimized GeoTIFF.
See Also:
Cloud Optimized GeoTiff https://gdal.org/drivers/raster/cog.html
Args:
destination: Path to store the data set.
raster: Numpy raster values to | |
in the first r columns, then keep its segment number
cur_segment_id = segmented_img[y, x]
segmented_img[y, x] = cur_segment_id
lowest_active_point_per_col[x] = y
else:
# not continuopus image, but one with borders
# go over all active points
# start with points after height of r and later between 0 and r
for y in range(height):
for x in range(width):
if binary_img[y, x]:
# check if there are connected segments
col_idxs = x + dist_per_row
col_feature_idxs = (col_idxs >= 0) & (col_idxs < width)
col_idxs = col_idxs[col_feature_idxs]
dist_lowest_point_per_col = y - lowest_active_point_per_col[col_idxs]
cols_with_connected_segments = col_idxs[dist_lowest_point_per_col <= max_dist_per_col[col_feature_idxs]]
if len(cols_with_connected_segments) > 0:
segments = segmented_img[lowest_active_point_per_col[cols_with_connected_segments].astype(int), cols_with_connected_segments]
# if current point was already segmented, if it was in the first r cols, then also keep its original segment number in consideration
if segmented_img[y, x] > 0:
segments = np.hstack((segments, segmented_img[y, x]))
cur_segment_id = segments[0]
segments_unique = set()
for segment_id in segments:
if segment_id not in segments_unique:
segments_unique.add(segment_id)
cur_segment_id = min(cur_segment_id, segment_id)
if len(segments_unique) > 1:
for segment_id in segments_unique:
if segment_id != cur_segment_id:
segmented_img[segmented_img == segment_id] = cur_segment_id
segment_ids.remove(segment_id)
else:
# give it new segment number if no other segment nearby
cur_segment_id = max(segment_ids) + 1
segment_ids.add(cur_segment_id)
segmented_img[y, x] = cur_segment_id
lowest_active_point_per_col[x] = y
sorted_segments = sorted(segment_ids)
# relabel the segment ids to have no jumps
for segment_idx in range(1, len(sorted_segments)):
if segment_idx != sorted_segments[segment_idx]:
segmented_img[segmented_img == sorted_segments[segment_idx]] = segment_idx
return segmented_img, list(range(1, len(sorted_segments)))
# class BinaryImageSegmenter:
#
# @staticmethod
# def default_config():
# config = ad.config.Config()
# config.r = 1
# config.tol = 0.1
#
# return config
#
#
# def __init__(self, config=None, **kwargs):
# self.config = ad.config.set_default_config(kwargs, config, self.__class__.default_config())
#
# # holds filter templates for different image sizes if needed
# self.filter_templates = dict()
#
#
# def create_filter_template(self, image_shape):
#
# filter_template = np.zeros(image_shape)
#
# mid_y = int(image_shape[0] / 2)
# mid_x = int(image_shape[1] / 2)
#
# for y in range(mid_y - self.config.r, mid_y + self.config.r + 1):
# for x in range(mid_x - self.config.r, mid_x + self.config.r + 1):
# if np.linalg.norm(np.array([y, x]) - np.array([mid_y, mid_x])) <= self.config.r:
# filter_template[y, x] = 1
#
# mid_point = np.array([mid_y, mid_x])
#
# return filter_template, mid_point
#
#
# def get_filter(self, pos, image_shape):
#
# if image_shape in self.filter_templates:
# [filter_template, mid_point] = self.filter_templates[image_shape]
# else:
# [filter_template, mid_point] = self.create_filter_template(image_shape)
# self.filter_templates[image_shape] = (filter_template, mid_point)
#
# shift = np.array(pos) - mid_point
# return np.roll(filter_template, shift, axis=(0, 1))
#
#
# def calc(self, img):
#
# # create a binary image
# binary_img = np.array(img) >= self.config.tol
#
# # segments
# segmented_img = binary_img.copy() * np.nan
#
# segment_ids = [0]
#
# # go over all active points
# for y in range(binary_img.shape[0]):
# for x in range(binary_img.shape[1]):
# if binary_img[y,x]:
#
# cur_filter = self.get_filter((y, x), binary_img.shape)
#
# # point wise multiplication of filter for current pos and image to identify all the active points that influence the current point
# connected_points = np.multiply(binary_img, cur_filter)
# connected_segments = np.multiply(segmented_img, cur_filter)
#
# # ignore outside segments
# connected_segments[connected_segments == 0] = np.nan
#
# # get sorted existing segments
# min_connected_segment_id = np.nanmin(connected_segments)
#
# if np.isnan(min_connected_segment_id):
# # if the first is nan, then all others are also nan, because of the sorting of unique
#
# # add new segment number because there are no other unseen segments nearby
# new_segment_id = segment_ids[-1] + 1
# segment_ids.append(new_segment_id)
#
# new_points_segment_id = new_segment_id
#
# else:
# # use for all found segments the minimal existing segment number
#
# cur_segment_ids = connected_segments[connected_segments > 0]
#
# removed_segment_ids = []
# for cur_segment_id in cur_segment_ids:
# if cur_segment_id != min_connected_segment_id and cur_segment_id not in removed_segment_ids:
#
# segmented_img[segmented_img == cur_segment_id] = min_connected_segment_id
#
# # remove segment id from list of segments
# segment_ids.remove(cur_segment_id)
# removed_segment_ids.append(cur_segment_id)
#
# new_points_segment_id = min_connected_segment_id
#
# segmented_img[connected_points.astype(bool)] = new_points_segment_id
#
#
# # relabel the segment ids to have no jumps
# segmented_img[np.isnan(segmented_img)] = 0
#
# for segment_idx in range(1, len(segment_ids)):
# if segment_idx != segment_ids[segment_idx]:
# segmented_img[segmented_img == segment_ids[segment_idx]] = segment_idx
#
# return segmented_img
def calc_is_segments_finite(image=None, continuous_segmented_image=None, non_continuous_segmented_image=None, tol=0.2, r=1):
'''This version has a bug. It detects infinite segments as finite if they are connected via different borders: N->E->W->S->N or N->W->E->S->N.'''
warnings.warn(DeprecationWarning('The function calc_is_segments_finite contains a bug which classifies certain infinite segements as finite. Please use calc_is_segments_finite_v2 instead.'))
r = int(r)
if continuous_segmented_image is None:
continuous_segmented_image, continuous_segments = ad.helper.statistics.calc_active_binary_segments(image, tol=tol, r=r, is_continuous_image=True)
else:
(continuous_segmented_image, continuous_segments) = continuous_segmented_image
if non_continuous_segmented_image is None:
non_continuous_segmented_image, non_continuous_segments = ad.helper.statistics.calc_active_binary_segments(image, tol=tol, r=r, is_continuous_image=False)
else:
(non_continuous_segmented_image, non_continuous_segments) = non_continuous_segmented_image
# prepare the distances that have to be taken into account to say an active point is part of another active point
max_dist_per_col = np.zeros(int(r)*2 + 1, dtype=int)
dist_per_row = np.zeros(int(r) * 2 + 1, dtype=int)
idx1 = 0
idx2 = len(dist_per_row) - 1
for x_d in range(r, -1, -1):
dist_per_row[idx1] = -x_d
dist_per_row[idx2] = x_d
for y_d in range(r, -1, -1):
if np.linalg.norm([x_d, y_d]) <= r:
max_dist_per_col[idx1] = y_d
max_dist_per_col[idx2] = y_d
break
idx1 += 1
idx2 -= 1
height = continuous_segmented_image.shape[0]
width = continuous_segmented_image.shape[1]
# get relevant segments, i.e. upper and lower segments of each side
# identify lowest point per col for first r rows:
default_location_array = np.zeros(width) * np.nan
###########################################
# check upper and lower border
upper_locations_per_segment = dict()
lower_locations_per_segment = dict()
for x in range(width):
# upper area of image
for y in range(r): # search from upper to lower
if continuous_segmented_image[y, x] > 0:
segment_id = continuous_segmented_image[y, x]
if segment_id not in upper_locations_per_segment:
upper_locations_per_segment[segment_id] = default_location_array.copy()
upper_locations_per_segment[segment_id][x] = y
break # found the upper -> go to next column
# lower area of image
for y in range(height-1, height-r-1, -1): # search from lower to upper
if continuous_segmented_image[y, x] > 0:
segment_id = continuous_segmented_image[y, x]
if segment_id not in lower_locations_per_segment:
lower_locations_per_segment[segment_id] = default_location_array.copy()
lower_locations_per_segment[segment_id][x] = y
break # found the lower -> go to next column
# go over the segments in the border regions and check if they are connected in the continuous and non-continuous segmentation
# if they are connected in both then they must be infinite
# only check segments that are in both
check_segment_ids = set(upper_locations_per_segment.keys()).intersection(lower_locations_per_segment.keys())
infinite_segments_ids = []
# check if one of them is infinite
for cur_segment_id in check_segment_ids:
stop = False
for x, y in enumerate(upper_locations_per_segment[cur_segment_id]):
if not np.isnan(y):
y = int(y)
# get all points that are connected in the lower area and chek if they are also connected only with a direct link via inside the image not via image borders
# check if there are connected segments
col_idxs = np.mod(x + dist_per_row, width)
dist_lowest_point_per_col = y - (lower_locations_per_segment[cur_segment_id] - height)
cols_with_connected_segments = col_idxs[dist_lowest_point_per_col[col_idxs] <= max_dist_per_col]
rows_with_connected_segments = lower_locations_per_segment[cur_segment_id][cols_with_connected_segments].astype(int)
# check each connected point to see if it is also connected in non continuous segmentation
for idx in range(len(cols_with_connected_segments)):
if non_continuous_segmented_image[rows_with_connected_segments[idx], cols_with_connected_segments[idx]] == non_continuous_segmented_image[y, x]:
infinite_segments_ids.append(cur_segment_id)
stop = True
break
if stop:
break
###########################################
# check left and right border
leftest_locations_per_segment = dict()
rightest_locations_per_segment = dict()
for y in range(height):
# upper area of image
for x in range(r): # search from left to right
if continuous_segmented_image[y, x] > 0:
segment_id = continuous_segmented_image[y, x]
if segment_id not in leftest_locations_per_segment:
leftest_locations_per_segment[segment_id] = default_location_array.copy()
leftest_locations_per_segment[segment_id][y] = x
break # found the upper -> go to next column
# lower area of image
for x in range(width - 1, width - r - 1, -1): # search from lower to upper
if continuous_segmented_image[y, x] > 0:
segment_id = continuous_segmented_image[y, x]
if segment_id not in rightest_locations_per_segment:
rightest_locations_per_segment[segment_id] = default_location_array.copy()
rightest_locations_per_segment[segment_id][y] = x
break # found the lower -> go to next column
# go over the segments in the border regions and check if they are connected in the continuous and non-continuous segmentation
# if they are connected in both then they must be infinite
# only check segments that are in both
check_segment_ids = set(leftest_locations_per_segment.keys()).intersection(rightest_locations_per_segment.keys())
# do not check segments that are already found to be ininite
check_segment_ids = check_segment_ids.difference(infinite_segments_ids)
# check if one of them is infinite
for cur_segment_id in check_segment_ids:
stop = False
for y, x in enumerate(leftest_locations_per_segment[cur_segment_id]):
if not np.isnan(x):
x = int(x)
# get all points that are connected in the lower area and chek if they are also connected only with a direct link via inside the image not via image borders
# check if there are connected segments
row_idxs = np.mod(y + dist_per_row, | |
"""Module alphabet_soup."""
__author__ = '<NAME> (japinol)'
__all__ = ["AlphabetSoup"]
from sys import exit
import logging
from alphabetsoup.utils import remove_diacritics_from_str
# Module Constants
WORDS_MIN_CHARS = 3 # Minimum characters for each word to be searched
WORDS_MIN_SEARCH = 1 # Minimum words to be searched
SOUP_MIN_ROWS = 7 # Minimum rows in the table that represents the alphabet soup
SOUP_MIN_COLS = 7 # Minimum columns in the table that represents the alphabet soup
READ_WORDS_FROM_FILE = "read_from_dictionary" # String used to know if the words to be found will be read from a dictionary in a external file
MORE_INFO_STRING = "more_info" # String used to know if we have to display more info
SAVE_BUFFER_EACH_N_WORDS = 90 # How many words to be found before saving the buffer to the output file
PR_DOT_EACH_N_WORDS = 4000 # How many words searched between progress dots
PR_DOT_NEW_LINE = 50 # How many words written before new line of dots
SOUP_NAME_DEFAULT = "Alphabet Soup"
DIACRITICS_PRESERVE_CHAR_SET = ('ñ', 'ç') # When removing diacritics normalizing a string, the chars in the tuple will be preserved
# Files
IN_FILE_DEFAULT = "files/input_soup.txt"
OUT_FILE_DEFAULT = "output/output_soup.txt"
EXTERNAL_DICT_FILE_DEFAULT = "files/soup_dictionary.txt" # External dictionary file for the words to search
# Errors
ERROR_IN_FILE = "!!! ERROR: Input file: %s. Search aborted !!!"
ERROR_IN_FILE_CONSOLE = "!!! ERROR: Input file: See the output file for more details. Search aborted !!!"
ERROR_OUT_FILE_OPEN = "!!! ERROR: Output file: %s. Search aborted !!!"
ERROR_OUT_FILE_WRITING = "!!! ERROR writing output file: %s. Some information has been lost. Search aborted !!!"
ERROR_OUT_FILE_MAX_TRIES = "!!! ERROR: Too much tries failed writing to the output file: %s. Search aborted !!!"
MAX_ERRORS_OUT_FILE = 5 # Max writing errors when trying to write the buffer to the output file
logging.basicConfig(format='%(asctime)s %(levelname)s %(name)s: %(message)s')
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
class AlphabetSoup:
"""Solves an alphabet soup finding a given list of words inside it."""
def __init__(self, name=None, in_file=None, out_file=None, external_dict_file=None,
more_info=None, remove_diacritics=None):
self._name = str(name) if name else SOUP_NAME_DEFAULT
self._in_file = str(in_file) if in_file else IN_FILE_DEFAULT
self._out_file = str(out_file) if out_file else OUT_FILE_DEFAULT
self._external_dict_file = str(external_dict_file) if external_dict_file else EXTERNAL_DICT_FILE_DEFAULT
self._read_words_from_file = True if external_dict_file else False
self._more_info = True if more_info else False # If true, calculates and displays more info, mainly in the summary
self._remove_diacritics = True if remove_diacritics else False # If true, removes diacritics from the words to find
self._num_rows = 0
self._num_cols = 0
self._soup = [] # The alphabet soup
self._words = [] # Words to find
self._num_words = 0 # Number of words to find
self._words_found = set()
self._num_words_too_short = 0
self._str_out = [] # List of strings to save to the output file
self._error_in_file = False # If true, and error in the input file has been detected.
self._num_errors_out_file = 0 # How many errors writing the output file
self._progress_dots_count = 0 # How many progress dots have been displayed
# Put soup's name to the buffer of the output file.
self._write_line('%s\n%s' % (self._name, '-' * len(self._name)))
def read_data(self):
"""Reads the words to find and the alphabet soup."""
self._print_progress_dots(char_str='[')
try:
with open(self._in_file, "r", encoding='utf-8') as in_file:
i = 0
for line_in in in_file:
line = line_in.lower().replace('\n', '').replace(' ', '')
if i == 0:
# Read the list of words to find from the first line if the words are not to be read from a file.
if line != READ_WORDS_FROM_FILE and not self._read_words_from_file:
self._words = line.split(',')
else:
# The words to find will be read from an external file.
self._read_words_from_file = True
elif i >= 2:
# Read the characters in the soup until it founds an empty line.
if line == '':
break
self._soup.append(line)
# The first row will determine the number of columns.
if i == 2:
self._num_cols = len(line)
else:
if len(line) != self._num_cols:
break
i += 1
except FileNotFoundError:
self._error_in_file = True
self._write_line(f"Input file not found: {self._in_file}")
except Exception:
self._error_in_file = True
self._num_rows = len(self._soup)
# Read the words to find from an external file if necessary.
if self._read_words_from_file:
self._read_words_to_find_from_file()
else:
# Discard the words to find that have too few characters.
for word in self._words[:]:
if len(word) < WORDS_MIN_CHARS:
self._num_words_too_short += 1
self._words.remove(word)
# Remove diacritics from the words to find
if self._remove_diacritics:
self._words = [remove_diacritics_from_str(word, preserve_char_set=DIACRITICS_PRESERVE_CHAR_SET)
for word in self._words]
# Remove duplicated words to find and sort the list.
self._words = list(set(self._words))
self._words.sort()
self._num_words = len(self._words)
# Check if there is something wrong with the input data.
if not self._error_in_file:
self._validate_input_data()
# Check if error reading an input file.
if self._error_in_file:
self._write_line(ERROR_IN_FILE % self._in_file)
self._write_data_to_file(open_method='w')
def search_words_in_the_soup(self):
"""Searches the words in the alphabet soup."""
self._print_progress_dots()
if (self._error_in_file):
logger.critical(ERROR_IN_FILE_CONSOLE)
return
self._write_header_of_the_search()
# Search the words in the soup.
self._write_line(self._format_msg_word_found_header())
num_words_searched = 0
num_words_found = 0
for word in self._words:
num_words_found += self._search_word_in_the_soup(word)
num_words_searched += 1
if num_words_found >= SAVE_BUFFER_EACH_N_WORDS:
self._write_data_to_file()
num_words_found = 0
if num_words_searched == PR_DOT_EACH_N_WORDS:
self._print_progress_dots()
num_words_searched = 0
self._print_progress_dots()
# Write the summary of the search.
self._write_summary_of_the_search()
self._print_progress_dots(char_str=']')
# Check if all the buffer has been written to the output file.
if self._str_out and self._num_errors_out_file > 0:
logger.critical(ERROR_OUT_FILE_WRITING % self._out_file)
exit()
def _read_words_to_find_from_file(self):
"""Reads the words to find from an external file. This file must have a word for line."""
try:
self._write_line(f"The words to find will be taken from the file: {self._external_dict_file}")
with open(self._external_dict_file, "r", encoding='utf-8') as in_file:
for line_in in in_file:
line = line_in.strip().replace("\n", "").replace(" ", "").lower()
if len(line) >= WORDS_MIN_CHARS:
self._words.append(line)
else:
self._num_words_too_short += 1
except FileNotFoundError:
self._error_in_file = True
self._write_line(f"Input file not found: {self._external_dict_file}")
except Exception:
self._error_in_file = True
def _validate_input_data(self):
"""Validates the input data."""
# Check the dimensions of the soup.
for wordSoup in self._soup:
if len(wordSoup) != self._num_cols:
self._error_in_file = True
self._write_line(f"!!! ERROR: The first row of the soup has {self._num_cols} columns. "
"Every other row must have this very number of columns !!!")
return
# Check rows, columns and minimum words to search.
if (self._num_rows < SOUP_MIN_ROWS or self._num_cols < SOUP_MIN_COLS
or self._num_words < WORDS_MIN_SEARCH):
self._error_in_file = True
self._write_line("!!! Input data error. Some of the following rules has been violated: !!!")
self._write_line(f" > Minimum rows: {SOUP_MIN_ROWS}")
self._write_line(f" > Minimum columns: {SOUP_MIN_COLS}")
self._write_line(f" > Minimum words to find: {WORDS_MIN_SEARCH}")
def _search_word_in_the_soup(self, word):
"""Searches a word in the alphabet soup."""
word_len = len(word)
num_words_found = 0
for i in range(self._num_rows): # Go through rows
for j in range(self._num_cols): # Go through columns
if word[0] == self._soup[i][j]: # Find the first char. of the current word in the soup
for p in range(word_len): # Check horitz. left->right
if (j + p) >= self._num_cols:
break
elif word[p] != self._soup[i][j + p]:
break
if p == word_len - 1:
self._words_found.add(word)
num_words_found += 1
self._write_line(self._format_msg_word_found(word, i, j, "left--> right"))
for p in range(word_len): # Check horitz. right->left
if (j - p) < 1:
break
elif word[p] != self._soup[i][j - p]:
break
if p == word_len - 1:
self._words_found.add(word)
num_words_found += 1
self._write_line(self._format_msg_word_found(word, i, j, "right--> left"))
for p in range(word_len): # Check vertical top->bottom
if (i + p) >= self._num_rows:
break
elif word[p] != self._soup[i + p][j]:
break
if p == word_len - 1:
self._words_found.add(word)
num_words_found += 1
self._write_line(self._format_msg_word_found(word, i, j, "top--> bottom"))
for p in range(word_len): # Check vertical bottom->top
if (i - p) < 1:
break
elif word[p] != self._soup[i - p][j]:
break
if p == word_len - 1:
self._words_found.add(word)
num_words_found += 1
self._write_line(self._format_msg_word_found(word, i, j, "bottom--> top"))
for p in range(word_len): # Check diagonal top->bottom left->right
if (i + p >= self._num_rows) or (j + p >= self._num_cols):
break
elif word[p] != self._soup[i + p][j + p]:
break
if p == word_len - 1:
self._words_found.add(word)
num_words_found += 1
self._write_line(self._format_msg_word_found(word, i, j, "diag. top->bottom, left->right"))
for p in range(word_len): # Check diagonal bottom->top left->right
if (i - p < 1) or (j + p >= self._num_cols):
break
elif word[p] != self._soup[i - p][j + p]:
break
if p == word_len - 1:
self._words_found.add(word)
num_words_found += 1
self._write_line(self._format_msg_word_found(word, i, j, "diag. bottom->top left->right"))
for p in range(word_len): # Check diagonal top->bottom right->left
if (i + p >= self._num_rows) or (j - p | |
scheduled[1].entry_date == GeneratedDate(2020, 9, 15)
records = [
Transaction(date(2019, 3, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 11, 1), "ABC", 1, Amount(100)), # dated in the future
]
scheduled = scheduled_transactions(records, since=date(2019, 10, 1))
assert len(scheduled) == 3
assert scheduled[0].entry_date == GeneratedDate(2020, 3, 15)
assert scheduled[1].entry_date == GeneratedDate(2020, 6, 15)
assert scheduled[2].entry_date == GeneratedDate(2020, 9, 15)
records = [
Transaction(date(2019, 9, 16), "ABC", 1, Amount(100)),
Transaction(date(2019, 11, 18), "ABC", 1, Amount(100)),
Transaction(date(2020, 2, 24), "ABC", 1, Amount(100)),
Transaction(date(2020, 5, 18), "ABC", 1, Amount(100)),
# note, one month earlier than last year
Transaction(date(2020, 8, 17), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2020, 8, 18))
# todo: issue here is that 2019/9 is projected to 2020/9, but we can clearly tell,
# based on month interval not matching expected frequency (i.e. 3), that we don't
# actually want/expect this projection - it should just be weeded out
assert len(scheduled) == 4
assert scheduled[0].entry_date == GeneratedDate(2020, 11, 30)
assert scheduled[1].entry_date == GeneratedDate(2021, 2, 28)
assert scheduled[2].entry_date == GeneratedDate(2021, 5, 31)
assert scheduled[3].entry_date == GeneratedDate(2021, 8, 31)
records = [
Transaction(date(2020, 3, 13), "ABC", 1, Amount(100)),
Transaction(date(2020, 6, 15), "ABC", 1, Amount(100)),
# preliminary record; e.g. in future, results in projection more than 1 year later
Transaction(date(2020, 9, 15), "ABC", 1, GeneratedAmount(100)),
]
scheduled = scheduled_transactions(records, since=date(2020, 9, 2))
assert len(scheduled) == 4
assert scheduled[0].entry_date == GeneratedDate(2020, 12, 15)
assert scheduled[1].entry_date == GeneratedDate(2021, 3, 15)
assert scheduled[2].entry_date == GeneratedDate(2021, 6, 15)
# note that this one is included though more than 365 days later; see earliest/cutoff in scheduled_transactions
assert scheduled[3].entry_date == GeneratedDate(2021, 9, 15)
def test_scheduled_grace_period():
records = [
Transaction(date(2018, 3, 1), "ABC", 1, Amount(100)),
Transaction(date(2018, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2018, 9, 1), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2019, 9, 16))
assert len(scheduled) == 1
records = [
Transaction(date(2018, 3, 1), "ABC", 1, Amount(100)),
Transaction(date(2018, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2018, 9, 1), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2019, 9, 30))
assert len(scheduled) == 1
records = [
Transaction(date(2018, 3, 1), "ABC", 1, Amount(100)),
Transaction(date(2018, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2018, 9, 1), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2019, 10, 1))
assert len(scheduled) == 0
records = [
Transaction(date(2019, 3, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100))
# a quarterly distribution skipped for december
# this should not prevent forecasts for previous distributions;
# we can't know whether this means distribution stopped completely, or is just a change in frequency;
# require user input
]
scheduled = scheduled_transactions(records, since=date(2020, 1, 20))
assert len(scheduled) == 3
for n in range(0, 14):
# going back 13 days; spanning 2021/03/18 - 2021/04/15; a 28 day period
records = [
Transaction(date(2020, 4, 7), "ABC", 1, Amount(1)),
Transaction(date(2021, 3, 31 - n), "ABC", 1, Amount(1)),
]
scheduled = scheduled_transactions(records, since=date(2021, 3, 31))
assert len(scheduled) == 1
records = [
Transaction(date(2020, 4, 7), "ABC", 1, Amount(1)),
# note that this date is the first date far enough back that
# it is not considered a fit for the april forecast
# i.e. if the date was one day later (2021/03/18), it would be
# considered a fit, and the forecast would be discarded
Transaction(date(2021, 3, 17), "ABC", 1, Amount(1)),
]
scheduled = scheduled_transactions(records, since=date(2021, 3, 31))
assert len(scheduled) == 2
def test_scheduled_transactions_closed_position():
records = [
Transaction(date(2019, 1, 20), "ABC", 1, Amount(100)),
Transaction(date(2020, 1, 19), "ABC", 0),
]
scheduled = scheduled_transactions(records, since=date(2020, 1, 20))
assert len(scheduled) == 0
records = [
Transaction(date(2019, 1, 20), "ABC", 1, Amount(100)),
Transaction(date(2020, 1, 19), "ABC", 0),
Transaction(date(2020, 2, 1), "ABC", 1),
]
scheduled = scheduled_transactions(records, since=date(2020, 1, 20))
assert len(scheduled) == 0
# see example/strategic.journal
records = [
Transaction(date(2019, 1, 20), "ABC", 1, Amount(100)),
Transaction(date(2019, 4, 20), "ABC", 1, Amount(100)),
Transaction(date(2019, 7, 20), "ABC", 1, Amount(100)),
Transaction(date(2019, 10, 20), "ABC", 1, Amount(100)),
Transaction(date(2020, 1, 19), "ABC", 0),
Transaction(date(2020, 2, 1), "ABC", 1),
]
scheduled = scheduled_transactions(records, since=date(2020, 2, 20))
assert len(scheduled) == 4
assert scheduled[0].entry_date == GeneratedDate(2020, 4, 30)
assert scheduled[0].position == 1
assert scheduled[0].amount == GeneratedAmount(100)
# ...
assert scheduled[3].entry_date == GeneratedDate(2021, 1, 31)
assert scheduled[3].position == 1
assert scheduled[3].amount == GeneratedAmount(100)
records = [
Transaction(date(2018, 8, 15), "ABC", 1, Amount(100)),
Transaction(date(2018, 11, 14), "ABC", 1, Amount(100)),
Transaction(date(2019, 2, 20), "ABC", 1, Amount(100)),
Transaction(date(2019, 5, 15), "ABC", 1, Amount(100)),
Transaction(date(2019, 8, 14), "ABC", 1, Amount(100)),
Transaction(date(2019, 11, 20), "ABC", 1, Amount(100)),
# simulate preliminary record, using --by-payout-date (entry_date=ex_date)
Transaction(
date(2020, 3, 12), "ABC", 1, GeneratedAmount(100), ex_date=date(2020, 2, 19)
),
Transaction(date(2020, 2, 28), "ABC", 0),
]
scheduled = scheduled_transactions(records, since=date(2020, 3, 8))
assert len(scheduled) == 0
# for this scenario, assume a user records by payout date, but makes sure to put in
# ex-date when necessary to maintain correct forecasting
records = [
# past dividend transaction; assume semi-annual distribution for scenario
Transaction(date(2018, 10, 5), "ABC", 100, Amount(100)),
# closing position right after passed ex-date
Transaction(date(2019, 1, 16), "ABC", 0),
# opening lower position before reaching payout date
Transaction(date(2019, 1, 26), "ABC", 50),
# payout date; note ex-date set
Transaction(
date(2019, 2, 5), "ABC", 100, Amount(100), ex_date=date(2019, 1, 15)
),
]
scheduled = scheduled_transactions(records, since=date(2019, 2, 16))
assert len(scheduled) == 2
assert scheduled[0].entry_date == date(2019, 10, 15)
assert scheduled[1].entry_date == date(2020, 2, 15)
assert scheduled[0].position == 50
assert scheduled[1].position == 50
# same exact scenario, except in this case, user forgot to set ex-date
from dataclasses import replace
records.append(replace(records[3], ex_date=None))
records.pop(3)
scheduled = scheduled_transactions(records, since=date(2019, 2, 16))
assert len(scheduled) == 2
assert scheduled[0].entry_date == date(2019, 10, 15)
assert scheduled[1].entry_date == date(2020, 2, 15)
assert scheduled[0].position == 100
assert scheduled[1].position == 100
def test_scheduled_transactions_sampling():
records = [
Transaction(date(2019, 3, 10), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 12, 1), "ABC", 1, Amount(100)),
# note 5 days earlier than in the past; this leads to an additional projection
# since there's not more than 12m between; e.g. records sampled will range from:
# 2019/03/05 (exclusive) - 2020/03/05 (inclusive)
# e.g. 2019/03/10 => 2020/03/15, but this one will be discarded (as it has been realized)
Transaction(date(2020, 3, 5), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2020, 3, 12))
assert len(scheduled) == 4
assert scheduled[0].entry_date == date(2020, 6, 15)
records = [
Transaction(date(2019, 3, 5), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 12, 1), "ABC", 1, Amount(100)),
# if it was 5 days later, however, then it would be more than 12m and prove no issue
# e.g. records sampled will range from:
# 2019/03/10 (exclusive) - 2020/03/10 (inclusive)
Transaction(date(2020, 3, 10), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2020, 3, 15))
assert len(scheduled) == 4
assert scheduled[0].entry_date == GeneratedDate(2020, 6, 15)
assert scheduled[3].entry_date == GeneratedDate(2021, 3, 15)
records = [
Transaction(date(2019, 3, 10), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 12, 1), "ABC", 1, Amount(100)),
Transaction(date(2020, 3, 5), "ABC", 1, Amount(100)),
]
# no issue whether earliest record was dated later,
# because the earliest record is now out of the 12m period entirely
scheduled = scheduled_transactions(records, since=date(2020, 4, 1))
assert len(scheduled) == 4
assert scheduled[0].entry_date == date(2020, 6, 15)
records = [
Transaction(date(2019, 3, 10), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 12, 1), "ABC", 1, Amount(100)),
]
scheduled = scheduled_transactions(records, since=date(2020, 3, 12))
assert len(scheduled) == 4
assert scheduled[0].entry_date == GeneratedDate(2020, 3, 15)
records = [
Transaction(date(2019, 3, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 6, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 9, 1), "ABC", 1, Amount(100)),
Transaction(date(2019, 12, 1), "ABC", 1, Amount(100)),
# note february instead of march; i.e. less than 12m between
Transaction(date(2020, 2, 28), "ABC", | |
k, dim in zip(key, self.dims)
if not isinstance(k, integer_types)
)
new_key = []
for k in key:
if isinstance(k, Variable):
k = k.data
if not isinstance(k, BASIC_INDEXING_TYPES):
k = np.asarray(k)
if k.size == 0:
# Slice by empty list; numpy could not infer the dtype
k = k.astype(int)
elif k.dtype.kind == "b":
(k,) = np.nonzero(k)
new_key.append(k)
return dims, OuterIndexer(tuple(new_key)), None
def _nonzero(self):
""" Equivalent numpy's nonzero but returns a tuple of Varibles. """
# TODO we should replace dask's native nonzero
# after https://github.com/dask/dask/issues/1076 is implemented.
nonzeros = np.nonzero(self.data)
return tuple(Variable((dim), nz) for nz, dim in zip(nonzeros, self.dims))
def _broadcast_indexes_vectorized(self, key):
variables = []
out_dims_set = OrderedSet()
for dim, value in zip(self.dims, key):
if isinstance(value, slice):
out_dims_set.add(dim)
else:
variable = (
value
if isinstance(value, Variable)
else as_variable(value, name=dim)
)
if variable.dtype.kind == "b": # boolean indexing case
(variable,) = variable._nonzero()
variables.append(variable)
out_dims_set.update(variable.dims)
variable_dims = set()
for variable in variables:
variable_dims.update(variable.dims)
slices = []
for i, (dim, value) in enumerate(zip(self.dims, key)):
if isinstance(value, slice):
if dim in variable_dims:
# We only convert slice objects to variables if they share
# a dimension with at least one other variable. Otherwise,
# we can equivalently leave them as slices aknd transpose
# the result. This is significantly faster/more efficient
# for most array backends.
values = np.arange(*value.indices(self.sizes[dim]))
variables.insert(i - len(slices), Variable((dim,), values))
else:
slices.append((i, value))
try:
variables = _broadcast_compat_variables(*variables)
except ValueError:
raise IndexError(f"Dimensions of indexers mismatch: {key}")
out_key = [variable.data for variable in variables]
out_dims = tuple(out_dims_set)
slice_positions = set()
for i, value in slices:
out_key.insert(i, value)
new_position = out_dims.index(self.dims[i])
slice_positions.add(new_position)
if slice_positions:
new_order = [i for i in range(len(out_dims)) if i not in slice_positions]
else:
new_order = None
return out_dims, VectorizedIndexer(tuple(out_key)), new_order
def __getitem__(self: VariableType, key) -> VariableType:
"""Return a new Variable object whose contents are consistent with
getting the provided key from the underlying data.
NB. __getitem__ and __setitem__ implement xarray-style indexing,
where if keys are unlabeled arrays, we index the array orthogonally
with them. If keys are labeled array (such as Variables), they are
broadcasted with our usual scheme and then the array is indexed with
the broadcasted key, like numpy's fancy indexing.
If you really want to do indexing like `x[x > 0]`, manipulate the numpy
array `x.values` directly.
"""
dims, indexer, new_order = self._broadcast_indexes(key)
data = as_indexable(self._data)[indexer]
if new_order:
data = duck_array_ops.moveaxis(data, range(len(new_order)), new_order)
return self._finalize_indexing_result(dims, data)
def _finalize_indexing_result(self: VariableType, dims, data) -> VariableType:
"""Used by IndexVariable to return IndexVariable objects when possible."""
return type(self)(dims, data, self._attrs, self._encoding, fastpath=True)
def _getitem_with_mask(self, key, fill_value=dtypes.NA):
"""Index this Variable with -1 remapped to fill_value."""
# TODO(shoyer): expose this method in public API somewhere (isel?) and
# use it for reindex.
# TODO(shoyer): add a sanity check that all other integers are
# non-negative
# TODO(shoyer): add an optimization, remapping -1 to an adjacent value
# that is actually indexed rather than mapping it to the last value
# along each axis.
if fill_value is dtypes.NA:
fill_value = dtypes.get_fill_value(self.dtype)
dims, indexer, new_order = self._broadcast_indexes(key)
if self.size:
if is_duck_dask_array(self._data):
# dask's indexing is faster this way; also vindex does not
# support negative indices yet:
# https://github.com/dask/dask/pull/2967
actual_indexer = indexing.posify_mask_indexer(indexer)
else:
actual_indexer = indexer
data = as_indexable(self._data)[actual_indexer]
mask = indexing.create_mask(indexer, self.shape, data)
# we need to invert the mask in order to pass data first. This helps
# pint to choose the correct unit
# TODO: revert after https://github.com/hgrecco/pint/issues/1019 is fixed
data = duck_array_ops.where(np.logical_not(mask), data, fill_value)
else:
# array cannot be indexed along dimensions of size 0, so just
# build the mask directly instead.
mask = indexing.create_mask(indexer, self.shape)
data = np.broadcast_to(fill_value, getattr(mask, "shape", ()))
if new_order:
data = duck_array_ops.moveaxis(data, range(len(new_order)), new_order)
return self._finalize_indexing_result(dims, data)
def __setitem__(self, key, value):
"""__setitem__ is overloaded to access the underlying numpy values with
orthogonal indexing.
See __getitem__ for more details.
"""
dims, index_tuple, new_order = self._broadcast_indexes(key)
if not isinstance(value, Variable):
value = as_compatible_data(value)
if value.ndim > len(dims):
raise ValueError(
"shape mismatch: value array of shape %s could not be "
"broadcast to indexing result with %s dimensions"
% (value.shape, len(dims))
)
if value.ndim == 0:
value = Variable((), value)
else:
value = Variable(dims[-value.ndim :], value)
# broadcast to become assignable
value = value.set_dims(dims).data
if new_order:
value = duck_array_ops.asarray(value)
value = value[(len(dims) - value.ndim) * (np.newaxis,) + (Ellipsis,)]
value = duck_array_ops.moveaxis(value, new_order, range(len(new_order)))
indexable = as_indexable(self._data)
indexable[index_tuple] = value
@property
def attrs(self) -> Dict[Hashable, Any]:
"""Dictionary of local attributes on this variable."""
if self._attrs is None:
self._attrs = {}
return self._attrs
@attrs.setter
def attrs(self, value: Mapping[Hashable, Any]) -> None:
self._attrs = dict(value)
@property
def encoding(self):
"""Dictionary of encodings on this variable."""
if self._encoding is None:
self._encoding = {}
return self._encoding
@encoding.setter
def encoding(self, value):
try:
self._encoding = dict(value)
except ValueError:
raise ValueError("encoding must be castable to a dictionary")
def copy(self, deep=True, data=None):
"""Returns a copy of this object.
If `deep=True`, the data array is loaded into memory and copied onto
the new object. Dimensions, attributes and encodings are always copied.
Use `data` to create a new object with the same structure as
original but entirely new data.
Parameters
----------
deep : bool, optional
Whether the data array is loaded into memory and copied onto
the new object. Default is True.
data : array_like, optional
Data to use in the new object. Must have same shape as original.
When `data` is used, `deep` is ignored.
Returns
-------
object : Variable
New object with dimensions, attributes, encodings, and optionally
data copied from original.
Examples
--------
Shallow copy versus deep copy
>>> var = xr.Variable(data=[1, 2, 3], dims="x")
>>> var.copy()
<xarray.Variable (x: 3)>
array([1, 2, 3])
>>> var_0 = var.copy(deep=False)
>>> var_0[0] = 7
>>> var_0
<xarray.Variable (x: 3)>
array([7, 2, 3])
>>> var
<xarray.Variable (x: 3)>
array([7, 2, 3])
Changing the data using the ``data`` argument maintains the
structure of the original object, but with the new data. Original
object is unaffected.
>>> var.copy(data=[0.1, 0.2, 0.3])
<xarray.Variable (x: 3)>
array([0.1, 0.2, 0.3])
>>> var
<xarray.Variable (x: 3)>
array([7, 2, 3])
See Also
--------
pandas.DataFrame.copy
"""
if data is None:
data = self._data
if isinstance(data, indexing.MemoryCachedArray):
# don't share caching between copies
data = indexing.MemoryCachedArray(data.array)
if deep:
data = copy.deepcopy(data)
else:
data = as_compatible_data(data)
if self.shape != data.shape:
raise ValueError(
"Data shape {} must match shape of object {}".format(
data.shape, self.shape
)
)
# note:
# dims is already an immutable tuple
# attributes and encoding will be copied when the new Array is created
return self._replace(data=data)
def _replace(
self, dims=_default, data=_default, attrs=_default, encoding=_default
) -> "Variable":
if dims is _default:
dims = copy.copy(self._dims)
if data is _default:
data = copy.copy(self.data)
if attrs is _default:
attrs = copy.copy(self._attrs)
if encoding is _default:
encoding = copy.copy(self._encoding)
return type(self)(dims, data, attrs, encoding, fastpath=True)
def __copy__(self):
return self.copy(deep=False)
def __deepcopy__(self, memo=None):
# memo does nothing but is required for compatibility with
# copy.deepcopy
return self.copy(deep=True)
# mutable objects should not be hashable
# https://github.com/python/mypy/issues/4266
__hash__ = None # type: ignore
@property
def chunks(self):
"""Block dimensions for this array's data or None if it's not a dask
array.
"""
return getattr(self._data, "chunks", None)
_array_counter = itertools.count()
def chunk(self, chunks={}, name=None, lock=False):
"""Coerce this array's data into a dask arrays with the given chunks.
If this variable is a non-dask array, it will be converted to dask
array. If it's a dask array, it will be rechunked to the given chunk
sizes.
If neither chunks is not provided for one or more dimensions, chunk
sizes along that dimension will not be updated; non-dask arrays will be
converted into dask arrays with a single block.
Parameters
----------
chunks : int, tuple or dict, optional
Chunk sizes along each dimension, e.g., ``5``, ``(5, 5)`` or
``{'x': 5, 'y': 5}``.
name : str, optional
Used to generate the name for this array in the internal dask
graph. Does not | |
},
{ 'type': TYPE_UINT32, 'name': 'eventId' },
{ 'type': TYPE_UINT32, 'name': 'deviceId' },
{ 'type': TYPE_UINT32, 'name': 'eventSecond' },
{ 'type': TYPE_UINT32, 'name': 'impact' },
{ 'type': TYPE_IPV6, 'name': 'sourceIpAddress' },
{ 'type': TYPE_IPV6, 'name': 'destinationIpAddress' },
{ 'block': BLOCK_STRING, 'name': 'description' }],
# 156
BLOCK_CORRELATION_EVENT_54: [
{ 'type': TYPE_UINT32, 'name': 'blockType' },
{ 'type': TYPE_UINT32, 'name': 'blockLength' },
{ 'type': TYPE_UINT32, 'name': 'deviceId' },
{ 'type': TYPE_UINT32, 'name': 'correlationEventSecond' },
{ 'type': TYPE_UINT32, 'name': 'eventId' },
{ 'type': TYPE_UINT32, 'name': 'policyId' },
{ 'type': TYPE_UINT32, 'name': 'ruleId' },
{ 'type': TYPE_UINT32, 'name': 'priority' },
{ 'block': BLOCK_STRING, 'name': 'eventDescription' },
{ 'type': TYPE_BYTE, 'name': 'eventType' },
{ 'type': TYPE_UINT32, 'name': 'eventDeviceId' },
{ 'type': TYPE_UINT32, 'name': 'signatureId' },
{ 'type': TYPE_UINT32, 'name': 'signatureGeneratorId' },
{ 'type': TYPE_UINT32, 'name': 'triggerEventSecond' },
{ 'type': TYPE_UINT32, 'name': 'triggerEventMicrosecond' },
{ 'type': TYPE_UINT32, 'name': 'deviceEventId' },
{ 'type': TYPE_UINT32, 'name': 'eventDefinedMask' },
{ 'type': TYPE_BYTE, 'name': 'eventImpactFlags' },
{ 'type': TYPE_BYTE, 'name': 'ipProtocol' },
{ 'type': TYPE_UINT16, 'name': 'networkProtocol' },
{ 'type': TYPE_UINT32, 'name': 'sourceIp' }, # No longer used
{ 'type': TYPE_BYTE, 'name': 'sourceHostType' },
{ 'type': TYPE_UINT16, 'name': 'sourceVlanId' },
{ 'type': TYPE_UUID, 'name': 'sourceOperatingSystemFingerprintUuid' },
{ 'type': TYPE_UINT16, 'name': 'sourceCriticality' },
{ 'type': TYPE_UINT32, 'name': 'sourceUserId' },
{ 'type': TYPE_UINT16, 'name': 'sourcePort' },
{ 'type': TYPE_UINT32, 'name': 'sourceServerId' },
{ 'type': TYPE_UINT32, 'name': 'destinationIp' }, # No longer used
{ 'type': TYPE_BYTE, 'name': 'destinationHostType' },
{ 'type': TYPE_UINT16, 'name': 'destinationVlanId' },
{ 'type': TYPE_UUID, 'name': 'destinationOperatingSystemFingerprintUuid' },
{ 'type': TYPE_UINT16, 'name': 'destinationCriticality' },
{ 'type': TYPE_UINT32, 'name': 'destinationUserId' },
{ 'type': TYPE_UINT16, 'name': 'destinationPort' },
{ 'type': TYPE_UINT32, 'name': 'destinationServerId' },
{ 'type': TYPE_BYTE, 'name': 'impact' },
{ 'type': TYPE_BYTE, 'name': 'blocked' },
{ 'type': TYPE_UUID, 'name': 'intrusionPolicy' },
{ 'type': TYPE_UINT32, 'name': 'ruleAction' },
{ 'block': BLOCK_STRING, 'name': 'netbios' },
{ 'type': TYPE_UINT32, 'name': 'urlCategory' },
{ 'type': TYPE_UINT32, 'name': 'urlReputation' },
{ 'block': BLOCK_STRING, 'name': 'url' },
{ 'type': TYPE_UINT32, 'name': 'clientId' },
{ 'block': BLOCK_STRING, 'name': 'clientVersion' },
{ 'type': TYPE_UUID, 'name': 'accessControlPolicyRevision' },
{ 'type': TYPE_UINT32, 'name': 'accessControlRuleId' },
{ 'type': TYPE_UUID, 'name': 'ingressIntefaceUuid' },
{ 'type': TYPE_UUID, 'name': 'egressIntefaceUuid' },
{ 'type': TYPE_UUID, 'name': 'ingressZoneUuid' },
{ 'type': TYPE_UUID, 'name': 'egressZoneUuid' },
{ 'type': TYPE_IPV6, 'name': 'sourceIpv6Address' },
{ 'type': TYPE_IPV6, 'name': 'destinationIpv6Address' },
{ 'type': TYPE_UINT16, 'name': 'sourceCountry' },
{ 'type': TYPE_UINT16, 'name': 'destinationCountry' },
{ 'type': TYPE_UUID, 'name': 'securityIntelligenceUuid' },
{ 'type': TYPE_UINT128, 'name': 'securityContext' },
{ 'type': TYPE_UINT128, 'name': 'sslPolicyId' },
{ 'type': TYPE_UINT32, 'name': 'sslRuleId' },
{ 'type': TYPE_UINT32, 'name': 'sslActualAction' },
{ 'type': TYPE_UINT32, 'name': 'sslFlowStatus' },
{ 'type': TYPE_UINT160, 'name': 'sslCertificateFingerprint'}],
# 158
BLOCK_USER_INFORMATION_DATA_60: [
{ 'type': TYPE_UINT32, 'name': 'blockType' },
{ 'type': TYPE_UINT32, 'name': 'blockLength' },
{ 'type': TYPE_UINT32, 'name': 'userId' },
{ 'block': BLOCK_STRING, 'name': 'username' },
{ 'type': TYPE_UINT32, 'name': 'realmId' },
{ 'type': TYPE_UINT32, 'name': 'protocol' },
{ 'block': BLOCK_STRING, 'name': 'firstName' },
{ 'block': BLOCK_STRING, 'name': 'lastName' },
{ 'block': BLOCK_STRING, 'name': 'email' },
{ 'block': BLOCK_STRING, 'name': 'department' },
{ 'block': BLOCK_STRING, 'name': 'phone' },
{ 'type': TYPE_UINT32, 'name': 'endpointProfileID' },
{ 'type': TYPE_UINT32, 'name': 'securityGroupId' },
{ 'type': TYPE_UINT128, 'name': 'locationIpv6Address' }],
# 159
BLOCK_USER_LOGIN_INFORMATION_60: [
{ 'type': TYPE_UINT32, 'name': 'blockType' },
{ 'type': TYPE_UINT32, 'name': 'blockLength' },
{ 'type': TYPE_UINT32, 'name': 'timestamp' },
{ 'type': TYPE_IPV4, 'name': 'ipv4Address' },
{ 'block': BLOCK_STRING, 'name': 'username' },
{ 'block': BLOCK_STRING, 'name': 'domain' },
{ 'type': TYPE_UINT32, 'name': 'userId' },
{ 'type': TYPE_UINT32, 'name': 'realmId' },
{ 'type': TYPE_UINT32, 'name': 'endpointProfileId' },
{ 'type': TYPE_UINT32, 'name': 'securityGroupId' },
{ 'type': TYPE_UINT32, 'name': 'applicationId' },
{ 'type': TYPE_UINT32, 'name': 'protocol' },
{ 'block': BLOCK_STRING, 'name': 'email' },
{ 'type': TYPE_IPV6, 'name': 'ipv6Address' },
{ 'type': TYPE_IPV6, 'name': 'locationIpv6Address' },
{ 'type': TYPE_BYTE, 'name': 'loginType' },
{ 'type': TYPE_BYTE, 'name': 'authType' },
{ 'block': BLOCK_STRING, 'name': 'reportedBy' }],
# 160
BLOCK_CONNECTION_STATISTICS_60: [
# Documentation wrong. Missing @pad below
# and ruleReason incorrectly specified as int16
{ 'type': TYPE_UINT32, 'name': 'blockType' },
{ 'type': TYPE_UINT32, 'name': 'blockLength' },
{ 'type': TYPE_UINT32, 'name': 'deviceId' },
{ 'type': TYPE_UUID, 'name': 'ingressZone' },
{ 'type': TYPE_UUID, 'name': 'egressZone' },
{ 'type': TYPE_UUID, 'name': 'ingressInterface' },
{ 'type': TYPE_UUID, 'name': 'egressInterface' },
{ 'type': TYPE_IPV6, 'name': 'initiatorIpAddress' },
{ 'type': TYPE_IPV6, 'name': 'responderIpAddress' },
{ 'type': TYPE_UUID, 'name': 'policyRevision' },
{ 'type': TYPE_UINT32, 'name': 'ruleId' },
{ 'type': TYPE_UINT16, 'name': 'ruleAction' },
{ 'type': TYPE_UINT32, 'name': 'ruleReason' },
{ 'type': TYPE_UINT16, 'name': 'initiatorPort' },
{ 'type': TYPE_UINT16, 'name': 'responderPort' },
{ 'type': TYPE_UINT16, 'name': 'tcpFlag' },
{ 'type': TYPE_BYTE, 'name': 'protocol' },
{ 'type': TYPE_UUID, 'name': 'netflowSource' },
{ 'type': TYPE_UINT16, 'name': 'instanceId' },
{ 'type': TYPE_UINT16, 'name': 'connectionCounter' },
{ 'type': TYPE_UINT32, 'name': 'firstPacketTimestamp' },
{ 'type': TYPE_UINT32, 'name': 'lastPacketTimestamp' },
{ 'type': TYPE_UINT64, 'name': 'initiatorTransmittedPackets' },
{ 'type': TYPE_UINT64, 'name': 'responderTransmittedPackets' },
{ 'type': TYPE_UINT64, 'name': 'initiatorTransmittedBytes' },
{ 'type': TYPE_UINT64, 'name': 'responderTransmittedBytes' },
{ 'type': TYPE_UINT32, 'name': 'userId' },
{ 'type': TYPE_UINT32, 'name': 'applicationId' }, #applicationProtocolId
{ 'type': TYPE_UINT32, 'name': 'urlCategory' },
{ 'type': TYPE_UINT32, 'name': 'urlReputation' },
{ 'type': TYPE_UINT32, 'name': 'clientApplicationId' },
{ 'type': TYPE_UINT32, 'name': 'webApplicationId' },
{ 'block': BLOCK_STRING, 'name': 'clientUrl' },
{ 'block': BLOCK_STRING, 'name': 'netbios' },
{ 'block': BLOCK_STRING, 'name': 'clientApplicationVersion' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule1' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule2' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule3' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule4' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule5' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule6' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule7' },
{ 'type': TYPE_UINT32, 'name': 'monitorRule8' },
{ 'type': TYPE_BYTE, 'name': 'securityIntelligenceSourceDestination' },
{ 'type': TYPE_BYTE, 'name': 'securityIntelligenceLayer' },
{ 'type': TYPE_UINT16, 'name': 'fileEventCount' },
{ 'type': TYPE_UINT16, 'name': 'intrusionEventCount' },
{ 'type': TYPE_UINT16, 'name': 'initiatorCountry' },
{ 'type': TYPE_UINT16, 'name': 'responderCountry' },
{ 'type': TYPE_UINT16, 'name': 'iocNumber' },
{ 'type': TYPE_UINT32, 'name': 'sourceAutonomousSystem' },
{ 'type': TYPE_UINT32, 'name': 'destinationAutonomousSystem' },
{ 'type': TYPE_UINT16, 'name': 'snmpIn' },
{ 'type': TYPE_UINT16, 'name': 'snmpOut' },
{ 'type': TYPE_BYTE, 'name': 'sourceTos' },
{ 'type': TYPE_BYTE, 'name': 'destinationTos' },
{ 'type': TYPE_BYTE, 'name': 'sourceMask' },
{ 'type': TYPE_BYTE, 'name': 'destinationMask' },
{ 'type': TYPE_UINT128, 'name': 'securityContext' },
{ 'type': TYPE_UINT16, 'name': 'vlanId' },
{ 'block': BLOCK_STRING, 'name': 'referencedHost' },
{ 'block': BLOCK_STRING, 'name': 'userAgent' },
{ 'block': BLOCK_STRING, 'name': 'httpReferrer' },
{ 'type': TYPE_UINT160, 'name': 'sslCertificateFingerprint' },
{ 'type': TYPE_UINT128, 'name': 'sslPolicyId' },
{ 'type': TYPE_UINT32, 'name': 'sslRuleId' },
{ 'type': TYPE_UINT16, 'name': 'sslCipherSuite' },
{ 'type': TYPE_BYTE, 'name': 'sslVersion' },
{ 'type': TYPE_UINT32, 'name': 'sslServerCertificateStatus' },
{ 'type': TYPE_UINT16, 'name': 'sslActualAction' },
{ 'type': TYPE_UINT16, 'name': 'sslExpectedAction' },
{ 'type': TYPE_UINT16, 'name': 'sslFlowStatus' },
{ 'type': TYPE_UINT32, 'name': 'sslFlowError' },
{ 'type': TYPE_UINT32, 'name': 'sslFlowMessages' },
{ 'type': TYPE_UINT64, 'name': 'sslFlowFlags' },
{ 'block': BLOCK_STRING, 'name': 'sslServerName' },
{ 'type': TYPE_UINT32, 'name': 'sslUrlCategory' },
{ 'type': TYPE_UINT256, 'name': 'sslSessionId' },
{ 'type': TYPE_BYTE, 'name': 'sslSessionIdLength' },
{ 'type': TYPE_UINT160, 'name': 'sslTicketId' },
{ 'type': TYPE_BYTE, 'name': 'sslTicketIdLength' },
{ 'type': TYPE_UUID, 'name': 'networkAnalysisPolicyRevision' },
{ 'type': TYPE_UINT32, 'name': 'endpointProfileId' },
{ 'type': TYPE_UINT32, 'name': 'securityGroupId' },
{ 'type': TYPE_IPV6, 'name': 'locationIpv6' },
{ 'type': TYPE_UINT32, 'name': 'httpResponse' },
{ 'block': BLOCK_STRING, 'name': 'dnsQuery' },
{ 'type': TYPE_UINT16, 'name': 'dnsRecordType' },
{ 'type': TYPE_UINT16, 'name': 'dnsResponseType' },
{ 'type': TYPE_UINT32, 'name': 'dnsTtl' },
{ 'type': TYPE_UUID, 'name': 'sinkholeUuid' },
{ 'type': TYPE_UINT32, 'name': 'securityIntelligenceList1' },
{ 'type': TYPE_UINT32, 'name': 'securityIntelligenceList2'}],
# 163
BLOCK_CONNECTION_STATISTICS_61: [
# Documentation wrong. Missing @pad below
{ 'type': TYPE_UINT32, 'name': 'blockType' },
{ 'type': TYPE_UINT32, 'name': 'blockLength' },
{ 'type': TYPE_UINT32, 'name': 'deviceId' },
{ 'type': TYPE_UUID, 'name': 'ingressZone' },
{ 'type': TYPE_UUID, 'name': 'egressZone' },
{ 'type': TYPE_UUID, 'name': 'ingressInterface' },
{ 'type': TYPE_UUID, 'name': 'egressInterface' },
{ 'type': TYPE_IPV6, 'name': 'initiatorIpAddress' },
{ 'type': TYPE_IPV6, 'name': 'responderIpAddress' },
{ 'type': TYPE_IPV6, 'name': 'originalClientIpAddress' },
{ 'type': TYPE_UUID, | |
Default is 0.8.
sampleRateHz : int
Samples rate of the audio for playback.
channels : int
Number of channels for the output.
Returns
-------
AudioClip
"""
samples = squaretone(duration, freqHz, dutyCycle, gain, sampleRateHz)
if channels > 1:
samples = np.tile(samples, (1, channels)).astype(np.float32)
return AudioClip(samples, sampleRateHz=sampleRateHz)
@staticmethod
def sawtooth(duration=1.0, freqHz=440, peak=1.0, gain=0.8,
sampleRateHz=SAMPLE_RATE_48kHz, channels=2):
"""Generate audio samples for a tone with a sawtooth waveform.
Parameters
----------
duration : float or int
Length of the sound in seconds.
freqHz : float or int
Frequency of the tone in Hertz (Hz). Note that this differs from the
`sampleRateHz`.
peak : float
Location of the peak between 0.0 and 1.0. If the peak is at 0.5, the
resulting wave will be triangular. A value of 1.0 will cause the
peak to be located at the very end of a cycle.
gain : float
Gain factor ranging between 0.0 and 1.0. Default is 0.8.
sampleRateHz : int
Samples rate of the audio for playback.
channels : int
Number of channels for the output.
Returns
-------
AudioClip
"""
samples = sawtone(duration, freqHz, peak, gain, sampleRateHz)
if channels > 1:
samples = np.tile(samples, (1, channels)).astype(np.float32)
return AudioClip(samples, sampleRateHz=sampleRateHz)
# --------------------------------------------------------------------------
# Audio editing methods
#
# Methods related to basic editing of audio samples (operations such as
# splicing clips and signal gain).
#
def __add__(self, other):
"""Concatenate two audio clips."""
assert other.sampleRateHz == self._sampleRateHz
assert other.channels == self.channels
newSamples = np.ascontiguousarray(
np.vstack((self._samples, other.samples)),
dtype=np.float32)
toReturn = AudioClip(
samples=newSamples,
sampleRateHz=self._sampleRateHz)
return toReturn
def __iadd__(self, other):
"""Concatenate two audio clips inplace."""
assert other.sampleRateHz == self._sampleRateHz
assert other.channels == self.channels
self._samples = np.ascontiguousarray(
np.vstack((self._samples, other.samples)),
dtype=np.float32)
return self
def append(self, clip):
"""Append samples from another sound clip to the end of this one.
The `AudioClip` object must have the same sample rate and channels as
this object.
Parameters
----------
clip : AudioClip
Audio clip to append.
Returns
-------
AudioClip
This object with samples from `clip` appended.
Examples
--------
Join two sound clips together::
snd1.append(snd2)
"""
# if either clip is empty, just replace it
if len(self.samples) == 0:
return clip
if len(clip.samples) == 0:
return self
assert self.channels == clip.channels
assert self._sampleRateHz == clip.sampleRateHz
self._samples = np.ascontiguousarray(
np.vstack((self._samples, clip.samples)),
dtype=np.float32)
# recompute the duration of the new clip
self._duration = len(self.samples) / float(self.sampleRateHz)
return self
def copy(self):
"""Create an independent copy of this `AudioClip`.
Returns
-------
AudioClip
"""
return AudioClip(
samples=self._samples.copy(),
sampleRateHz=self._sampleRateHz)
def gain(self, factor, channel=None):
"""Apply gain the audio samples.
This will modify the internal store of samples inplace. Clipping is
automatically applied to samples after applying gain.
Parameters
----------
factor : float or int
Gain factor to multiply audio samples.
channel : int or None
Channel to apply gain to. If `None`, gain will be applied to all
channels.
"""
try:
arrview = self._samples[:, :] \
if channel is None else self._samples[:, channel]
except IndexError:
raise ValueError('Invalid value for `channel`.')
# multiply and clip range
arrview *= float(factor)
arrview.clip(-1, 1)
# --------------------------------------------------------------------------
# Audio analysis methods
#
# Methods related to basic analysis of audio samples, nothing too advanced
# but still useful.
#
def rms(self, channel=None):
"""Compute the root mean square (RMS) of the samples to determine the
average signal level.
Parameters
----------
channel : int or None
Channel to compute RMS (zero-indexed). If `None`, the RMS of all
channels will be computed.
Returns
-------
ndarray or float
An array of RMS values for each channel if ``channel=None`` (even if
there is one channel an array is returned). If `channel` *was*
specified, a `float` will be returned indicating the RMS of that
single channel.
"""
if channel is not None:
assert 0 < channel < self.channels
arr = self._samples if channel is None else self._samples[:, channel]
rms = np.sqrt(np.mean(np.square(arr), axis=0))
return rms if len(rms) > 1 else rms[0]
# --------------------------------------------------------------------------
# Properties
#
@property
def samples(self):
"""Nx1 or Nx2 array of audio samples (`~numpy.ndarray`).
Values must range from -1 to 1. Values outside that range will be
clipped, possibly resulting in distortion.
"""
return self._samples
@samples.setter
def samples(self, value):
self._samples = np.asarray(value, dtype=float) # convert to array
self._samples.clip(-1., 1.) # do clipping to keep samples in range
# recompute duration after updating samples
self._duration = len(self._samples) / float(self._sampleRateHz)
@property
def sampleRateHz(self):
"""Sample rate of the audio clip in Hz (`int`). Should be the same
value as the rate `samples` was captured at.
"""
return self._sampleRateHz
@sampleRateHz.setter
def sampleRateHz(self, value):
self._sampleRateHz = int(value)
# recompute duration after updating sample rate
self._duration = len(self._samples) / float(self._sampleRateHz)
@property
def duration(self):
"""The duration of the audio in seconds (`float`).
This value is computed using the specified sampling frequency and number
of samples.
"""
return self._duration
@property
def channels(self):
"""Number of audio channels in the clip (`int`).
If `channels` > 1, the audio clip is in stereo.
"""
return self._samples.shape[1]
@property
def isStereo(self):
"""`True` if there are two channels of audio samples.
Usually one for each ear. The first channel is usually the left ear, and
the second the right.
"""
return not self.isMono # are we moving in stereo? ;)
@property
def isMono(self):
"""`True` if there is only one channel of audio data.
"""
return self._samples.shape[1] == 1
@property
def userData(self):
"""User data associated with this clip (`dict`). Can be used for storing
additional data related to the clip. Note that `userData` is not saved
with audio files!
Example
-------
Adding fields to `userData`. For instance, we want to associated the
start time the clip was recorded at with it::
myClip.userData['date_recorded'] = t_start
We can access that field later by::
thisRecordingStartTime = myClip.userData['date_recorded']
"""
return self._userData
@userData.setter
def userData(self, value):
assert isinstance(value, dict)
self._userData = value
def convertToWAV(self):
"""Get a copy of stored audio samples in WAV PCM format.
Returns
-------
ndarray
Array with the same shapes as `.samples` but in 16-bit WAV PCM
format.
"""
return np.asarray(
self._samples * ((1 << 15) - 1), dtype=np.int16).tobytes()
def asMono(self, copy=True):
"""Convert the audio clip to mono (single channel audio).
Parameters
----------
copy : bool
If `True` an :class:`~psychopy.sound.AudioClip` containing a copy
of the samples will be returned. If `False`, channels will be
mixed inplace resulting a the same object being returned. User data
is not copied.
Returns
-------
:class:`~psychopy.sound.AudioClip`
Mono version of this object.
"""
samples = np.atleast_2d(self._samples) # enforce 2D
if samples.shape[1] > 1:
samplesMixed = np.atleast_2d(
np.sum(samples, axis=1, dtype=np.float32) / np.float32(2.)).T
else:
samplesMixed = samples.copy()
if copy:
return AudioClip(samplesMixed, self.sampleRateHz)
self._samples = samplesMixed # overwrite
return self
def transcribe(self, engine='sphinx', language='en-US', expectedWords=None,
config=None):
"""Convert speech in audio to text.
This feature passes the audio clip samples to a specified text-to-speech
engine which will attempt to transcribe any speech within. The efficacy
of the transcription depends on the engine selected, audio quality, and
language support. By default, Pocket Sphinx is used which provides
decent transcription capabilities offline for English and a few other
languages. For more robust transcription capabilities with a greater
range of language support, online providers such as Google may be used.
Speech-to-text conversion blocks the main application thread when used
on Python. Don't transcribe audio during time-sensitive parts of your
experiment! This issue is known to the developers and will be fixed in a
later release.
Parameters
----------
engine : str
Speech-to-text engine to use. Can be one of 'sphinx' for CMU Pocket
Sphinx or 'google' for Google Cloud.
language : str
BCP-47 language code (eg., 'en-US'). Note that supported languages
vary between transcription engines.
expectedWords : list or tuple
List of strings representing expected words or phrases. This will
constrain the possible output words to the ones specified. Note not
all engines support this feature (only Sphinx and Google Cloud do at
this time). A warning will be logged if the engine selected does not
support this feature. CMU PocketSphinx has an additional feature
where the | |
<filename>gamemodes/comDifficulty/hard.py
import gamemodes.assets.turnCounter
from random import randint
from tkinter import *
import platform
# Player is O, Computer is X.
def playerVsComputer(ticTacPyApp):
field = [[" ", " ", " "], [" ", " ", " "], [" ", " ", " "]]
def fieldFilled():
notice = Toplevel(gamepvcom)
notice.geometry()
notice.resizable(width=0, height=0)
if platform.system() == "Windows":
notice.iconbitmap("ttpicon.ico")
noticeText = Label(notice, text=ticTacPyApp.fieldFilledWarning, font=("Arial", 16))
noticeText.pack()
noticeButton = Button(notice, text=ticTacPyApp.okay, font=("Arial", 12))
noticeButton["command"] = notice.destroy
noticeButton.pack()
placeholder7 = Label(notice, text="", font=("Arial", 2))
placeholder7.pack()
def playerWon():
def effectOfYes():
playerOnFirstPlace.destroy()
wannaPlayMore()
# Resetting the turns
gamemodes.assets.turnCounter.playerOne = 0
gamemodes.assets.turnCounter.playerTwo = 0
playerOnFirstPlace = Toplevel(gamepvcom)
playerOnFirstPlace.geometry()
playerOnFirstPlace.resizable(width=0, height=0)
if platform.system() == "Windows":
playerOnFirstPlace.iconbitmap("ttpicon.ico")
winnerText = Label(playerOnFirstPlace, text=f"{ticTacPyApp.playerWonText}\n{ticTacPyApp.playAgainQuestion}", font=("Arial", 16))
winnerText.grid(row=0, column=0, columnspan=3)
yesButton = Button(playerOnFirstPlace, text=ticTacPyApp.yes, font=("Arial", 12))
yesButton["command"] = effectOfYes
yesButton.grid(row=1, column=0)
noButton = Button(playerOnFirstPlace, text=ticTacPyApp.no, font=("Arial", 12))
noButton["command"] = doneWithPlaying
noButton.grid(row=1, column=2)
placeholder7 = Label(playerOnFirstPlace, text="", font=("Arial", 2))
placeholder7.grid(row=2)
def playerLost():
def effectOfYes():
playerOnSecondPlace.destroy()
wannaPlayMore()
# Resetting the turns
gamemodes.assets.turnCounter.playerOne = 0
gamemodes.assets.turnCounter.playerTwo = 0
playerOnSecondPlace = Toplevel(gamepvcom)
playerOnSecondPlace.geometry()
playerOnSecondPlace.resizable(width=0, height=0)
if platform.system() == "Windows":
playerOnSecondPlace.iconbitmap("ttpicon.ico")
loserText = Label(playerOnSecondPlace, text=f"{ticTacPyApp.playerLostText}\n{ticTacPyApp.playAgainQuestion}", font=("Arial", 16))
loserText.grid(row=0, column=0, columnspan=3)
yesButton = Button(playerOnSecondPlace, text=ticTacPyApp.yes, font=("Arial", 12))
yesButton["command"] = effectOfYes
yesButton.grid(row=1, column=0)
noButton = Button(playerOnSecondPlace, text=ticTacPyApp.no, font=("Arial", 12))
noButton["command"] = doneWithPlaying
noButton.grid(row=1, column=2)
placeholder7 = Label(playerOnSecondPlace, text="", font=("Arial", 2))
placeholder7.grid(row=2)
def nobodyWon():
def effectOfYes():
playerEqual.destroy()
wannaPlayMore()
# Resetting the turns
gamemodes.assets.turnCounter.playerOne = 0
gamemodes.assets.turnCounter.playerTwo = 0
playerEqual = Toplevel(gamepvcom)
playerEqual.geometry()
playerEqual.resizable(width=0, height=0)
if platform.system() == "Windows":
playerEqual.iconbitmap("ttpicon.ico")
equalText = Label(playerEqual, text=f"{ticTacPyApp.tieText}\n{ticTacPyApp.playAgainQuestion}", font=("Arial", 16))
equalText.grid(row=0, column=0, columnspan=3)
yesButton = Button(playerEqual, text=ticTacPyApp.yes, font=("Arial", 12))
yesButton["command"] = effectOfYes
yesButton.grid(row=1, column=0)
noButton = Button(playerEqual, text=ticTacPyApp.no, font=("Arial", 12))
noButton["command"] = doneWithPlaying
noButton.grid(row=1, column=2)
placeholder7 = Label(playerEqual, text="", font=("Arial", 2))
placeholder7.grid(row=2)
def doneWithPlaying():
gamepvcom.destroy()
# New code
field[0][0] = " "
field[0][1] = " "
field[0][2] = " "
field[1][0] = " "
field[1][1] = " "
field[1][2] = " "
field[2][0] = " "
field[2][1] = " "
field[2][2] = " "
def wannaPlayMore():
# New code
field[0][0] = " "
field[0][1] = " "
field[0][2] = " "
field[1][0] = " "
field[1][1] = " "
field[1][2] = " "
field[2][0] = " "
field[2][1] = " "
field[2][2] = " "
# Hiding player marks
buttonForCellZeroP.grid_forget()
buttonForCellOneP.grid_forget()
buttonForCellTwoP.grid_forget()
buttonForCellThreeP.grid_forget()
buttonForCellFourP.grid_forget()
buttonForCellFiveP.grid_forget()
buttonForCellSixP.grid_forget()
buttonForCellSevenP.grid_forget()
buttonForCellEightP.grid_forget()
# Hiding computer marks
buttonForCellZeroCom.grid_forget()
buttonForCellOneCom.grid_forget()
buttonForCellTwoCom.grid_forget()
buttonForCellThreeCom.grid_forget()
buttonForCellFourCom.grid_forget()
buttonForCellFiveCom.grid_forget()
buttonForCellSixCom.grid_forget()
buttonForCellSevenCom.grid_forget()
buttonForCellEightCom.grid_forget()
# Placing empty cells back
buttonForCellZero.grid(row=1, column=1)
buttonForCellOne.grid(row=1, column=3)
buttonForCellTwo.grid(row=1, column=5)
buttonForCellThree.grid(row=3, column=1)
buttonForCellFour.grid(row=3, column=3)
buttonForCellFive.grid(row=3, column=5)
buttonForCellSix.grid(row=5, column=1)
buttonForCellSeven.grid(row=5, column=3)
buttonForCellEight.grid(row=5, column=5)
def checkState():
# Checking rows
if field[0][0] == field[0][1] == field[0][2]:
if field[0][0] == "O":
playerWon()
elif field[0][0] == "X":
playerLost()
elif field[1][0] == field[1][1] == field[1][2]:
if field[1][0] == "O":
playerWon()
elif field[1][0] == "X":
playerLost()
elif field[2][0] == field[2][1] == field[2][2]:
if field[2][0] == "O":
playerWon()
elif field[2][0] == "X":
playerLost()
# Checking columns
elif field[0][0] == field[1][0] == field[2][0]:
if field[0][0] == "O":
playerWon()
elif field[0][0] == "X":
playerLost()
elif field[0][1] == field[1][1] == field[2][1]:
if field[0][1] == "O":
playerWon()
elif field[0][1] == "X":
playerLost()
elif field[0][2] == field[1][2] == field[2][2]:
if field[0][2] == "O":
playerWon()
elif field[0][2] == "X":
playerLost()
# Checking diagonals (Sorry for my bad English, I primarily speak German. :( )
elif field[0][0] == field[1][1] == field[2][2]:
if field[0][0] == "O":
playerWon()
elif field[0][0] == "X":
playerLost()
elif field[0][2] == field[1][1] == field[2][0]:
if field[0][2] == "O":
playerWon()
elif field[0][2] == "X":
playerLost()
# Checking if full
elif field[0][0] != " " and field[0][1] != " " and field[0][2] != " " and field[1][0] != " ":
if field[1][1] != " " and field[1][2] != " " and field[2][0] != " ":
if field[2][1] != " " and field[2][2] != " ":
nobodyWon()
# Here is the real game
def fieldZeroPlayer():
if field[0][0] == " ":
field[0][0] = "O"
buttonForCellZero.grid_forget()
buttonForCellZeroP.grid(row=1, column=1)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldOnePlayer():
if field[0][1] == " ":
field[0][1] = "O"
buttonForCellOne.grid_forget()
buttonForCellOneP.grid(row=1, column=3)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldTwoPlayer():
if field[0][2] == " ":
field[0][2] = "O"
buttonForCellTwo.grid_forget()
buttonForCellTwoP.grid(row=1, column=5)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldThreePlayer():
if field[1][0] == " ":
field[1][0] = "O"
buttonForCellThree.grid_forget()
buttonForCellThreeP.grid(row=3, column=1)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldFourPlayer():
if field[1][1] == " ":
field[1][1] = "O"
buttonForCellFour.grid_forget()
buttonForCellFourP.grid(row=3, column=3)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldFivePlayer():
if field[1][2] == " ":
field[1][2] = "O"
buttonForCellFive.grid_forget()
buttonForCellFiveP.grid(row=3, column=5)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldSixPlayer():
if field[2][0] == " ":
field[2][0] = "O"
buttonForCellSix.grid_forget()
buttonForCellSixP.grid(row=5, column=1)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldSevenPlayer():
if field[2][1] == " ":
field[2][1] = "O"
buttonForCellSeven.grid_forget()
buttonForCellSevenP.grid(row=5, column=3)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldEightPlayer():
if field[2][2] == " ":
field[2][2] = "O"
buttonForCellEight.grid_forget()
buttonForCellEightP.grid(row=5, column=5)
gamemodes.assets.turnCounter.playerOne += 1
computerTurn()
ticTacPyApp.gridCopy = field.copy()
def fieldZeroComputer():
if field[0][0] == " ":
field[0][0] = "X"
buttonForCellZero.grid_forget()
buttonForCellZeroCom.grid(row=1, column=1)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldOneComputer():
if field[0][1] == " ":
field[0][1] = "X"
buttonForCellOne.grid_forget()
buttonForCellOneCom.grid(row=1, column=3)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldTwoComputer():
if field[0][2] == " ":
field[0][2] = "X"
buttonForCellTwo.grid_forget()
buttonForCellTwoCom.grid(row=1, column=5)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldThreeComputer():
if field[1][0] == " ":
field[1][0] = "X"
buttonForCellThree.grid_forget()
buttonForCellThreeCom.grid(row=3, column=1)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldFourComputer():
if field[1][1] == " ":
field[1][1] = "X"
buttonForCellFour.grid_forget()
buttonForCellFourCom.grid(row=3, column=3)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldFiveComputer():
if field[1][2] == " ":
field[1][2] = "X"
buttonForCellFive.grid_forget()
buttonForCellFiveCom.grid(row=3, column=5)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldSixComputer():
if field[2][0] == " ":
field[2][0] = "X"
buttonForCellSix.grid_forget()
buttonForCellSixCom.grid(row=5, column=1)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldSevenComputer():
if field[2][1] == " ":
field[2][1] = "X"
buttonForCellSeven.grid_forget()
buttonForCellSevenCom.grid(row=5, column=3)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def fieldEightComputer():
if field[2][2] == " ":
field[2][2] = "X"
buttonForCellEight.grid_forget()
buttonForCellEightCom.grid(row=5, column=5)
gamemodes.assets.turnCounter.playerTwo += 1
checkState()
else:
computerTurn()
def computerTurn():
def getMove():
if i == 0:
fieldZeroComputer()
elif i == 1:
fieldOneComputer()
elif i == 2:
fieldTwoComputer()
elif i == 3:
fieldThreeComputer()
elif i == 4:
fieldFourComputer()
elif i == 5:
fieldFiveComputer()
elif i == 6:
fieldSixComputer()
elif i == 7:
fieldSevenComputer()
elif i == 8:
fieldEightComputer()
checkState()
if gamemodes.assets.turnCounter.playerOne != 0 and gamemodes.assets.turnCounter.playerOne > gamemodes.assets.turnCounter.playerTwo:
i = 0
while i < len(ticTacPyApp.gridCopy):
if ticTacPyApp.gridCopy[i] == " ":
gridWithNewMove = ticTacPyApp.gridCopy
gridWithNewMove[i] = "O"
if gridWithNewMove[0] == gridWithNewMove[1] == gridWithNewMove[2] == "O":
getMove()
break
elif gridWithNewMove[4] == gridWithNewMove[3] == gridWithNewMove[5] == "O":
getMove()
break
elif gridWithNewMove[7] == gridWithNewMove[8] == gridWithNewMove[6] == "O":
getMove()
break
elif gridWithNewMove[0] == gridWithNewMove[3] == gridWithNewMove[6] == "O":
getMove()
break
elif gridWithNewMove[1] == gridWithNewMove[4] == gridWithNewMove[7] == "O":
getMove()
break
elif gridWithNewMove[2] == gridWithNewMove[5] == gridWithNewMove[8] == "O":
getMove()
break
elif gridWithNewMove[0] == gridWithNewMove[4] == gridWithNewMove[8] == "O":
getMove()
break
elif gridWithNewMove[2] == gridWithNewMove[4] == gridWithNewMove[6] == "O":
getMove()
break
i += 1
i = 0
if gamemodes.assets.turnCounter.playerOne > gamemodes.assets.turnCounter.playerTwo:
while i < len(ticTacPyApp.gridCopy):
if ticTacPyApp.gridCopy[i] == " ":
gridWithNewMove = ticTacPyApp.gridCopy
gridWithNewMove[i] = "X"
if gridWithNewMove[0] == gridWithNewMove[1] == gridWithNewMove[2] == "X":
getMove()
break
elif gridWithNewMove[4] == gridWithNewMove[3] == gridWithNewMove[5] == "X":
getMove()
break
elif gridWithNewMove[7] == gridWithNewMove[8] == gridWithNewMove[6] == "X":
getMove()
break
elif gridWithNewMove[0] == gridWithNewMove[3] == gridWithNewMove[6] == "X":
getMove()
break
elif gridWithNewMove[1] == gridWithNewMove[4] == gridWithNewMove[7] == "X":
getMove()
break
elif gridWithNewMove[2] == gridWithNewMove[5] == gridWithNewMove[8] == "X":
getMove()
break
elif gridWithNewMove[0] == gridWithNewMove[4] == gridWithNewMove[8] == "X":
getMove()
break
elif gridWithNewMove[2] == gridWithNewMove[4] == gridWithNewMove[6] == "X":
getMove()
break
i += 1
if gamemodes.assets.turnCounter.playerOne > gamemodes.assets.turnCounter.playerTwo:
computer = randint(0, 8)
if computer == 0:
fieldZeroComputer()
elif computer == 1:
| |
import numpy as np
from matplotlib import pyplot as plt
from mpl_toolkits import mplot3d
import neural_net
import utils
def plot_lra_random_weight_losses(linear_regressor_ann, input_dim, output_dim, train1_x, train1_nb_examples, train1_y):
min_lra_loss = np.inf
random_weights = np.arange(-10,11)
fig = plt.figure()
fig.set_facecolor('w')
for i in random_weights:
linear_regressor_ann.set_weights(i.reshape((output_dim, input_dim)))
lra_output = linear_regressor_ann.forward(train1_x.reshape((train1_nb_examples, input_dim, output_dim)))
lra_loss = np.mean(linear_regressor_ann.loss(train1_y))
if lra_loss < min_lra_loss:
min_lra_loss = lra_loss
plt.scatter(i, lra_loss, color="blue")
plt.title('Loss for Linear regressor ANN')
plt.xlabel('weights')
plt.ylabel('loss')
print(f"Minimum loss:{min_lra_loss:.2f}")
plt.show()
def plot_tla_random_weight_losses(two_layer_ann, input_dim, output_dim, nb_of_hiddenunits, train1_x, train1_nb_examples, train1_y, randomize_first_layer):
random_weights = np.arange(-10,11)
fig = plt.figure(figsize=(12, 6))
ax = fig.add_subplot(111, projection='3d')
for i in random_weights:
for j in random_weights:
if randomize_first_layer:
two_layer_ann.set_weights_1(np.array([i, j]).reshape((nb_of_hiddenunits, input_dim)))
else:
two_layer_ann.set_weights_2(np.array([i, j]).reshape((output_dim, nb_of_hiddenunits)))
tla_output = two_layer_ann.forward(train1_x.reshape((train1_nb_examples, input_dim, output_dim)))
tla_loss = np.mean(two_layer_ann.loss(train1_y))
ax.scatter(i, j, tla_loss, color="blue")
plt.title('Loss for Two Layer ANN')
if randomize_first_layer:
ax.set_xlabel('weights_1')
ax.set_ylabel('weights_1')
else:
ax.set_xlabel('weights_2')
ax.set_ylabel('weights_2')
ax.set_zlabel('loss')
plt.show()
def train_lra(hyperparams, linear_regressor_ann, train_x, train_y, input_dim, output_dim, train_nb_examples, train_uniform_x_samples, label="train"):
learning_rate, nb_of_epochs, batch_size = hyperparams
fig = plt.figure()
min_lra_loss = np.inf
for epoch in range(nb_of_epochs):
for i in range(train_nb_examples//batch_size):
linear_regressor_ann.forward(train_x[i*batch_size:i*batch_size+batch_size].reshape((batch_size, input_dim, output_dim)))
linear_regressor_ann.loss(train_y[i*batch_size:i*batch_size+batch_size])
linear_regressor_ann.backward(learning_rate)
lra_output = linear_regressor_ann.forward(train_x.reshape((train_nb_examples, input_dim, output_dim)))
lra_loss = np.mean(linear_regressor_ann.loss(train_y))
print(f"Epoch:{epoch+1}, Linear regressor ANN loss:{lra_loss:.4f}")
plt.scatter(train_x, train_y)
lra_output = linear_regressor_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, lra_output.reshape((train_nb_examples, 1)), linewidth=3)
plt.title(f'Linear regressor ANN, Epoch:{epoch+1}, Training Set, Loss:{lra_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'gif/lra_{epoch+1:03d}.png')
plt.close()
if min_lra_loss - lra_loss > 1e-5:
min_lra_loss = lra_loss
else:
print("Stopped training")
plt.scatter(train_x, train_y)
lra_output = linear_regressor_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, lra_output.reshape((train_nb_examples, 1)), linewidth=3)
plt.title(f'Linear regressor ANN, Epoch:{epoch+1}, Training Set, Loss:{lra_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/lra_{label}.png')
plt.close()
break
def evaluate_lra(linear_regressor_ann, x, nb_examples, input_dim, output_dim, y, mode_str):
lra_output = linear_regressor_ann.forward(x.reshape((nb_examples, input_dim, output_dim)))
lra_loss = np.mean(linear_regressor_ann.loss(y))
lra_loss_std = np.std(linear_regressor_ann.loss(y))
print(f"Linear regressor ANN, {mode_str} set loss:{lra_loss:.4f}, std:{lra_loss_std:.4f}")
return lra_loss
def plot_lra_evaluation(linear_regressor_ann, x, input_dim, output_dim, y, mode_str, lra_loss, train_uniform_x_samples, train_nb_examples, label):
fig = plt.figure()
fig.set_facecolor('w')
plt.scatter(x, y)
lra_output = linear_regressor_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, lra_output.reshape((train_nb_examples, 1)), linewidth=3)
plt.title(f'Linear regressor ANN, {mode_str} Set, Loss:{np.mean(lra_loss):.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/lra_{label}.png')
plt.show()
def train_tla(data_ix, train_x, train_y, input_dim, output_dim, train_nb_examples, train_uniform_x_samples):
if data_ix == 1:
lr_config = {2: 8e-3, 4: 1e-2, 8: 1e-2, 16: 5e-3}
epoch_config = {2: 5500, 4: 8000, 8: 7500, 16: 9000}
batchsize_config = {2: 2, 4: 2, 8: 2, 16: 3}
activation_config = {2: "sigmoid", 4: "sigmoid", 8: "sigmoid", 16: "sigmoid"}
loss_config = {2: "mse", 4: "mse", 8: "mse", 16: "mse"}
momentum_config = {2: 0.75, 4: 0.75, 8: 0.9, 16: 0.6}
stop_loss_config = {2: 0.05795, 4: 0.02025, 8: 0.02045, 16: 0.02065}
plot_color = {2: "red", 4: "cyan", 8: "magenta", 16: "black"}
elif data_ix == 2:
lr_config = {2: 9e-3, 4: 9e-3, 8: 1e-2, 16: 9e-3}
epoch_config = {2: 7500, 4: 6500, 8: 8000, 16: 30000}
batchsize_config = {2: 3, 4: 3, 8: 2, 16: 2}
activation_config = {2: "sigmoid", 4: "sigmoid", 8: "sigmoid", 16: "sigmoid"}
loss_config = {2: "mse", 4: "mse", 8: "mse", 16: "mse"}
momentum_config = {2: 0.4, 4: 0.4, 8: 0.5, 16: 0.3}
stop_loss_config = {2: 0.28005, 4: 0.14305, 8: 0.05975, 16: 0.05915}
plot_color = {2: "red", 4: "cyan", 8: "magenta", 16: "black"}
trained_nets = []
anim_files = []
for nb_of_hiddenunits in (2, 4, 8, 16):
np.random.seed(550)
learning_rate = lr_config[nb_of_hiddenunits]
nb_of_epochs = epoch_config[nb_of_hiddenunits]
batch_size = batchsize_config[nb_of_hiddenunits]
two_layer_ann = neural_net.TwoLayerANN(nb_of_hiddenunits,
activation_function=activation_config[nb_of_hiddenunits],
loss_function=loss_config[nb_of_hiddenunits],
use_momentum=True, momentum_factor=momentum_config[nb_of_hiddenunits])
fig = plt.figure()
print(f"Training two layer ANN with {nb_of_hiddenunits} units")
for epoch in range(nb_of_epochs):
for i in range(train_nb_examples//batch_size):
two_layer_ann.forward(train_x[i*batch_size:i*batch_size+batch_size].reshape((batch_size, input_dim, output_dim)))
two_layer_ann.loss(train_y[i*batch_size:i*batch_size+batch_size])
two_layer_ann.backward(learning_rate)
tla_output = two_layer_ann.forward(train_x.reshape((train_nb_examples, input_dim, output_dim)))
tla_loss = np.mean(two_layer_ann.loss(train_y))
if (data_ix == 1 and (epoch == 0 or (epoch+1) % 500 == 0)) or (data_ix == 2 and epoch == 0 or (epoch+1) % (1500 if nb_of_hiddenunits == 16 else 500) == 0):
print(f"Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
plt.scatter(train_x, train_y)
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)),
color=plot_color[nb_of_hiddenunits], linewidth=3)
plt.title(f'Two layer ANN ({nb_of_hiddenunits} units), Epoch:{epoch+1}, Training Set, Loss:{tla_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'gif/tla_{nb_of_hiddenunits}_{epoch+1:05d}.png')
plt.close()
if tla_loss < stop_loss_config[nb_of_hiddenunits]:
print(f"Stopped training, Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
plt.scatter(train_x, train_y)
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)),
color=plot_color[nb_of_hiddenunits], linewidth=3)
plt.title(f'Two layer ANN ({nb_of_hiddenunits} units), Epoch:{epoch+1}, Training Set, Loss:{tla_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_{nb_of_hiddenunits}_train{"_2" if data_ix == 2 else ""}.png')
plt.close()
break
anim_file = f'gif/tla_{nb_of_hiddenunits}_training{"_2" if data_ix == 2 else ""}.gif'
utils.create_animation(anim_file, f'gif/tla_{nb_of_hiddenunits}_*.png', fps=4 if data_ix == 1 else 8)
trained_nets.append(two_layer_ann)
anim_files.append(anim_file)
return trained_nets, anim_files
def evaluate_tla(trained_nets, train_x, train_y, test_x, test_y, train_nb_examples, test_nb_examples, train_uniform_x_samples, input_dim, output_dim, label=""):
ann_hidden_units = [2, 4, 8, 16]
plot_color = {2: "red", 4: "cyan", 8: "magenta", 16: "black"}
for i in range(4):
two_layer_ann = trained_nets[i]
tla_output = two_layer_ann.forward(train_x.reshape((train_nb_examples, input_dim, output_dim)))
tla_loss = np.mean(two_layer_ann.loss(train_y))
tla_loss_std = np.std(two_layer_ann.loss(train_y))
print(f"Two layer ANN, {ann_hidden_units[i]} units, training set loss:{tla_loss:.4f}, std:{tla_loss_std:.4f}")
fig = plt.figure()
fig.set_facecolor('w')
plt.scatter(train_x, train_y)
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)),
color=plot_color[ann_hidden_units[i]], linewidth=3)
plt.title(f'Two layer ANN, {ann_hidden_units[i]} units, Training Set, Loss:{np.mean(tla_loss):.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_{ann_hidden_units[i]}_train_curve{label}.png')
plt.show()
tla_output = two_layer_ann.forward(test_x.reshape((test_nb_examples, input_dim, output_dim)))
tla_loss = np.mean(two_layer_ann.loss(test_y))
tla_loss_std = np.std(two_layer_ann.loss(test_y))
print(f"Two layer ANN, {ann_hidden_units[i]} units, test set loss:{tla_loss:.4f}, std:{tla_loss_std:.4f}")
fig = plt.figure()
fig.set_facecolor('w')
plt.scatter(test_x, test_y)
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)),
color=plot_color[ann_hidden_units[i]], linewidth=3)
plt.title(f'Two layer ANN, {ann_hidden_units[i]} units, Test Set, Loss:{np.mean(tla_loss):.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_{ann_hidden_units[i]}_test_curve{label}.png')
plt.show()
def plot_tla_curves(trained_nets, train_x, train_y, train_uniform_x_samples, train_nb_examples, input_dim, output_dim, loc="upper left", label=""):
plot_color = {2: "red", 4: "cyan", 8: "magenta", 16: "black"}
fig = plt.figure()
fig.set_facecolor('w')
plt.scatter(train_x, train_y)
two_layer_ann = trained_nets[0]
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)), label='2 Units',
color=plot_color[2], linewidth=3)
two_layer_ann = trained_nets[1]
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)), label='4 Units',
color=plot_color[4], linewidth=6)
two_layer_ann = trained_nets[2]
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)), label='8 Units',
color=plot_color[8], linewidth=3)
two_layer_ann = trained_nets[3]
tla_output = two_layer_ann.forward(train_uniform_x_samples.reshape((train_nb_examples, input_dim, output_dim)))
plt.plot(train_uniform_x_samples, tla_output.reshape((train_nb_examples, 1)), label='16 Units',
color=plot_color[16], linewidth=3)
leg = plt.legend(loc=loc)
for legobj in leg.legendHandles:
legobj.set_linewidth(3)
plt.title(f'Two layer ANNs with different number of hidden units')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_all_curves{label}.png')
plt.show()
def train_tla_different_lrs(train2_x, train2_y, train2_nb_examples, train2_uniform_x_samples, input_dim, output_dim):
nb_of_hiddenunits = 8
lr = {0: 1, 1: 1e-1, 2: 1e-2, 3: 1e-3, 4: 1e-4}
nb_epoch = {0: 1, 1: 500, 2: 2500, 3: 25000, 4: 225000}
batch_size = 229
activation = "sigmoid"
loss = "mse"
momentum = 0.99
stop_loss = 0.12
plot_color = "magenta"
for j in lr:
np.random.seed(550)
learning_rate = lr[j]
nb_of_epochs = nb_epoch[j]
two_layer_ann = neural_net.TwoLayerANN(nb_of_hiddenunits,
activation_function=activation,
loss_function=loss,
use_momentum=True, momentum_factor=momentum)
fig = plt.figure()
fig.set_facecolor('w')
print(f"Training two layer ANN with {nb_of_hiddenunits} units, LR:{learning_rate}")
for epoch in range(nb_of_epochs):
for i in range(train2_nb_examples//batch_size):
two_layer_ann.forward(train2_x[i*batch_size:i*batch_size+batch_size].reshape((batch_size, input_dim, output_dim)))
two_layer_ann.loss(train2_y[i*batch_size:i*batch_size+batch_size])
two_layer_ann.backward(learning_rate)
tla_output = two_layer_ann.forward(train2_x.reshape((train2_nb_examples, input_dim, output_dim)))
tla_loss = np.mean(two_layer_ann.loss(train2_y))
if epoch == 0 or (epoch+1) % (1 if j == 0 else (500 if j < 3 else (10000 if j == 3 else 30000))) == 0:
print(f"Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
if tla_loss < stop_loss:
print(f"Stopped training, Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
plt.scatter(train2_x, train2_y)
tla_output = two_layer_ann.forward(train2_uniform_x_samples.reshape((train2_nb_examples, input_dim, output_dim)))
plt.plot(train2_uniform_x_samples, tla_output.reshape((train2_nb_examples, 1)), plot_color,
linewidth=3)
plt.title(f'Two layer ANN ({nb_of_hiddenunits} units), Epoch:{epoch+1}, Training Set, Loss:{tla_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_{nb_of_hiddenunits}_train_d{j}.png')
plt.show()
break
if epoch == nb_of_epochs - 1:
print(f"Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
plt.scatter(train2_x, train2_y)
tla_output = two_layer_ann.forward(train2_uniform_x_samples.reshape((train2_nb_examples, input_dim, output_dim)))
plt.plot(train2_uniform_x_samples, tla_output.reshape((train2_nb_examples, 1)), plot_color,
linewidth=3)
plt.title(f'Two layer ANN ({nb_of_hiddenunits} units), Epoch:{epoch+1}, Training Set, Loss:{tla_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_{nb_of_hiddenunits}_train_d{j}.png')
plt.show()
def train_tla_momentum(train2_x, train2_y, train2_nb_examples, train2_uniform_x_samples, input_dim, output_dim):
nb_of_hiddenunits = 8
learning_rate = 1e-2
nb_of_epochs = 300000
batch_size = 229
activation = "sigmoid"
loss = "mse"
mf = {0: 0, 1: 0.99}
stop_loss = 0.12
plot_color = "magenta"
for j in mf:
np.random.seed(550)
momentum = mf[j]
two_layer_ann = neural_net.TwoLayerANN(nb_of_hiddenunits,
activation_function=activation,
loss_function=loss,
use_momentum=True, momentum_factor=momentum)
fig = plt.figure()
fig.set_facecolor('w')
print(f"Training two layer ANN with {nb_of_hiddenunits} units, MF:{momentum}")
for epoch in range(nb_of_epochs):
for i in range(train2_nb_examples//batch_size):
two_layer_ann.forward(train2_x[i*batch_size:i*batch_size+batch_size].reshape((batch_size, input_dim, output_dim)))
two_layer_ann.loss(train2_y[i*batch_size:i*batch_size+batch_size])
two_layer_ann.backward(learning_rate)
tla_output = two_layer_ann.forward(train2_x.reshape((train2_nb_examples, input_dim, output_dim)))
tla_loss = np.mean(two_layer_ann.loss(train2_y))
if epoch == 0 or (epoch+1) % (40000 if j == 0 else 500) == 0:
print(f"Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
if tla_loss < stop_loss:
print(f"Stopped training, Epoch:{epoch+1}, Two layer ANN loss:{tla_loss:.4f}")
plt.scatter(train2_x, train2_y)
tla_output = two_layer_ann.forward(train2_uniform_x_samples.reshape((train2_nb_examples, input_dim, output_dim)))
plt.plot(train2_uniform_x_samples, tla_output.reshape((train2_nb_examples, 1)), plot_color,
linewidth=3)
plt.title(f'Two layer ANN ({nb_of_hiddenunits} units), Epoch:{epoch+1}, Training Set, Loss:{tla_loss:.4f}')
plt.xlabel('x')
plt.ylabel('y')
plt.savefig(f'output/tla_{nb_of_hiddenunits}_train_e{j}.png')
plt.show()
break
def train_tla_batch(train2_x, train2_y, train2_nb_examples, train2_uniform_x_samples, input_dim, output_dim):
nb_of_hiddenunits = 8
learning_rates | |
# -*- coding: utf-8 -*-
"""
This is the base file that can serve as a starting point for the Python Adaptor development.
This file can also be used as template for Python modules.
main_logger.
"""
import argparse as ap
import csv
import datetime
import logging
import os
import pandas as pd
from pathlib import Path
import subprocess
import re
from shutil import move
import xarray as xr
import sys
import xml.etree.ElementTree as ET
# For package only #
# uncomment this when building the wheel distribution: python setup.py bdist_wheel
# from epaswmmadaptor import epaswmm
# from epaswmmadaptor import __version__
__author__ = "pbishop,lboutin"
__copyright__ = "pbishop,lboutin"
__license__ = "mit"
# XML namespace dict, needed to find elements
namespace = {"pi": "http://www.wldelft.nl/fews/PI"}
def add_attributes(ds):
"""
Add model specific attributes to make it more CF compliant
"""
ds.time.attrs["standard_name"] = "time"
ds.time.attrs["long_name"] = "time"
ds.time.attrs["axis"] = "T"
ds.station_id.attrs["standard_name"] = "Station Identifier"
ds.station_id.attrs["long_name"] = "EPA_SWMM Station Identifier"
ds.station_id.attrs["axis"] = "XY"
ds.station_id.attrs["cf_role"] = "timeseries_id"
ds = ds.assign_attrs(
Conventions="CF-1.6",
title="Data from simulation outputs",
institution="TRCA",
source="Don River Hydrology Update Project Number 60528844 December 2018",
history=datetime.datetime.utcnow().replace(microsecond=0).isoformat(" ")
+ " EMT: simulation results from EPA SWMM model",
references="https://trca.ca/",
Metadata_Conventions="Unidata Dataset Discovery v1.0",
summary="EPA SWMM simulation output",
date_created=datetime.datetime.utcnow().replace(microsecond=0).isoformat(" ")
+ " EMT",
coordinate_system="WGS 1984",
featureType="timeSeries",
comment="created from Python script EPA-SWMM-Adaptor",
)
return ds
def bytes_to_string(df, col_to_convert):
"""
Decodes columns in a dataframe. When the NetCDF file is read, string columns are encoded.
"""
for x in col_to_convert:
df[x] = df[x].str.decode('utf-8')
return df
def check_properties(key, props, run_info_file):
if key not in props:
main_logger.error("Key (%s) was not specified in the run_info.xml file." % key)
raise KeyError(
f'"{key}" needs to be specified under <properties> in {run_info_file.resolve()}'
)
def create_xarray_dataset(data_dict, swmm_unit_dict):
"""
Creating xarray datasets.
"""
main_logger.debug("Creating DataSet from the results DataFrame.")
list_ds_nodes = []
list_ds_links = []
list_keys_ignored = []
for key in data_dict.keys():
try:
header = data_dict[key]['Header']
units = data_dict[key]['Units']
rename_header = {}
except Exception:
main_logger.error("Failed to get header/units when creating dataset.")
stop_program()
for item in range(0, len(units)):
try:
rename_header[units[item]] = header[item]
temp_df = data_dict[key]['Data'].copy(deep=True)
temp_df = temp_df.rename(rename_header, axis='columns')
temp_df['station_id'] = key
temp_df.set_index(['station_id'], append=True, inplace=True)
ds2 = xr.Dataset.from_dataframe(temp_df)
except Exception:
main_logger.error("Failed to create DataSet for {0}".format(temp_df['station_id']))
stop_program()
for var, unit in data_dict[key]['units_dict'].items():
try:
attributes_info = swmm_unit_dict.get(unit)
for attrs, val in attributes_info.items():
if attrs == 'UDUNITS':
attrs = 'units'
ds2[var].attrs[attrs] = val
except Exception:
main_logger.error(
"Error raised due to EPA SWMM unit --> {0} is not recognized. Please add corresponding information into the UDUNITS_lookup.csv input file.".format(
unit))
stop_program()
raise KeyError(
"Error raised due to EPA SWMM unit --> {0} is not recognized. Please add corresponding information into the UDUNITS_lookup.csv input file.".format(
unit))
try:
if "node" in key.lower():
list_ds_nodes.append(ds2)
elif "link" in key.lower():
list_ds_links.append(ds2)
else:
list_keys_ignored.append(key)
pass
except Exception:
main_logger.error("Failed to append data to dataset for: {0}".format(key))
stop_program()
print("Locations ignored in the resulting output file (i.e. not a node or a link): \n\n" + str(list_keys_ignored))
# Combining Dataset for each station_id with same type
try:
main_logger.debug("Start combining xarray DataSets for nodes ...")
combined_ds_nodes = xr.combine_by_coords(list_ds_nodes)
combined_ds_nodes = add_attributes(combined_ds_nodes)
except Exception:
main_logger.error("Failed to combining xarray DataSets for nodes")
stop_program()
try:
main_logger.debug("Start combining xarray DataSets for links ...")
combined_ds_links = xr.combine_by_coords(list_ds_links)
combined_ds_links = add_attributes(combined_ds_links)
except Exception:
main_logger.error("Failed to combining xarray DataSets for links")
stop_program()
print("\nDone creating xarray DataSet for Nodes and Links.\n")
main_logger.debug("Done creating xarray DataSet for Nodes and Links.")
return combined_ds_nodes, combined_ds_links
def dir_element(elem, exists=True):
"""
Checks if a string or XML element is a directory path, and returns the corresponding path.
"""
if isinstance(elem, str):
# such that this works if the path is in an attribute
path = Path(elem)
else:
path = Path(elem.text)
if exists and not path.is_dir():
main_logger.error(
"The following is expected to exist but was not found: %s" % (os.path.join(os.getcwd(), path)))
stop_program()
raise FileNotFoundError(path.resolve())
return path
def file_element(elem, exists=True):
"""
Checks if a string or XML element is a path, and returns the corresponding path.
"""
if isinstance(elem, str):
# such that this works if the path is in an attribute
if "bin" in elem:
path = Path(elem)
root = Path(os.getcwd())
path = os.path.join(root.parents[0], path)
path = Path(path)
else:
path = Path(elem)
else:
path = Path(elem.text)
if exists and not path.is_file():
print("The following is expected to exist but was not found: %s" % (os.path.join(os.getcwd(), path)))
main_logger.error(
"The following is expected to exist but was not found: %s" % (os.path.join(os.getcwd(), path)))
stop_program()
raise FileNotFoundError(path.resolve())
return path
def make_df(lines, start, nrows, df_header):
"""
Method to create a pandas DataFrame from a subset of lines from the simulation results *.rpt file.
"""
# PERFORMANCE ISSUE: parsers.py from pandas is causing lost in performance.
# Using pandas.DataFrame() method allowed increasing performance.
# df = pd.read_csv(file, delimiter=r"\s+", names=df_header, header=None,
# skiprows=start+2,nrows=nrows-1, parse_dates=[0], dayfirst = False)
try:
df = pd.DataFrame([[i for i in line.strip().split()] for line in lines[start + 2:start + nrows - 1]],
columns=df_header)
df['DateO'] = pd.to_datetime(df['Date'])
df['TimeO'] = pd.to_timedelta(df['Time'])
df['time'] = df['DateO'] + df['TimeO']
df = df.drop(columns=['DateO', 'TimeO', 'Date', 'Time'])
df = df.set_index('time')
df = df.apply(pd.to_numeric)
except Exception:
main_logger.error("Failed to create dataframe for line starting with: {0}".format(lines[start]))
stop_program()
return df
def read_netcdf(netcdf_filename, col_to_convert):
"""
Read a netCDF file and return a pandas DataFrame
"""
ds = xr.open_dataset(netcdf_filename)
try:
df = ds.to_dataframe()
except Exception:
main_logger.error("Failed to create dataframe when reading the NetCDF file.")
stop_program()
try:
df = bytes_to_string(df, col_to_convert)
except Exception:
main_logger.error("Failed to decode following columns when reading NetCDF file: " + ','.join(col_to_convert))
stop_program()
return df
def read_errors_warnings(file_list):
"""
Read errors and warnings from the *.rpt ASCII and Python log file output from the simulation.
"""
main_logger.debug("File list: {0}".format(file_list))
list_warning_error = []
df = None
for f in file_list:
try:
with open(f, "r") as fi:
for ln in fi:
if any(x in ln for x in ["ERROR", "WARNING", "DEBUG", "INFO", "FATAL"]):
list_warning_error.append(ln.strip())
except Exception:
main_logger.error(
"The following is expected to exist but was not found: {0}".format(os.path.join(os.getcwd(), f)))
stop_program()
raise FileNotFoundError(Path(f).resolve())
if len(list_warning_error) > 0:
df = pd.Series(list_warning_error).str.split(":", 1, expand=True).rename(
columns={0: "level", 1: "description"})
df["description"] = [x.strip() for x in df["description"]]
df = df.drop_duplicates(["level",
"description"]).reset_index() # SWMM outputs identical warnings sometimes, which does not add any value
else:
df = None
# CONVERT TO FEWS ERROR Numbering
if df is not None and len(df) > 0:
df['description'] = df['level'] + ": " + df['description']
for index, row in df.iterrows():
if "DEBUG" in row["level"]:
df.at[index, "level"] = 4
if "INFO" in row["level"]:
df.at[index, "level"] = 3
if "WARN" in row["level"]:
df.at[index, "level"] = 2
if "ERROR" in row["level"]:
df.at[index, "level"] = 1
if "FATAL" in row["level"]:
df.at[index, "level"] = 0
else:
main_logger.info("No errors, warnings or info messages were detected.")
df = pd.DataFrame(columns=['description', 'level'])
return df
def read_rpt_file(rpt_input_file):
"""
Read *.rpt ASCII file with timeSeries output from the simulation.
"""
try:
with open(rpt_input_file, "r") as f:
lines = f.readlines()
data_dict = {}
in_data = False
varchange = False
old_name = ""
main_logger.debug("Starting parsing *.rpt file...")
# Parse ASCII *.rpt file into nested Dictionary/DataFrame
for i in range(0, len(lines)):
try:
if "<<<" in lines[i]:
new_name = lines[i].strip().strip("<<<").strip(">>>").lstrip(" ").rstrip(" ").replace(" ", "_")
print("Proceeding with --> ", new_name)
data_dict[new_name] = {'start_line': i + 3}
# Parsing Header and Units information.
# Two potential cases:
# 1) Date and Time located on the Header line (Nodes and Links)
# 2) Date and Time located on the Units line (Subcatchment)
header = lines[i + 2].strip().lstrip(" ").rstrip(" ").rstrip("/").split()
units = lines[i + 3].strip().lstrip(" ").rstrip(" ").rstrip("/").split() # [2::]
if len(header) > len(units):
df_header = header
header = header[2::]
else:
df_header = units[:2] + header
units = units[2::]
units_dict = {}
for item in range(len(header)):
units_dict[header[item]] = units[item]
data_dict[new_name] = {'start_line': i + 3, 'Header': header, 'Units': units,
'df_header': df_header, 'units_dict': units_dict}
if not in_data:
in_data = True
elif varchange:
varchange = False
# Pass when there's a change in variable
else:
data_dict[old_name]['end_line'] = i - 3
df_header = data_dict[old_name]['df_header']
start = data_dict[old_name]['start_line']
nrows = data_dict[old_name]['end_line'] - data_dict[old_name]['start_line']
df = make_df(lines, start, nrows, df_header)
data_dict[old_name]['Data'] = df
elif not in_data:
pass
elif "***" in lines[i]: # Export type/variable change
data_dict[old_name]['end_line'] = i - 5
df_header = data_dict[old_name]['df_header']
start = data_dict[old_name]['start_line']
nrows = | |
from flask import render_template, flash, redirect, url_for, request, Flask, jsonify, send_from_directory
from app import app, db, ImmigrationToolBox, DataWizardTools
from app.models import User, Post
from app.forms import PostForm
from werkzeug.urls import url_parse
from datetime import datetime
import pandas as pd
@app.route("/IOIimmQuarterly", methods=['GET', 'POST'])
def upload_IOIimmQuarterly():
if request.method == 'POST':
print(request.files['file'])
f = request.files['file']
test = pd.read_excel(f)
test.fillna('',inplace=True)
#Cleaning
if test.iloc[0][0] == '':
df = pd.read_excel(f,skiprows=2)
else:
df = pd.read_excel(f)
df.fillna('',inplace=True)
#Create Hyperlinks
df['Hyperlinked Case #'] = df.apply(lambda x : DataWizardTools.Hyperlinker(x['Matter/Case ID#']),axis=1)
df['Assigned Branch/CC'] = df['Assigned Branch/CC'].str.replace('Bronx Legal Services','BxLS')
df['Assigned Branch/CC'] = df['Assigned Branch/CC'].str.replace('Brooklyn Legal Services','BkLS')
df['Assigned Branch/CC'] = df['Assigned Branch/CC'].str.replace('Queens Legal Services','QLS')
df['Assigned Branch/CC'] = df['Assigned Branch/CC'].str.replace('Manhattan Legal Services','MLS')
df['Assigned Branch/CC'] = df['Assigned Branch/CC'].str.replace('Staten Island Legal Services','SILS')
df['Assigned Branch/CC'] = df['Assigned Branch/CC'].str.replace('Legal Support Unit','LSU')
#Determining 'level of service' from 3 fields
df['HRA Level of Service'] = df.apply(lambda x: ImmigrationToolBox.HRA_Level_Service(x['Close Reason'],x['Level of Service']), axis=1)
#HRA Case Coding
#Putting Cases into HRA's Baskets!
df['HRA Case Coding'] = df.apply(lambda x: ImmigrationToolBox.HRA_Case_Coding(x['Legal Problem Code'],x['Special Legal Problem Code'],x['HRA Level of Service'],x['IOI Does Client Have A Criminal History? (IOI 2)']), axis=1)
#Dummy SLPC for Juvenile Cases
def DummySLPC(LPC,SLPC):
LPC = str(LPC)
SLPC = str(SLPC)
if LPC == "44 Minor Guardianship / Conservatorship" or LPC == "42 Neglected/Abused/Dependent":
return 'N/A'
else:
return SLPC
df['Special Legal Problem Code'] = df.apply(lambda x: DummySLPC(x['Legal Problem Code'],x['Special Legal Problem Code']), axis=1)
df['HRA Service Type'] = df['HRA Case Coding'].apply(lambda x: x[:2] if x != 'Hold For Review' else '')
df['HRA Proceeding Type'] = df['HRA Case Coding'].apply(lambda x: x[3:] if x != 'Hold For Review' else '')
#Giving things better names in cleanup sheet
df['DHCI form?'] = df['Has Declaration of Household Composition and Income (DHCI) Form?']
df['Consent form?'] = df['IOI HRA Consent Form? (IOI 2)']
df['Client Name'] = df['Full Person/Group Name (Last First)']
df['Office'] = df['Assigned Branch/CC']
df['Country of Origin'] = df['IOI Country Of Origin (IOI 1 and 2)']
df['Substantial Activity'] = df['IOI Substantial Activity (Choose One)']
df['Date of Substantial Activity'] = df['Custom IOI Date substantial Activity Performed']
#Income Waiver
def Income_Exclude(IncomePct,Waiver,Referral):
IncomePct = int(IncomePct)
Waiver = str(Waiver)
if Referral == 'Action NY':
return ''
elif IncomePct > 200 and Waiver.startswith('2') == False:
return 'Needs Income Waiver'
else:
return ''
df['Exclude due to Income?'] = df.apply(lambda x: Income_Exclude(x['Percentage of Poverty'],x['IOI HRA WAIVER APPROVAL DATE if over 200% of FPL (IOI 2)'],x['IOI Referral Source (IOI 2)']), axis=1)
#Eligibility_Date & Rollovers
def Eligibility_Date(Effective_Date,Date_Opened):
if Effective_Date != '':
return Effective_Date
else:
return Date_Opened
df['Eligibility_Date'] = df.apply(lambda x : Eligibility_Date(x['IOI HRA Effective Date (optional) (IOI 2)'],x['Date Opened']), axis = 1)
#Manipulable Dates
df['Open Month'] = df['Eligibility_Date'].apply(lambda x: str(x)[:2])
df['Open Day'] = df['Eligibility_Date'].apply(lambda x: str(x)[3:5])
df['Open Year'] = df['Eligibility_Date'].apply(lambda x: str(x)[6:])
df['Open Construct'] = df['Open Year'] + df['Open Month'] + df['Open Day']
df['Subs Month'] = df['Date of Substantial Activity'].apply(lambda x: str(x)[:2])
df['Subs Day'] = df['Date of Substantial Activity'].apply(lambda x: str(x)[3:5])
df['Subs Year'] = df['Date of Substantial Activity'].apply(lambda x: str(x)[6:])
df['Subs Construct'] = df['Subs Year'] + df['Subs Month'] + df['Subs Day']
df['Subs Construct'] = df.apply(lambda x : x['Subs Construct'] if x['Subs Construct'] != '' else 0, axis = 1)
df['Outcome1 Month'] = df['IOI Outcome 2 Date (IOI 2)'].apply(lambda x: str(x)[:2])
df['Outcome1 Day'] = df['IOI Outcome 2 Date (IOI 2)'].apply(lambda x: str(x)[3:5])
df['Outcome1 Year'] = df['IOI Outcome 2 Date (IOI 2)'].apply(lambda x: str(x)[6:])
df['Outcome1 Construct'] = df['Outcome1 Year'] + df['Outcome1 Month'] + df['Outcome1 Day']
df['Outcome2 Month'] = df['IOI Secondary Outcome Date 2 (IOI 2)'].apply(lambda x: str(x)[:2])
df['Outcome2 Day'] = df['IOI Secondary Outcome Date 2 (IOI 2)'].apply(lambda x: str(x)[3:5])
df['Outcome2 Year'] = df['IOI Secondary Outcome Date 2 (IOI 2)'].apply(lambda x: str(x)[6:])
df['Outcome2 Construct'] = df['Outcome2 Year'] + df['Outcome2 Month'] + df['Outcome2 Day']
#DHCI Form
def DHCI_Needed(DHCI,Open_Construct,LoS):
if Open_Construct == '':
return ''
elif LoS.startswith('Advice'):
return ''
elif LoS.startswith('Brief'):
return ''
elif int(Open_Construct) < 20180701:
return ''
elif DHCI != 'Yes':
return 'Needs DHCI Form'
else:
return ''
df['Needs DHCI?'] = df.apply(lambda x: DHCI_Needed(x['Has Declaration of Household Composition and Income (DHCI) Form?'],x['Open Construct'],x['Level of Service']), axis=1)
#Needs Substantial Activity to Rollover into FY'20
def Needs_Rollover(Open_Construct,Substantial_Activity,Substantial_Activity_Date,CaseID,ReportedFY19):
if int(Open_Construct) >= 20190701:
return ''
elif Substantial_Activity != '' and int(Substantial_Activity_Date) >= 20190701 and int(Substantial_Activity_Date) <= 20200630:
return ''
elif CaseID in ReportedFY19:
return 'Needs Substantial Activity in FY20'
else:
return ''
df['Needs Substantial Activity?'] = df.apply(lambda x: Needs_Rollover(x['Open Construct'],x['Substantial Activity'],x['Subs Construct'],x['Matter/Case ID#'], ImmigrationToolBox.ReportedFY19), axis=1)
#Outcomes
#if there are two outcomes choose which outcome to report based on which one happened more recently
def OutcomeToReport (Outcome1,OutcomeDate1,Outcome2,OutcomeDate2,ServiceLevel,CloseDate):
if OutcomeDate1 == '' and OutcomeDate2 == '' and CloseDate != '' and ServiceLevel == 'Advice':
return 'Advice given'
elif OutcomeDate1 == '' and OutcomeDate2 == '' and CloseDate != '' and ServiceLevel == 'Brief Service':
return 'Advice given'
elif CloseDate != '' and ServiceLevel == 'Full Rep or Extensive Service' and Outcome1 == '' and Outcome2 == '':
return '*Needs Outcome*'
elif OutcomeDate1 >= OutcomeDate2:
return Outcome1
elif OutcomeDate2 > OutcomeDate1:
return Outcome2
else:
return 'no actual outcome'
df['Outcome To Report'] = df.apply(lambda x: OutcomeToReport(x['IOI Outcome 2 (IOI 2)'],x['Outcome1 Construct'],x['IOI Secondary Outcome 2 (IOI 2)'],x['Outcome2 Construct'],x['HRA Level of Service'],x['Date Closed']), axis=1)
#make it add the outcome date as well (or tell you if you need it!)
def OutcomeDateToReport (Outcome1,OutcomeDate1,Outcome2,OutcomeDate2,ServiceLevel,CloseDate,ActualOutcomeDate1,ActualOutcomeDate2):
if OutcomeDate1 == '' and OutcomeDate2 == '' and CloseDate != '' and ServiceLevel == 'Advice':
return CloseDate
elif OutcomeDate1 == '' and OutcomeDate2 == '' and CloseDate != '' and ServiceLevel == 'Brief Service':
return CloseDate
elif OutcomeDate1 >= OutcomeDate2:
return ActualOutcomeDate1
elif OutcomeDate2 > OutcomeDate1:
return ActualOutcomeDate2
else:
return '*Needs Outcome Date*'
df['Outcome Date To Report'] = df.apply(lambda x: OutcomeDateToReport(x['IOI Outcome 2 (IOI 2)'],x['Outcome1 Construct'],x['IOI Secondary Outcome 2 (IOI 2)'],x['Outcome2 Construct'],x['HRA Level of Service'],x['Date Closed'],x['IOI Outcome 2 Date (IOI 2)'],x['IOI Secondary Outcome Date 2 (IOI 2)']), axis=1)
#kind of glitchy - if it has an outcome date but no outcome it doesn't say *Needs Outcome*
#add LSNYC to start of case numbers
df['Unique_ID'] = 'LSNYC'+df['Matter/Case ID#']
#take second letters of first and last names
df['Last_Initial'] = df['Client Last Name'].str[1]
df['First_Initial'] = df['Client First Name'].str[1]
#Year of birth
df['Year_of_Birth'] = df['Date of Birth'].str[-4:]
#Unique Client ID#
df['Unique Client ID#'] = df['First_Initial'] + df['Last_Initial'] + df['Year_of_Birth']
#Deliverable Categories
def Deliverable_Category(HRA_Coded_Case,Income_Cleanup,Age_at_Intake):
if Income_Cleanup == 'Needs Income Waiver':
return 'Needs Cleanup'
elif HRA_Coded_Case == 'T2-RD' and Age_at_Intake <= 21:
return 'Tier 2 (minor removal)'
elif HRA_Coded_Case == 'T2-RD':
return 'Tier 2 (removal)'
elif HRA_Coded_Case.startswith('T2') == True:
return 'Tier 2 (other)'
elif HRA_Coded_Case.startswith('T1')== True:
return 'Tier 1'
elif HRA_Coded_Case.startswith('B') == True:
return 'Brief'
else:
return 'Needs Cleanup'
df['Deliverable Tally'] = df.apply(lambda x: Deliverable_Category(x['HRA Case Coding'],x['Exclude due to Income?'],x['Age at Intake']), axis=1)
#make all cases for any client that has a minor removal tally, into also being minor removal cases
dfs = df.groupby('Unique Client ID#',sort = False)
tdf = pd.DataFrame()
for x, y in dfs:
for z in y['Deliverable Tally']:
if z == 'Tier 2 (minor removal)':
y['Modified Deliverable Tally'] = 'Tier 2 (minor removal)'
tdf = tdf.append(y)
df = tdf
#write function to identify blank 'modified deliverable tallies' and add it back in as the original deliverable tally
df.fillna('',inplace= True)
def fillBlanks(ModifiedTally,Tally):
if ModifiedTally == '':
return Tally
else:
return ModifiedTally
df['Modified Deliverable Tally'] = df.apply(lambda x: fillBlanks(x['Modified Deliverable Tally'],x['Deliverable Tally']),axis=1)
#***add code to make it so that it deletes any extra 'brief' cases for clients that have mutliple cases
#gender
def HRAGender (gender):
if gender == 'Male' or gender == 'Female':
return gender
else:
return 'Other'
df['Gender'] = df.apply(lambda x: HRAGender(x['Gender']), axis=1)
| |
this test if it completely |
| notContains | surrounds a feature in selectingLayer. No portion of the |
| | containing feature; however, the contained feature is allowed |
| | to touch the containing feature (that is, share a common |
| | point along its boundary). |
| | |
| | contains-If a feature in layer contains a feature in |
| | selectingLayer, the feature in layer is included in the output. |
| | notcontains-If a feature in layer contains a feature in |
| | selectingLayer, the feature in the first layer is excluded |
+-------------------+----------------------------------------------------------------------------------------+
| within | |within| |
| | |
| | A feature in layer passes this test if it is completely |
| notWithin | surrounded by a feature in selectingLayer. The entire feature |
| | layer must be within the containing feature; however, the two |
| | features are allowed to touch (that is, share a common point |
| | along its boundary). |
| | |
| | * within-If a feature in layer is completely within a feature in |
| | selectingLayer, the feature in layer is included in the output. |
| | * notwithin-If a feature in layer is completely within a feature |
| | in selectingLayer, the feature in layer is excluded from the |
| | output. |
| | |
| | **Note:** |
| | |
| | can use the within relationship for points and lines, just as |
| | you can with the contains relationship. For example, your first |
| | layer contains points representing manhole covers and you want |
| | to find the manholes that are on street centerlines (as opposed |
| | to parking lots or other non-street features). You could use |
| | within to find manhole points within street centerlines, but |
| | in order for a point to contain a line, the point must be exactly |
| | on the line (that is, in GIS terms, they are snapped to each |
| | other). If there is any doubt about this, use the withinDistance |
| | relationship with a suitable distance value. |
+-------------------+----------------------------------------------------------------------------------------+
| nearest | |nearest| |
| | |
| | feature in the first layer passes this test if it is nearest |
| | to a feature in the second layer. |
| | |
| | * nearest-If a feature in the first layer is nearest to a |
| | feature in the second layer, the feature in the first layer |
| | is included in the output. |
+-------------------+----------------------------------------------------------------------------------------+
* ``distance`` is the distance to use for the withinDistance and notWithinDistance spatial relationship.
* ``units`` is the units for distance.
Choice list: ['Meters', 'Kilometers', 'Feet', 'Yards', 'Miles']
An expression may be a list, which denotes a group. The first operator in the group indicates how the group expression
is added to the previous expression. Grouping expressions is only necessary when you need to create two or more distinct
sets of features from the same layer. One way to think of grouping is that without grouping, you would have to execute
``find_existing_locations`` multiple times and merge the results.
------------------------------------- ------------------------------------------------------------------------------------------------------
output_name Optional string. If provided, the method will create a feature layer of the results. You define the name of the layer.
If ``output_name`` is not supplied, the task will return a feature collection.
------------------------------------- ------------------------------------------------------------------------------------------------------
context Optional string. Additional settings such as processing extent and output spatial reference. For ``find_existing_locations``, there are two settings.
#. Extent (``extent``)-a bounding box that defines the analysis area. Only those points in the input_layers that intersect the bounding box will be analyzed.
#. Output Spatial Reference (``outSR``)-the output features will be projected into the output spatial reference.
------------------------------------- ------------------------------------------------------------------------------------------------------
gis Optional, the GIS on which this tool runs. If not specified, the active GIS is used.
------------------------------------- ------------------------------------------------------------------------------------------------------
estimate Optional boolean. Is true, the number of credits needed to run the operation will be returned as a float.
------------------------------------- ------------------------------------------------------------------------------------------------------
future Optional boolean. If True, the result will be a GPJob object and results will be returned asynchronously.
===================================== ======================================================================================================
:Returns: result_layer : feature layer Item if output_name is specified, else Feature Collection.
.. code-block:: python
#USAGE EXAMPLE: To find busy (where SEGMENT_TY is 1 and where ARTERIAL_C is 1) streets from the existing seattle streets layer.
arterial_streets = find_existing_locations(input_layers=[bike_route_streets],
expressions=[{"operator":"","layer":0,"where":"SEGMENT_TY = 1"},
{"operator":"and","layer":0,"where":"ARTERIAL_C = 1"}],
output_name='ArterialStreets')
"""
if input_layers is None:
input_layers = []
if expressions is None:
expressions = []
gis = _arcgis.env.active_gis if gis is None else gis
return gis._tools.featureanalysis.find_existing_locations(
input_layers,
expressions,
output_name,
context,
estimate=estimate,future=future)
def derive_new_locations(
input_layers=[],
expressions=[],
output_name=None,
context=None,
gis=None,
estimate=False,
future=False):
"""
.. image:: _static/images/derive_new_locations/derive_new_locations.png
.. |intersect| image:: _static/images/derive_new_locations/intersect.png
.. |distance| image:: _static/images/derive_new_locations/distance.png
.. |within| image:: _static/images/derive_new_locations/within.png
.. |nearest| image:: _static/images/derive_new_locations/nearest.png
.. |contains| image:: _static/images/derive_new_locations/contains.png
The ``derive_new_locations`` method derives new features from the input layers that meet a query you specify. A query is
made up of one or more expressions. There are two types of expressions: attribute and spatial. An example of an
attribute expression is that a parcel must be vacant, which is an attribute of the Parcels layer
(STATUS = 'VACANT'). An example of a spatial expression is that the parcel must also be within a certain
distance of a river (Parcels within a distance of 0.75 Miles from Rivers).
The ``derive_new_locations`` method is very similar to the ``find_existing_locations`` method, the main difference is that
the result of ``derive_new_locations`` can contain partial features.
* In both methods, the attribute expression ``where`` and the spatial relationships within and contains return the same result.
This is because these relationships return entire features.
* When ``intersects`` or ``within_distance`` is used, ``derive_new_locations`` creates new features
in the result. For example, when intersecting a parcel feature and a flood zone area that partially overlap each other,
``find_existing_locations`` will return the entire parcel whereas ``derive_new_locations`` will return just the portion of
the parcel that is within the flood zone.
===================================== ======================================================================================================
**Argument** **Description**
------------------------------------- ------------------------------------------------------------------------------------------------------
input_layers Required list of feature layers. A list of layers that will be used in the expressions parameter.
Each layer in the list can be:
* a feature service layer with an optional filter to select specific features, or
* a feature collection
------------------------------------- ------------------------------------------------------------------------------------------------------
expressions Required dict. There are two types of expressions, attribute and spatial.
Example attribute expression:
{
"operator": "and",
"layer": 0,
"where": "STATUS = 'VACANT'"
}
**Note**
* operator can be either ``and`` or ``or``
* layer is the index of the layer in the ``input_layers`` parameter.
* The where clause must be surrounded by double quotes.
* When dealing with text fields, values must be single-quoted ('VACANT').
* Date fields support all queries except LIKE. Dates are strings in YYYY:MM:DD hh:mm:ss format. Here's an example using the date field ObsDate:
"where": "ObsDate >= '1998-04-30 13:30:00' "
+----------+------------------------------------------------------------------+
| = | Equal |
+----------+------------------------------------------------------------------+
| > | Greater than |
+----------+------------------------------------------------------------------+
| < | Less than |
+----------+------------------------------------------------------------------+
| >= | Greater than or equal to |
+----------+------------------------------------------------------------------+
| <= | Less than or equal to |
+----------+------------------------------------------------------------------+
| <> | Not equal |
+----------+------------------------------------------------------------------+
| LIKE '% | A percent symbol (%) signifies a wildcard, meaning that |
| <string>'| anything is acceptable in its place-one character, a |
| | hundred characters, or no character. This expression |
| | would select Mississippi and Missouri among USA |
| | state names: STATE_NAME LIKE 'Miss%' |
+----------+------------------------------------------------------------------+
| BETWEEN | Selects a record if it has a value greater than or equal |
| <value1> | to <value1> | |
<gh_stars>1-10
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License
from .common import DistributedOperator
from .common import DistributedOperatorImpl
from .common import register_distributed_operator
from .common import register_distributed_operator_impl
from ..utils import is_dim_shard
from ..utils import is_dim_replicate
from ..utils import is_valid_list_index
from ..utils import compute_compatible_dim_mapping
from ..utils import compute_compatible_dims_mapping
from ..utils import compute_compatible_and_update_dim_mapping
from paddle.fluid import core, unique_name
from paddle.fluid.framework import in_dygraph_mode
from paddle.fluid.framework import Program, Parameter, Variable, program_guard
from paddle.fluid.data_feeder import check_variable_and_dtype, check_dtype
from ..process import new_process_group
from ..utils import _get_comm_group
def _update_dims_mapping_for_matmul(op_dist_attr):
changed = False
op_desc = op_dist_attr.get_owner_op().desc
x_name = op_desc.input('X')[0]
y_name = op_desc.input('Y')[0]
out_name = op_desc.output('Out')[0]
x_dims_mapping = op_dist_attr.get_input_dims_mapping(x_name)
y_dims_mapping = op_dist_attr.get_input_dims_mapping(y_name)
out_dims_mapping = op_dist_attr.get_output_dims_mapping(out_name)
x_dims_mapping_len = len(x_dims_mapping)
y_dims_mapping_len = len(y_dims_mapping)
out_dims_mapping_len = len(out_dims_mapping)
# Add dim mapping to Make sure the length dims_mapping be at least 2
if x_dims_mapping_len == 1:
x_dims_mapping.insert(0, -1)
if y_dims_mapping_len == 1:
y_dims_mapping.insert(1, -1)
# Deal with dim > 2 and take care of broadcasting
if out_dims_mapping_len > 2:
broadcast_x_dims_mapping = []
broadcast_y_dims_mapping = []
broadcast_out_dims_mapping = []
for i in range(out_dims_mapping_len - x_dims_mapping_len):
broadcast_x_dims_mapping.append(out_dims_mapping[i])
for i in range(x_dims_mapping_len - 2):
broadcast_x_dims_mapping.append(x_dims_mapping[i])
for i in range(out_dims_mapping_len - y_dims_mapping_len):
broadcast_y_dims_mapping.append(out_dims_mapping[i])
for i in range(y_dims_mapping_len - 2):
broadcast_y_dims_mapping.append(y_dims_mapping[i])
for i in range(out_dims_mapping_len - 2):
broadcast_out_dims_mapping.append(out_dims_mapping[i])
compatible_dims_mapping = compute_compatible_dims_mapping([
broadcast_x_dims_mapping, broadcast_y_dims_mapping,
broadcast_out_dims_mapping
])
assert compatible_dims_mapping is not None, "There is no compatible dim mapping."
for i in range(x_dims_mapping_len - 2):
new_idx = i + (out_dims_mapping_len - x_dims_mapping_len)
if x_dims_mapping[i] != compatible_dims_mapping[new_idx]:
x_dims_mapping[i] = compatible_dims_mapping[new_idx]
changed = True
for i in range(y_dims_mapping_len - 2):
new_idx = i + (out_dims_mapping_len - y_dims_mapping_len)
if y_dims_mapping[i] != compatible_dims_mapping[new_idx]:
y_dims_mapping[i] = compatible_dims_mapping[new_idx]
changed = True
for i in range(out_dims_mapping_len - 2):
if out_dims_mapping[i] != compatible_dims_mapping[i]:
out_dims_mapping[i] = compatible_dims_mapping[i]
changed = True
# The following which uses negative index can be work
# when len(out_dims_mapping) > 2 and len(out_dims_mapping) <=2
dim_changed = compute_compatible_and_update_dim_mapping(
[x_dims_mapping, y_dims_mapping], [-1, -2])
if dim_changed:
changed = True
dim_changed = compute_compatible_and_update_dim_mapping(
[x_dims_mapping, out_dims_mapping], [-2, -2])
if dim_changed:
changed = True
dim_changed = compute_compatible_and_update_dim_mapping(
[y_dims_mapping, out_dims_mapping], [-1, -1])
if dim_changed:
changed = True
# Remove unnecessary dim mapping to make sure the lenght of dims_mapping is same as its tensor
if x_dims_mapping_len == 1:
x_dims_mapping.pop(0)
if y_dims_mapping_len == 1:
y_dims_mapping.pop(1)
assert len(x_dims_mapping) == x_dims_mapping_len
assert len(y_dims_mapping) == y_dims_mapping_len
assert len(out_dims_mapping) == out_dims_mapping_len
return changed
class DistributedMatmul(DistributedOperator):
def __init__(self, name):
super(DistributedMatmul, self).__init__()
self._name = name
register_distributed_operator("matmul", DistributedMatmul("matmul"))
# ColumnParallel
class DistributedMatmulImpl0(DistributedOperatorImpl):
def __init__(self, name):
super(DistributedMatmulImpl0, self).__init__()
self._name = name
self._forward_implemented = True
self._backward_implemented = False
def is_process_mesh_compatible(self, op_dist_attr):
""" No restriction for now. """
return True
def is_input_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
x_name = op_desc.input('X')[0]
y_name = op_desc.input('Y')[0]
x_dims_mapping = op_dist_attr.get_input_dims_mapping(x_name)
y_dims_mapping = op_dist_attr.get_input_dims_mapping(y_name)
if is_dim_shard(x_dims_mapping[-1]):
return False
if is_dim_shard(y_dims_mapping[0]) or is_dim_replicate(y_dims_mapping[
1]):
return False
for mapping in x_dims_mapping[1:-1]:
if is_dim_shard(mapping):
return False
return True
def is_output_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
out_name = op_desc.output('Out')[0]
out_dims_mapping = op_dist_attr.get_output_dims_mapping(out_name)
if is_dim_replicate(out_dims_mapping[-1]):
return False
for mapping in out_dims_mapping[1:-1]:
if is_dim_shard(mapping):
return False
return True
def update_dims_mapping(self, op_dist_attr):
changed = False
dim_changed = _update_dims_mapping_for_matmul(op_dist_attr)
if dim_changed:
changed = True
return changed
def forward(self, serial_op):
def static_handle(dst_block,
src_op,
op_dist_attr,
input_name_mapping,
output_name_mapping,
rank_id=0):
assert len(
input_name_mapping
) == 2, "col_parallel_linear take 2 inputs variable but got {}".format(
input_name_mapping)
assert len(
output_name_mapping
) == 1, "col_parallel_linear take 2 inputs variable but got {}".format(
output_name_mapping)
assert len(
input_name_mapping['X']
) == 1, "col_parallel_linear input X take 1 variable but got {}".format(
input_name_mapping['X'])
assert len(
input_name_mapping['Y']
) == 1, "col_parallel_linear input Y take 1 variable but got {}".format(
input_name_mapping['Y'])
assert len(
output_name_mapping['Out']
) == 1, "col_parallel_linear input Out take 1 variable but got {}".format(
input_name_mapping['Out'])
X_var = dst_block.var(input_name_mapping['X'][0])
Weight_var = dst_block.var(input_name_mapping['Y'][0])
Out_var = dst_block.var(output_name_mapping['Out'][0])
# TODO infer logic comm presentation
model_parallel_axis, process_mesh = op_dist_attr.get_owner_context(
)._get_model_parallel_info()
group_ranks = _get_comm_group(process_mesh.process_group,
process_mesh.topology,
model_parallel_axis, rank_id)
group = new_process_group(group_ranks)
intermediate_var_0 = dst_block.create_var(
name=unique_name.generate_with_ignorable_key(".".join(
["c_identity", 'tmp'])),
dtype=X_var.dtype,
shape=X_var.shape,
type=core.VarDesc.VarType.LOD_TENSOR,
persistable=False,
stop_gradient=X_var.stop_gradient)
check_variable_and_dtype(
X_var, 'tensor',
['float16', 'float32', 'float64', 'int32', 'int64'],
'_c_identity')
dst_block.append_op(
type='c_identity',
inputs={'X': [X_var]},
outputs={'Out': intermediate_var_0},
attrs={
'ring_id': group.id,
'use_calc_stream': True,
'use_model_parallel': True,
})
check_variable_and_dtype(intermediate_var_0, 'x',
['float16', 'float32', 'float64'],
'linear')
check_dtype(intermediate_var_0.dtype, 'dtype',
['float16', 'float32', 'float64'], 'linear')
attrs = {
'transpose_X': False,
'transpose_Y': False,
'alpha': 1,
}
inputs = {'X': [intermediate_var_0], 'Y': [Weight_var]}
dst_block.append_op(
type='matmul',
inputs=inputs,
outputs={'Out': Out_var},
attrs=attrs)
if in_dygraph_mode():
raise NotImplementedError(
"Dist op for [{}] with idx [{}] is NOT implemented yet.".format(
"matmul", 0))
else:
return static_handle
# RowParallel
class DistributedMatmulImpl1(DistributedOperatorImpl):
def __init__(self, name):
super(DistributedMatmulImpl1, self).__init__()
self._name = name
self._forward_implemented = True
self._backward_implemented = False
def is_process_mesh_compatible(self, op_dist_attr):
""" No restriction for now. """
return True
def is_input_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
x_name = op_desc.input('X')[0]
y_name = op_desc.input('Y')[0]
x_dims_mapping = op_dist_attr.get_input_dims_mapping(x_name)
y_dims_mapping = op_dist_attr.get_input_dims_mapping(y_name)
if is_dim_replicate(x_dims_mapping[-1]):
return False
if is_dim_replicate(y_dims_mapping[-2]) or is_dim_shard(y_dims_mapping[
-1]):
return False
# Other dimensions must be replicate except the batch dimension
for mapping in x_dims_mapping[1:-1]:
if is_dim_shard(mapping):
return False
return True
def is_output_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
out_name = op_desc.output('Out')[0]
out_dims_mapping = op_dist_attr.get_output_dims_mapping(out_name)
if is_dim_shard(out_dims_mapping[-1]):
return False
# Other dimensions must be replicate except the batch dimension
for mapping in out_dims_mapping[1:-1]:
if is_dim_shard(mapping):
return False
return True
def update_dims_mapping(self, op_dist_attr):
changed = False
dim_changed = _update_dims_mapping_for_matmul(op_dist_attr)
if dim_changed:
changed = True
return changed
def forward(self, serial_op):
def static_handle(dst_block,
src_op,
op_dist_attr,
input_name_mapping,
output_name_mapping,
rank_id=0):
assert len(
input_name_mapping
) == 2, "col_parallel_linear take 2 inputs variable but got {}".format(
input_name_mapping)
assert len(
output_name_mapping
) == 1, "col_parallel_linear take 2 inputs variable but got {}".format(
output_name_mapping)
assert len(
input_name_mapping['X']
) == 1, "col_parallel_linear input X take 1 variable but got {}".format(
input_name_mapping['X'])
assert len(
input_name_mapping['Y']
) == 1, "col_parallel_linear input Y take 1 variable but got {}".format(
input_name_mapping['Y'])
assert len(
output_name_mapping['Out']
) == 1, "col_parallel_linear input Out take 1 variable but got {}".format(
input_name_mapping['Out'])
X_var = dst_block.var(input_name_mapping['X'][0])
Weight_var = dst_block.var(input_name_mapping['Y'][0])
Out_var = dst_block.var(output_name_mapping['Out'][0])
# TODO infer logic comm presentation
model_parallel_axis, process_mesh = op_dist_attr.get_owner_context(
)._get_model_parallel_info()
group_ranks = _get_comm_group(process_mesh.process_group,
process_mesh.topology,
model_parallel_axis, rank_id)
group = new_process_group(group_ranks)
check_variable_and_dtype(
X_var, 'x', ['float16', 'float32', 'float64'], 'linear')
check_dtype(X_var.dtype, 'dtype',
['float16', 'float32', 'float64'], 'linear')
attrs = {
'transpose_X': False,
'transpose_Y': False,
'alpha': 1,
}
inputs = {'X': X_var, 'Y': Weight_var}
intermediate_var_0 = dst_block.create_var(
shape=Out_var.shape,
dtype=Out_var.dtype,
type=Out_var.type,
lod_level=Out_var.lod_level,
persistable=False,
is_data=False,
need_check_feed=Out_var.desc.need_check_feed())
dst_block.append_op(
type='matmul',
inputs=inputs,
outputs={'Out': intermediate_var_0},
attrs=attrs)
dst_block.append_op(
type='c_allreduce_sum',
inputs={'X': intermediate_var_0},
outputs={'Out': Out_var},
attrs={
'ring_id': group.id,
'use_calc_stream': True,
'use_model_parallel': True
})
if in_dygraph_mode():
raise NotImplementedError(
"Dist op for [{}] with idx [{}] is NOT implemented yet.".format(
"matmul", 0))
else:
return static_handle
# ReplicateParallel
class DistributedMatmulImpl2(DistributedOperatorImpl):
def __init__(self, name):
super(DistributedMatmulImpl2, self).__init__()
self._name = name
def is_process_mesh_compatible(self, op_dist_attr):
""" No restriction for now. """
return True
def is_input_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
x_name = op_desc.input('X')[0]
y_name = op_desc.input('Y')[0]
x_dims_mapping = op_dist_attr.get_input_dims_mapping(x_name)
y_dims_mapping = op_dist_attr.get_input_dims_mapping(y_name)
if is_dim_shard(x_dims_mapping[-1]):
return False
if is_valid_list_index(x_dims_mapping,
-2) and is_dim_shard(x_dims_mapping[-2]):
return False
if is_dim_shard(y_dims_mapping[-1]):
return False
if is_valid_list_index(y_dims_mapping,
-2) and is_dim_shard(y_dims_mapping[-2]):
return False
return True
def is_output_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
out_name = op_desc.output('Out')[0]
out_dims_mapping = op_dist_attr.get_output_dims_mapping(out_name)
if is_dim_shard(out_dims_mapping[-1]):
return False
if is_valid_list_index(out_dims_mapping,
-2) and is_dim_shard(out_dims_mapping[-2]):
return False
return True
def update_dims_mapping(self, op_dist_attr):
changed = False
dim_changed = _update_dims_mapping_for_matmul(op_dist_attr)
if dim_changed:
changed = True
return changed
register_distributed_operator_impl("matmul",
DistributedMatmulImpl0("column_parallel"))
register_distributed_operator_impl("matmul",
DistributedMatmulImpl1("row_parallel"))
register_distributed_operator_impl("matmul",
DistributedMatmulImpl2("replicate_parallel"))
class DistributedMatmulV2(DistributedOperator):
def __init__(self, name):
super(DistributedMatmulV2, self).__init__()
self._name = name
register_distributed_operator("matmul_v2", DistributedMatmulV2("matmul_v2"))
# ColumnParallel
class DistributedMatmulV2Impl0(DistributedOperatorImpl):
def __init__(self, name):
super(DistributedMatmulV2Impl0, self).__init__()
self._name = name
self._forward_implemented = True
self._backward_implemented = False
def is_process_mesh_compatible(self, op_dist_attr):
""" No restriction for now. """
return True
def is_input_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
x_name = op_desc.input('X')[0]
y_name = op_desc.input('Y')[0]
x_dims_mapping = op_dist_attr.get_input_dims_mapping(x_name)
y_dims_mapping = op_dist_attr.get_input_dims_mapping(y_name)
if is_dim_shard(x_dims_mapping[-1]):
return False
if is_dim_shard(y_dims_mapping[0]) or is_dim_replicate(y_dims_mapping[
1]):
return False
for mapping in x_dims_mapping[1:-1]:
if is_dim_shard(mapping):
return False
return True
def is_output_compatible(self, op_dist_attr):
op_desc = op_dist_attr.get_owner_op().desc
out_name = op_desc.output('Out')[0]
out_dims_mapping = op_dist_attr.get_output_dims_mapping(out_name)
if | |
<gh_stars>10-100
# -*- coding: utf-8 -*-
"""
Created on Thu Nov 10 20:21:46 2015
@author: derrick
"""
from __future__ import print_function, absolute_import, unicode_literals, division
import glob
import itertools
import json
import os
import random
import numpy as np
import obspy
import pandas as pd
from six import string_types
import detex
# client imports
import obspy.clients.fdsn
import obspy.clients.neic
import obspy.clients.earthworm
conDirDefault = 'ContinuousWaveForms'
eveDirDefault = 'EventWaveForms'
# extension key to map obspy output type to extension. Add more here
formatKey = {'mseed': 'msd', 'pickle': 'pkl', 'sac': 'sac', 'Q': 'Q'}
def read(path):
"""
function to read a file from a path. If IOError or TypeError simply try
appending os.set to start
"""
try:
st = obspy.read(path)
except (IOError, TypeError):
try:
st = obspy.read(os.path.join(os.path.sep, path))
except (IOError, TypeError):
msg = 'Cannot read %s, the file may be corrupt, skipping it' % path
detex.log(__name__, msg, level='warn', pri=True)
return None
return st
def quickFetch(fetch_arg, **kwargs):
"""
Instantiate a DataFetcher using as little information as possible.
Parameters
----------
fetch_arg : str or DataFetcher instance
fetch_arg can be one of three things:
1. An instance of DataFetcher
2. A valid DataFetcher Method other than dir
3. A path to a directory containing waveform data
fetch_arg is checked in that order, so if you are trying to use a
data directory make sure it does not share names with a valid
DataFetcher method
kwargs are passed to the DataFetcher class, see DataFetcher
docs for details
Returns
-------
An instance of DataFetcher
Notes
--------
For client methods (eg 'uuss', 'iris') remove response is assumed True
with the default prelim. filter. If you don't want this make a custom
instance of DataFetcher.
"""
if isinstance(fetch_arg, DataFetcher):
dat_fet = fetch_arg
elif isinstance(fetch_arg, string_types):
if fetch_arg in DataFetcher.supMethods:
if fetch_arg == 'dir':
msg = 'If using method dir you must pass a path to directory'
detex.log(__name__, msg, level='error')
dat_fet = DataFetcher(fetch_arg, removeResponse=True, **kwargs)
else:
if not os.path.exists(fetch_arg):
msg = 'Directory %s does not exist' % fetch_arg
detex.log(__name__, msg, level='error')
dat_fet = DataFetcher('dir', directoryName=fetch_arg, **kwargs)
else:
msg = 'Input not understood, read docs and try again'
detex.log(__name__, msg, level='error')
return dat_fet
def makeDataDirectories(templateKey='TemplateKey.csv',
stationKey='StationKey.csv',
fetch='IRIS',
formatOut='mseed',
templateDir=eveDirDefault,
timeBeforeOrigin=1 * 60,
timeAfterOrigin=4 * 60,
conDir=conDirDefault,
secBuf=120,
conDatDuration=3600,
multiPro=False,
getContinuous=True,
getTemplates=True,
removeResponse=True,
opType='VEL',
prefilt=[.05, .1, 15, 20]):
"""
Function designed to fetch data needed for detex and store them in local
directories. StationKey.csv and TemplateKey.csv indicate which events to
download and for which stations. Organizes ContinuousWaveForms and
EventWaveForms directories.
Parameters
------------
template_key : str or pd DataFrame
The path to the TemplateKey csv
station_key : str or pd DataFrame
The path to the station key
fetch : str or FetchData instance
String for method argument of FetchData class or FetchData instance
formatOut : str
Seismic data file format, most obspy formats acceptable, options are:
'mseed','sac','GSE2','sacxy','q','sh_asc',' slist', 'tspair','segy',
'su', 'pickle', 'h5' (h5 only if obspyh5 module installed)
tempalateDir : str
The name of the template directory. Using the default is recommended
else the templateDir parameter will have to be set in calling most
other detex functions
timeBeforeOrigin: real number
The time in seconds before the reported origin of each template that
is downloaded.
timeAfterOrigin : real number(int, float, etc.)
The time in seconds to download after the origin time of each template.
conDir : str
The name of the continuous waveform directory. Using the default is
recommended
secBuf : real number (int, float, etc.)
The number of seconds to download after each hour of continuous data.
This might be non-zero in order to capture some detections that would
normally be overlooked if data did not overlap somewhat.
conDatDuration : real number (int, float, etc.)
The duration of the continuous data to download in seconds.
multiPro : bool
If True fork several processes to get data at once, potentially much
faster but a bit inconsiderate on the server hosting the data
getContinuous : bool
If True fetch continuous data with station and date ranges listed in
the station key
getTemplates : bool
If True get template data with stations listed in the station key
and events listed in the template key
removeResponse : bool
If true remove instrument response
opType : str
Output type after removing instrument response. Choices are:
"DISP" (m), "VEL" (m/s), or "ACC" (m/s**2)
prefilt : list 4 real numbers
Pre-filter parameters for removing instrument response, response is
flat from corners 2 to 3.
"""
temkey = detex.util.readKey(templateKey, 'template')
stakey = detex.util.readKey(stationKey, 'station')
# Check output type
if formatOut not in formatKey.keys():
msg = ('%s is not an acceptable format, choices are %s' %
(formatOut, formatKey.keys()))
detex.log(__name__, msg, level='error')
# Configure data fetcher
if isinstance(fetch, detex.getdata.DataFetcher):
fetcher = fetch
# Make sure DataFetcher is on same page as function inputs
fetcher.opType = opType
fetcher.removeResponse = removeResponse
fetcher.prefilt = prefilt
else:
fetcher = detex.getdata.DataFetcher(fetch,
removeResponse=removeResponse,
opType=opType,
prefilt=prefilt)
## Get templates
if getTemplates:
msg = 'Getting template waveforms'
detex.log(__name__, msg, level='info', pri=True)
_getTemData(temkey, stakey, templateDir, formatOut,
fetcher, timeBeforeOrigin, timeAfterOrigin)
## Get continuous data
if getContinuous:
msg = 'Getting continuous data'
detex.log(__name__, msg, level='info', pri=True)
_getConData(fetcher, stakey, conDir, secBuf, opType, formatOut,
duration=conDatDuration)
## Log finish
msg = "finished makeDataDirectories call"
detex.log(__name__, msg, level='info', close=True, pri=True)
def _getTemData(temkey, stakey, temDir, formatOut, fetcher, tb4, taft):
streamGenerator = fetcher.getTemData(temkey, stakey, tb4, taft,
returnName=True, temDir=temDir,
skipIfExists=True)
for st, name in streamGenerator:
netsta = st[0].stats.network + '.' + st[0].stats.station
fname = netsta + '.' + name + '.' + formatKey[formatOut]
fdir = os.path.join(temDir, name)
if not os.path.exists(fdir):
os.makedirs(fdir)
st.write(os.path.join(fdir, fname), formatOut)
if not os.path.exists(os.path.join(temDir, '.index.db')):
indexDirectory(temDir)
def _getConData(fetcher, stakey, conDir, secBuf, opType, formatOut,
duration=3600):
streamGenerator = fetcher.getConData(stakey,
secBuf,
returnName=True,
conDir=conDir,
skipIfExists=True,
duration=duration)
for st, path, fname in streamGenerator:
if st is not None: # if data were returned
if not os.path.exists(path):
os.makedirs(path)
fname = fname + '.' + formatKey[formatOut]
st.write(os.path.join(path, fname), formatOut)
if not os.path.exists(os.path.join(conDir, '.index.db')):
indexDirectory(conDir)
class DataFetcher(object):
"""
\n
Class to handle data acquisition
Parameters
----------
method : str or int
One of the approved methods for getting data as supported by detex
Options are:
"dir" : A data directory as created by makeDataDirectories
"client" : an obspy client can be passed to get data
useful if using an in-network database
"iris" : an iris client is initiated, also uses IRIS for inventory
"uuss" : A client attached to the university of utah
seismograph stations is initiated using CWB for waveforms
and IRIS is used for station inventories
client : An obspy client object
Client object used to get data, from obspy.clients
removeResponse : bool
If True remove response before returning stream.
inventoryArg : None, obspy client object, or obspy Inventory object
A seperate client for station inventories, only used if
removeResponse == True, also supports keyword "iris" for iris client
directoryName : str
A path to the continuous waveforms directory or event waveforms
directory. If None is passed default names are used
(ContinuousWaveForms and EventWaveForms)
opType : str
Output type after removing instrument response. Choices are:
"DISP" (m), "VEL" (m/s), or "ACC" (m/s**2)
prefilt : list of real numbers
Pre-filter parameters for removing instrument response.
conDatDuration : int or float
Duration for continuous data in seconds
conBuff : int or float
The amount of data, in seconds, to download at the end of the
conDatDuration. Ideally should be equal to template length, important
in order to avoid missing potential events at the end of a stream
timeBeforeOrigin : int or float
Seconds before origin of each event to fetch (used in getTemData)
timeAfterOrigin : int or float
Seconds after origin of each event to fetch (used in getTemData)
checkData : bool
If True apply some data checks before returning streams, can be useful
for older data sets.
fillZeros : bool
If True fill data that are not available with 0s (provided some data are
available)
"""
supMethods | |
<reponame>yawatajunk/Wi-Sun_EnergyMeter<filename>sem_com.py
#!/usr/bin/python3
# coding: UTF-8
import argparse
import binascii
import datetime
import glob
import json
import threading
import time
import os
import pickle
import socket
import sys
import RPi.GPIO as gpio
from y3module import Y3Module
from echonet_lite import *
import user_conf
# 定数定義
Y3RESET_GPIO = 18 # Wi-SUNリセット用GPIO
LED_GPIO = 4 # LED用GPIO
# ログファイル関連
TMP_LOG_DIR = '/tmp/' # 一次ログディレクトリ
LOG_DIR = 'sem_app/public/logs/' # ログ用ディレクトリ, 本スクリプトからの相対パス
SOCK_FILE = TMP_LOG_DIR + 'sem.sock' # UNIXソケット
TMP_LOG_FILE = TMP_LOG_DIR + 'sem.csv' # 一時ログファイル
POW_DAYS_JSON_FILE = LOG_DIR + 'pow_days.json' # JSON形式の電力ログファイル
POW_DAY_LOG_HEAD = 'pow_day_' # 日別ログファイル名の先頭
POW_DAY_LOG_FMT = '%Y%m%d' # 日時フォーマット
CURR_POW_FILE = TMP_LOG_DIR + 'curr_pow.txt'
# 低圧スマート電力量計 情報保存用リスト
sem_info = {}
def gpio_init():
"""GPIO初期化"""
gpio.setwarnings(False)
gpio.setmode(gpio.BCM)
gpio.setup(Y3RESET_GPIO, gpio.OUT)
gpio.setup(LED_GPIO, gpio.OUT)
gpio.output(Y3RESET_GPIO, gpio.HIGH)
time.sleep(0.1)
gpio.output(LED_GPIO, gpio.LOW)
class LedThread(threading.Thread):
"""LEDを点滅させるスレッド"""
def __init__(self):
super().__init__()
self._trigger = False
self._termFlag = False
def run(self):
while not self._termFlag:
if self._trigger:
self.ledon(True)
time.sleep(0.3)
self.ledon(False)
self._trigger = False
else:
time.sleep(0.1)
@staticmethod
def ledon(ctl):
if ctl:
gpio.output(LED_GPIO, gpio.HIGH)
else:
gpio.output(LED_GPIO, gpio.LOW)
def oneshot(self):
self._trigger = True
def terminate(self):
self._termFlag = True
self.join()
def y3reset():
"""Wi-Sunモジュールのリセット"""
gpio.output(Y3RESET_GPIO, gpio.LOW) # high -> low -> high
time.sleep(0.5)
gpio.output(Y3RESET_GPIO, gpio.HIGH)
time.sleep(2.0)
class Y3ModuleSub(Y3Module):
"""Y3Module()のサブクラス"""
global sem_inf_list
def __init__(self):
super().__init__()
self.EHD = '1081'
self.ECV_INF = '73' # ECHONET ECVコード （INF)
# UART受信スレッドrun()をECHONET Lite電文用に拡張
# UART受信用スレッド
def run(self):
while not self.term_flag:
msg = self.read()
if msg:
msg_list = self.parse_message(msg)
# debug: UDP(PANA)の受信
if msg_list['COMMAND'] == 'ERXUDP' and msg_list['LPORT'] == self.Y3_UDP_PANA_PORT:
sys.stdout.write('[PANA]: {}\n'.format(msg_list['DATA']))
# スマートメーターが自発的に発するプロパティ通知
if msg_list['COMMAND'] == 'ERXUDP' and msg_list['DATA'][0:4] == self.EHD \
and msg_list['DATA'][20:22] == self.ECV_INF:
sem_inf_list.append(msg_list)
elif self.search['search_words']: # サーチ中である
# サーチワードを受信した。
search_words = self.search['search_words'][0]
if isinstance(search_words, list):
for word in search_words:
if msg_list['COMMAND'].startswith(word):
self.search['found_word_list'].append(msg_list)
self.search['search_words'].pop(0)
break
elif msg_list['COMMAND'].startswith(search_words):
self.search['found_word_list'].append(msg_list)
self.search['search_words'].pop(0)
elif self.search['ignore_intermidiate']:
pass # 途中の受信データを破棄
else: # サーチワードではなかった
self.enqueue_message(msg_list)
else: # サーチ中ではない
self.enqueue_message(msg_list)
elif self.search['timeout']: # read()がタイムアウト，write()でタイムアウトが設定されている
if time.time() - self.search['start_time'] > self.search['timeout']:
self.search['found_word_list'] = []
self.search['search_words'] = []
self.search['timeout'] = 0
def sem_get(epc):
"""プロパティ値要求 'Get' """
global tid_counter
frame = sem.GET_FRAME_DICT['get_' + epc]
tid_counter = tid_counter + 1 if tid_counter + 1 != 65536 else 0 # TICカウントアップ
frame = sem.change_tid_frame(tid_counter, frame)
res = y3.udp_send(1, ip6, True, y3.Y3_UDP_ECHONET_PORT, frame)
def sem_get_getres(epc):
"""プロパティ値要求 'Get', 'GetRes'受信
epc: EHONET Liteプロパティ
"""
sem_get(epc) # 'Get'送信
start = time.time()
while True:
if y3.get_queue_size(): # データ受信
msg_list = y3.dequeue_message() # 受信データ取り出し
if msg_list['COMMAND'] == 'ERXUDP':
parsed_data = sem.parse_frame(msg_list['DATA'])
if parsed_data:
if parsed_data['tid'] != tid_counter:
errmsg = '[Error]: ECHONET Lite TID mismatch\n'
sys.stdout.write(errmsg)
return False
else:
return msg_list['DATA']
else:
sys.stdout.write('[Error]: ECHONET Lite frame error.\n')
return False
else:
sys.stdout.write('[Error]: Unknown data received.\n')
return False
else: # データ未受信
if time.time() - start > 20: # タイムアウト 20s
sys.stdout.write('[Error]: Time out.\n')
return False
time.sleep(0.01)
def sem_seti(epc, edt):
"""プロパティ値書き込み要求（応答要） 'SetI'
---------------------------------
(注)未検証 (注)未検証 (注)未検証
---------------------------------
epc: Echonet Liteプロパティ(bytes)
edt: Echonet Liteプロパティ値データ(bytes)
return: True(成功) / False(失敗)"""
global tid_counter
tid_counter = tid_counter + 1 if tid_counter + 1 != 65536 else 0 # TICカウントアップ
ptys = [[epc, edt]]
frame = sem.make_frame(tid_counter, sem.ESV_CODE['setc'], ptys)
res = y3.udp_send(1, ip6, True, y3.Y3_UDP_ECHONET_PORT, frame)
start = time.time()
while True:
if y3.get_queue_size(): # データ受信
msg_list = y3.dequeue_message() # 受信データ取り出し
if msg_list['COMMAND'] == 'ERXUDP':
parsed_data = sem.parse_frame(msg_list['DATA'])
if parsed_data:
if parsed_data['tid'] != tid_counter:
errmsg = '[Error]: ECHONET Lite TID mismatch\n'
sys.stdout.write(errmsg)
return False
else:
return msg_list['DATA']
else:
sys.stdout.write('[Error]: ECHONET Lite frame error.\n')
return False
else:
sys.stdout.write('[Error]: Unknown data received.\n')
return False
else: # データ未受信
if time.time() - start > 20: # タイムアウト 20s
sys.stdout.write('[Error]: Time out.\n')
return False
time.sleep(0.01)
def pow_logfile_init(dt):
"""電力ログファイル初期設定"""
f = open(TMP_LOG_FILE , 'w') # 一時ログ初期化
f.close()
if not (os.path.isdir(LOG_DIR) and os.access(LOG_DIR, os.W_OK)): # ログ用ディレクトリ確認
return False
csv_day_files = [] # 10日分のログファイルリスト(CSV)
pkl_day_files = [] # (pickle)
for i in range(10): # 10日分の電力ログ作成
t = dt - datetime.timedelta(days = i) # 対象日のdatetime
# ログファイル名
dt_str = t.strftime(POW_DAY_LOG_FMT)
csv_filename = LOG_DIR + POW_DAY_LOG_HEAD + dt_str + '.csv'
pkl_filename = TMP_LOG_DIR + POW_DAY_LOG_HEAD + dt_str + '.pickle'
csv_day_files.append(csv_filename)
pkl_day_files.append(pkl_filename)
if not os.path.exists(csv_filename): # 電力ログ(CSV)が無かったら作成する
try:
fcsv = open(csv_filename, 'w')
fcsv.close()
except:
return False
if not os.path.exists(pkl_filename): # 電力ログ(pickle)が無かったら作成する
result = csv2pickle(csv_filename, pkl_filename, t)
if not result:
return False
files = glob.glob(LOG_DIR + POW_DAY_LOG_HEAD + '*.csv') # 電力ログ(CSV)検索
for f in files:
if f in csv_day_files:
continue
else:
os.remove(f) # 古い電力ログ(CSV)を削除
files = glob.glob(TMP_LOG_DIR + POW_DAY_LOG_HEAD + '*.pickle') # 電力ログ(pickle)検索
for f in files:
if f in pkl_day_files:
continue
else:
os.remove(f) # 古い電力ログ(pickle)を削除
# CSVファイルをJSONファイルに変換
pickle2json(sorted(pkl_day_files), POW_DAYS_JSON_FILE)
return True
def pow_logfile_maintainance(last_dt, new_dt):
"""電力ログファイル更新"""
if last_dt.minute != new_dt.minute and new_dt.minute % 10 == 0: # 10分毎
dt_str = last_dt.strftime(POW_DAY_LOG_FMT)
today_csv_file = LOG_DIR + POW_DAY_LOG_HEAD + dt_str + '.csv'
today_pkl_file = TMP_LOG_DIR + POW_DAY_LOG_HEAD + dt_str + '.pickle'
file_cat(today_csv_file, TMP_LOG_FILE)
os.remove(TMP_LOG_FILE) # 一時ログファイルを削除
csv2pickle(today_csv_file, today_pkl_file, last_dt) # pickle更新
if last_dt.day != new_dt.day: # 日付変更
pow_logfile_init(new_dt) # 電力ログ初期化
else:
pkl_day_files = glob.glob(TMP_LOG_DIR + POW_DAY_LOG_HEAD + '*.pickle') # 電力ログ(pickle)検索
pickle2json(sorted(pkl_day_files), POW_DAYS_JSON_FILE) # CSVファイルをJSONファイルに変換
def file_cat(file_a, file_b):
"""ファイルを連結する"""
try:
fp_a = open(file_a, 'ab')
fp_b = open(file_b, 'rb')
fp_a.write(fp_b.read())
fp_a.close()
fp_b.close()
return True
except:
return False
def csv2pickle(csvfile, pklfile, dt):
"""csvファイルをpickleファイルに変換"""
try:
fcsv = open(csvfile, 'r')
fpkl = open(pklfile, 'wb')
data = fcsv.readlines()
except:
return False
if data == []: # 新規作成のよりcsvファイルが空の場合
# 引数dt(datetime型)から、0時0分のタイムスタンプを作成
ts_origin = datetime.datetime.combine(dt, datetime.time(0, 0)).timestamp()
else:
ts = int(data[0].strip().split(',')[0]) # ログからタイムスタンプを取得
dt = datetime.datetime.fromtimestamp(ts) # 0時0分のタイムスタンプを作成
ts_origin = datetime.datetime(dt.year, dt.month, dt.day).timestamp()
data_work = [[None, []] for row in range(60 * 24)] # 作業用空箱
for minute in range(60 * 24):
data_work[minute][0] = ts_origin + 60 * minute # 1分刻みのタイムスタンプを設定
for row in data:
row_list = row.strip().split(',') # [タイムスタンプ(s), 電力]
if row_list[1] != 'None':
minute = int((int(row_list[0]) - ts_origin) / 60) # 00:00からの経過時間[分]
if minute > 0 and minute < 60 * 24:
data_work[minute][1].append(int(row_list[1])) # 電力を追加
data_summary = [[None, None] for row in range(60 * 24)] # 集計用空箱
for minute, data in enumerate(data_work):
data_summary[minute][0] = data[0]
if len(data[1]):
data_summary[minute][1] = round(sum(data[1]) / len(data[1])) # 電力平均値
pickle.dump(data_summary, fpkl)
fcsv.close()
fpkl.close()
return True
def pickle2json(pklfiles, jsonfile):
"""pickleファイルをJSONファイルに変換する"""
data = []
for fpkl in pklfiles:
try:
f = open(fpkl, 'rb')
d = pickle.load(f)
data = data + d
except:
return False
json_data = []
for row in data:
row = [int(row[0])*1000, None if row[1] is None else int(row[1])]
json_data.append(row)
s = json.dumps(json_data)
try:
f = open(jsonfile, 'w')
f.write(s)
f.close()
return True
except:
return False
# コマンドライン引数
def arg_parse():
p = argparse.ArgumentParser()
p.add_argument('-d', '--delay', help='This script starts after a delay of [n] seconds.', default=0, type=int)
args = p.parse_args()
return args
if __name__ == '__main__':
args = arg_parse()
if args.delay: # スクリプトをスタートするまでの待ち時間。sem_appとの連携時にsem_com.pyのスタートを遅らせる。
if isinstance(args.delay, int):
ws = args.delay
sys.stdout.write('Waiting for {} seconds...\n'.format(ws))
time.sleep(ws)
os.chdir(os.path.dirname(os.path.abspath(__file__)))
sem_inf_list = [] # スマートメータのプロパティ通知用
tid_counter = 0 # TIDカウンタ
pana_ts = 0.0 # PANA認証時のタイムスタンプを記録
saved_dt = datetime.datetime.now() # 現在日時を保存
sys.stdout.write('Log files setup...\n')
result = pow_logfile_init(saved_dt) # ログファイル初期化
if not result:
sys.stdout.write('[Error]: Log file error\n')
sys.exit(-1)
gpio_init()
led = LedThread()
led.start()
led.oneshot()
y3 = Y3ModuleSub()
y3.uart_open(dev='/dev/ttyAMA0', baud=115200, timeout=1)
y3.start()
sys.stdout.write('Wi-SUN reset...\n')
y3reset()
y3.set_echoback_off()
y3.set_opt(True)
y3.set_password(user_conf.SEM_PASSWORD)
y3.set_routeb_id(user_conf.SEM_ROUTEB_ID)
sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
try:
sock.connect(SOCK_FILE)
except:
sock = None
channel_list = []
sem_exist = False
for i in range(10):
sys.stdout.write('({}/10) Active scan with a duration of {}...\n'.format(i+1, user_conf.SEM_DURATION))
channel_list = y3.active_scan(user_conf.SEM_DURATION)
if channel_list is False: # active_scan()をCtrl+cで終了したとき
break
if channel_list:
sem_exist = True
break
if not sem_exist: # スキャン失敗
sys.stdout.write('[Error]: Can not connect to a smart energy meter\n')
if sem_exist:
ch = channel_list[0]
sys.stdout.write('Energy Meter: [Ch.0x{:02X}, Addr.{}, LQI.{}, PAN.0x{:04X}]\n'.format(ch['Channel'],
ch['Addr'], ch['LQI'], ch['Pan ID']))
# チャンネル設定
y3.set_channel(ch['Channel'])
sys.stdout.write('Set channel to 0x{:02X}\n'.format(ch['Channel']))
# スマートメータのIP6アドレス
ip6 = y3.get_ip6(ch['Addr'])
sys.stdout.write('IP6 address is \'{}\'\n'.format(ip6))
# PAN ID
y3.set_pan_id(ch['Pan ID'])
sys.stdout.write('Set PAN ID to 0x{:04X}\n'.format(ch['Pan ID']))
# PANA認証(PaC)
sem_exist = False
pana_done = False
for i in range(10):
sys.stdout.write('({}/10) PANA connection...\n'.format(i+1))
sem_exist = y3.start_pac(ip6)
if sem_exist: # インスタンスリスト通知の受信待ち
st = time.time()
while True:
if sem_inf_list:
pana_ts = time.time() # タイムスタンプを保存
sys.stdout.write('Successfully done.\n')
time.sleep(3)
pana_done = True
break
elif time.time() - st > 15: # PANA認証失敗によるタイムアウト
sys.stdout.write('Fail to connect.\n')
sem_exist = False
pana_done = False
break
else:
time.sleep(0.1)
if pana_done:
break
if sem_exist:
sem = EchonetLiteSmartEnergyMeter()
get_list = ['operation_status', 'location', 'version', 'fault_status',
'manufacturer_code', 'production_no',
'current_time', 'current_date', | |
<reponame>SimonasJocys/retina_net
"""
Copyright 2018 <NAME>
This file was derived from eval.py, implementing RSNA metric calculation.
Copyright 2017-2018 Fizyr (https://fizyr.com)
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from __future__ import print_function
from .anchors import compute_overlap
from .visualization import draw_detections, draw_annotations
import keras
import numpy as np
import os
import cv2
def _compute_ap(recall, precision):
""" Compute the average precision, given the recall and precision curves.
Code originally from https://github.com/rbgirshick/py-faster-rcnn.
# Arguments
recall: The recall curve (list).
precision: The precision curve (list).
# Returns
The average precision as computed in py-faster-rcnn.
"""
# correct AP calculation
# first append sentinel values at the end
mrec = np.concatenate(([0.], recall, [1.]))
mpre = np.concatenate(([0.], precision, [0.]))
# compute the precision envelope
for i in range(mpre.size - 1, 0, -1):
mpre[i - 1] = np.maximum(mpre[i - 1], mpre[i])
# to calculate area under PR curve, look for points
# where X axis (recall) changes value
i = np.where(mrec[1:] != mrec[:-1])[0]
# and sum (\Delta recall) * prec
ap = np.sum((mrec[i + 1] - mrec[i]) * mpre[i + 1])
return ap
# helper function to calculate IoU
def iou(box1, box2):
x11,y11,x12,y12=box1
x21,y21,x22,y22=box2
w1,h1=x12-x11,y12-y11
w2,h2=x22-x21,y22-y21
#x11, y11, w1, h1 = box1
#x21, y21, w2, h2 = box2
#assert w1 * h1 > 0
#assert w2 * h2 > 0
#x12, y12 = x11 + w1, y11 + h1
#x22, y22 = x21 + w2, y21 + h2
area1, area2 = w1 * h1, w2 * h2
xi1, yi1, xi2, yi2 = max([x11, x21]), max([y11, y21]), min([x12, x22]), min([y12, y22])
if xi2 <= xi1 or yi2 <= yi1:
return 0
else:
intersect = (xi2-xi1) * (yi2-yi1)
union = area1 + area2 - intersect
return intersect / union
def map_iou(boxes_true, boxes_pred, scores, thresholds = [0.4, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75]):
"""
Mean average precision at differnet intersection over union (IoU) threshold
input:
boxes_true: Mx4 numpy array of ground true bounding boxes of one image.
bbox format: (x1, y1, w, h)
boxes_pred: Nx4 numpy array of predicted bounding boxes of one image.
bbox format: (x1, y1, w, h)
scores: length N numpy array of scores associated with predicted bboxes
thresholds: IoU shresholds to evaluate mean average precision on
output:
map: mean average precision of the image
"""
# According to the introduction, images with no ground truth bboxes will not be
# included in the map score unless there is a false positive detection (?)
# return None if both are empty, don't count the image in final evaluation (?)
if len(boxes_true) == 0 and len(boxes_pred) == 0:
return None
assert boxes_true.shape[1] == 4 or boxes_pred.shape[1] == 4, "boxes should be 2D arrays with shape[1]=4"
if len(boxes_pred):
assert len(scores) == len(boxes_pred), "boxes_pred and scores should be same length"
# sort boxes_pred by scores in decreasing order
boxes_pred = boxes_pred[np.argsort(scores)[::-1], :]
map_total = 0
# loop over thresholds
for t in thresholds:
matched_bt = set()
tp, fn = 0, 0
for i, bt in enumerate(boxes_true):
matched = False
for j, bp in enumerate(boxes_pred):
miou = iou(bt, bp)
if miou >= t and not matched and j not in matched_bt:
matched = True
tp += 1 # bt is matched for the first time, count as TP
matched_bt.add(j)
if not matched:
fn += 1 # bt has no match, count as FN
fp = len(boxes_pred) - len(matched_bt) # FP is the bp that not matched to any bt
m = tp / (tp + fn + fp)
map_total += m
return map_total / len(thresholds)
def nmf(boxes, scores, overlapThresh):
# if there are no boxes, return an empty list
if len(boxes) == 0:
return []
if boxes.dtype.kind == "i":
boxes = boxes.astype("float")
pick = []
x1 = boxes[:,0]
y1 = boxes[:,1]
x2 = boxes[:,2]
y2 = boxes[:,3]
# compute the area of the bounding boxes and sort the bounding
# boxes by the bottom-right y-coordinate of the bounding box
area = (x2 - x1 + 1) * (y2 - y1 + 1)
idxs=np.argsort(scores)
#idxs = np.argsort(y2)
# keep looping while some indexes still remain in the indexes
# list
while len(idxs) > 0:
# grab the last index in the indexes list and add the
# index value to the list of picked indexes
last = len(idxs) - 1
i = idxs[last]
pick.append(i)
# find the largest (x, y) coordinates for the start of
# the bounding box and the smallest (x, y) coordinates
# for the end of the bounding box
xx1 = np.maximum(x1[i], x1[idxs[:last]])
yy1 = np.maximum(y1[i], y1[idxs[:last]])
xx2 = np.minimum(x2[i], x2[idxs[:last]])
yy2 = np.minimum(y2[i], y2[idxs[:last]])
# compute the width and height of the bounding box
w = np.maximum(0, xx2 - xx1 + 1)
h = np.maximum(0, yy2 - yy1 + 1)
# compute the ratio of overlap
overlap = (w * h) / area[idxs[:last]]
# delete all indexes from the index list that have
idxs = np.delete(idxs, np.concatenate(([last],
np.where(overlap > overlapThresh)[0])))
# return only the bounding boxes that were picked using the
# integer data type
return pick #boxes[pick].astype("int")
def _get_detections(generator, model, score_threshold=0.05, max_detections=100, save_path=None):
""" Get the detections from the model using the generator.
The result is a list of lists such that the size is:
all_detections[num_images][num_classes] = detections[num_detections, 4 + num_classes]
# Arguments
generator : The generator used to run images through the model.
model : The model to run on the images.
score_threshold : The score confidence threshold to use.
max_detections : The maximum number of detections to use per image.
save_path : The path to save the images with visualized detections to.
# Returns
A list of lists containing the detections for each image in the generator.
"""
all_detections = []
for i in range(generator.size()):
raw_image = generator.load_image(i)
image = generator.preprocess_image(raw_image.copy())
image, scale = generator.resize_image(image)
if keras.backend.image_data_format() == 'channels_first':
image = image.transpose((2, 0, 1))
# run network
boxes, scores, labels = model.predict_on_batch(np.expand_dims(image, axis=0))[:3]
# correct boxes for image scale
boxes /= scale
# select indices which have a score above the threshold
indices = np.where(scores[0, :] > score_threshold)[0]
# select those scores
scores = scores[0][indices]
# find the order with which to sort the scores
scores_sort = np.argsort(-scores)[:max_detections]
# select detections
image_boxes = boxes[0, indices[scores_sort], :]
image_scores = scores[scores_sort]
all_detections.append([image_boxes, image_scores])
print('{}/{}'.format(i + 1, generator.size()), end='\r')
return all_detections
def _get_annotations(generator):
""" Get the ground truth annotations from the generator.
The result is a list of lists such that the size is:
all_detections[num_images][num_classes] = annotations[num_detections, 5]
# Arguments
generator : The generator used to retrieve ground truth annotations.
# Returns
A list of lists containing the annotations for each image in the generator.
"""
all_annotations=[]
for i in range(generator.size()):
# load the annotations
annotation = generator.load_annotations(i)[:,:4]
all_annotations.append(annotation)
print('{}/{}'.format(i + 1, generator.size()), end='\r')
return all_annotations
def evaluate_rsna(generator, model):
detections = _get_detections(generator, model)
annotations = _get_annotations(generator)
max_youden=0
y_se=y_sp=0
y_rsna_score=0
y_thresh=0
nmf_threshold=0
for score_threshold in np.arange(0.05,0.31,0.01):
total_score=0
denominator=0
tp=tn=fp=fn=0
for i, detection in enumerate(detections):
boxes_true=annotations[i]
boxes_pred=detection[0]
scores=detection[1]
indices = np.where(scores > score_threshold)[0]
scores=scores[indices]
boxes_pred=boxes_pred[indices]
idx=nmf(boxes_pred,scores, nmf_threshold)
scores=scores[idx]
boxes_pred=boxes_pred[idx]
score=map_iou(boxes_true, boxes_pred, scores)
if score is not None:
total_score+=score
denominator+=1
if boxes_true.size:
if boxes_pred.size:
tp+=1
else:
fn+=1
else:
if boxes_pred.size:
fp+=1
else:
tn+=1
se=tp/(tp+fn)
sp=tn/(fp+tn)
youden=se+sp-1
rsna_score=total_score/denominator
if youden>max_youden:
max_youden=youden
y_rsna_score=rsna_score
y_se=se
y_sp=sp
y_thresh=score_threshold
# print(f'{score_threshold:.3f} {total_score/denominator:.5f} {se:.5f} {sp:.5f} {se+sp-1:.5f}')
return (y_thresh, y_rsna_score, y_se, y_sp, max_youden)
def evaluate(
generator,
model,
iou_threshold=0.5,
score_threshold=0.05,
max_detections=100,
save_path=None
):
""" Evaluate a given dataset using a given model.
# Arguments
generator : The generator that represents | |
import os
from nipype.interfaces.afni.base import (AFNICommandBase,
AFNICommandOutputSpec,
isdefined)
from nipype.utils.filemanip import split_filename as split_f
from nipype.interfaces.base import (CommandLine, CommandLineInputSpec,
TraitedSpec, traits, File)
def interative_flirt(anat_file, anat_file_BET, template_brain_file,
template_mask_file, n_iter):
"""
This funcion, from Regis script, aims at interatively building a better
skull stripped version of the subject's. There is a need for an already
computed skullstripped version to initiallized the procedure
(anat_file_BET)
The algo works this way:
1) flirt skullstripped template to skullstripped subject's brain
2) apply transfo on template's mask to have the mask in subject's space
3) mask orig anat with compute mask to obtained a new skullstripped
subject's brain. Use this new skullstripped subject's for the next
iteration.
"""
import os
import nipype.interfaces.fsl as fsl
from nipype.utils.filemanip import split_filename as split_f
path_t, fname_t, ext_t = split_f(template_brain_file)
template_to_anat_file = os.path.abspath(fname_t + "_to_anat.xfm")
path_a, fname_a, ext_a = split_f(anat_file)
anat_file_brain_mask = os.path.abspath(fname_a + "_brain_mask.nii.gz")
anat_file_brain = os.path.abspath(fname_a + "_brain.nii")
flirt_ref_file = anat_file_BET
for i in range(n_iter):
print('Iter flirt {}'.format(i))
# first step = FLIRT: template brain to anat bet
# -> transfo matrix (linear) between the two
flirt = fsl.FLIRT()
flirt.inputs.in_file = template_brain_file
flirt.inputs.reference = flirt_ref_file
flirt.inputs.out_matrix_file = template_to_anat_file
flirt.inputs.cost = "normcorr"
flirt.run()
# second step = apply transfo to template's mask
# -> brain_mask in subject's space
print('Iter apply_flirt {}'.format(i))
apply_flirt = fsl.ApplyXFM()
apply_flirt.inputs.in_file = template_mask_file
apply_flirt.inputs.reference = anat_file_BET
apply_flirt.inputs.in_matrix_file = template_to_anat_file
apply_flirt.inputs.apply_xfm = True
apply_flirt.inputs.interp = "nearestneighbour"
apply_flirt.inputs.out_file = anat_file_brain_mask
apply_flirt.run()
# third step = use the mask in subject's space to mask the build
# a skull-stripped version of the subject's brain
# -> better skullstripped version
print('Iter apply_mask {}'.format(i))
# apply_mask = fsl.ApplyMask() ### a voir si plus pertinent...
apply_mask = fsl.BinaryMaths()
apply_mask.inputs.in_file = anat_file
apply_mask.inputs.operation = 'mul'
apply_mask.inputs.operand_file = anat_file_brain_mask
apply_mask.inputs.out_file = anat_file_brain
apply_mask.inputs.output_type = "NIFTI"
apply_mask.run()
flirt_ref_file = anat_file_brain
return anat_file_brain, template_to_anat_file
# IterREGBET
class IterREGBETInputSpec(CommandLineInputSpec):
# mandatory
inw_file = File(
exists=True,
desc='Moving Whole-head image',
mandatory=True, position=0, argstr="-inw %s")
inb_file = File(
exists=True,
desc='Moving brain image',
mandatory=True, position=1, argstr="-inb %s")
refb_file = File(
exists=True,
desc='Fixed reference brain image',
mandatory=True, position=2, argstr="-refb %s")
# optional
xp = traits.String(
genfile=True,
desc="Prefix for the registration outputs (\"in_FLIRT-to_ref\" if not \
specified)",
position=3, argstr="-xp %s", mandatory=False)
bs = traits.String(
"_IRbrain", usedefault=True,
desc="Suffix for the brain files (\"in_IRbrain\" & \"in_IRbrain_mask\"\
if not specified)",
position=3, argstr="-bs %s", mandatory=False)
dof = traits.Enum(
12, 6, 7, desc='FLIRT degrees of freedom (6=rigid body, 7=scale, \
12=affine (default)). Use dof 6 for intra-subject, 12 for \
inter-subject registration',
argstr='-dof %d',
usedefault=True, mandatory=True)
cost = traits.Enum(
'normmi', 'leastsq', 'labeldiff', 'bbr', 'mutualinfo', 'corratio',
'normcorr',
desc='FLIRT cost {mutualinfo,corratio,normcorr,normmi,leastsq,\
labeldiff,bbr} (default is normmi)',
argstr='-cost %s',
usedefault=True, mandatory=False)
# how to assert minimal value in traits def? is now in _parse_args
n = traits.Int(
2, usedefault=True,
desc='n = the number of FLIRT iterations (>=2, default=2).',
argstr="-n %d", mandatory=False)
m = traits.Enum(
'ref', 'union', 'inter', 'mix',
desc='At each new iteration, either use:\
- the reference brain mask, m=ref (default)\
- the union of the reference and input brain masks, \
m=union (use if your input brain is too small)\
- the intersection of the reference and input brain masks, m=inter\
(use if your input brain is too big)\
- a mix between union & intersection, m=mix (give it a try!)',
argstr='-m %s',
usedefault=True, mandatory=False)
refw_file = File(
exists=True,
desc='Do a whole-head non-linear registration (using FNIRT) during\
last iteration (provide reference whole-head image)',
mandatory=False, argstr="-refw %s")
k = traits.Bool(
False, usedefault=True,
position=3, argstr="-k",
desc="Will keep temporary files",
mandatory=False)
p = traits.String(
desc="Prefix for running FSL functions\
(can be a path or just a prefix)",
position=3, argstr="-p %s")
class IterREGBETOutputSpec(TraitedSpec):
brain_file = File(
exists=True,
desc="brain from IterREGBET.sh")
brain_mask_file = File(
exists=True,
desc="masked brain from IterREGBET.sh")
warp_file = File(
exists=True,
desc="warped image from IterREGBET.sh")
transfo_file = File(
exists=True,
desc="transfo_file")
inv_transfo_file = File(
exists=True,
desc="inv_transfo_file")
class IterREGBET(CommandLine):
"""
Description: Iterative registration of the in-file to the ref file (
registered brain mask of the ref image is used at each iteration). To use
when the input brain mask is not optimal (eg. an output of FSL BET).
Will output a better brain mask of the in-file.
Inputs:
Mandatory:
inw_file
Moving Whole-head image
inb_file
Moving brain image
refb_file
Fixed reference brain image
Optional:
xp
Prefix for the registration outputs ("in_FLIRT-to_ref" if not
specified)
bs
Suffix for the brain files ("in_IRbrain" & "in_IRbrain_mask"
if not specified)
dof
FLIRT degrees of freedom (6=rigid body, 7=scale,
12=affine (default)). Use dof 6 for intra-subject, 12 for
inter-subject registration
cost
FLIRT cost {mutualinfo,corratio,normcorr,normmi,leastsq,\
labeldiff,bbr} (default is normmi)
n
n = the number of FLIRT iterations (>=2, default=2)
m
At each new iteration, either use:
- the reference brain mask, m=ref (default)
- the union of the reference and input brain masks, m=union \
(use if your input brain is too small)
- the intersection of the reference and input brain masks, \
m=inter (use if your input brain is too big)
- a mix between union & intersection, m=mix (give it a try!)
refw_file
Do a whole-head non-linear registration (using FNIRT) during
last iteration (provide reference whole-head image)
k
Will keep temporary files
p
Prefix for running FSL functions (can be a path or just a
prefix)
Outputs:
brain_file
brain from IterREGBET.sh
brain_mask_file
masked brain from IterREGBET.sh
warp_file
warped image from IterREGBET.sh
transfo_file
transfo_file
inv_transfo_file
inv_transfo_file
"""
input_spec = IterREGBETInputSpec
output_spec = IterREGBETOutputSpec
package_directory = os.path.dirname(os.path.abspath(__file__))
_cmd = 'bash {}/../bash/IterREGBET.sh'.format(package_directory)
def _gen_filename(self, name):
if name == "xp":
return self._gen_outfilename()
else:
return None
def _gen_outfilename(self):
from nipype.utils.filemanip import split_filename as split_f
_, in_brain, _ = split_f(self.inputs.inb_file)
_, ref, _ = split_f(self.inputs.refb_file)
if isdefined(self.inputs.xp):
outname = self.inputs.xp
else:
outname = in_brain + "_FLIRT-to_" + ref
return outname
def _list_outputs(self):
import os
from nipype.utils.filemanip import split_filename as split_f
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.inw_file)
outputs["brain_file"] = os.path.abspath(
fname + self.inputs.bs + ".nii.gz")
outputs["brain_mask_file"] = os.path.abspath(
fname + self.inputs.bs + "_mask.nii.gz")
if isdefined(self.inputs.xp):
outfile = self.inputs.xp
else:
outfile = self._gen_outfilename()
outputs["warp_file"] = os.path.abspath(outfile + ".nii.gz")
outputs["transfo_file"] = os.path.abspath(outfile + ".xfm")
outputs["inv_transfo_file"] = os.path.abspath(outfile + "_inverse.xfm")
return outputs
# NMTSubjectAlign
class NMTSubjectAlignInputSpec(CommandLineInputSpec):
T1_file = File(
exists=True,
desc='Target file',
mandatory=True, position=0, argstr="%s")
NMT_SS_file = File(
exists=True,
desc='Align to T1',
mandatory=True, position=1, argstr="%s")
class NMTSubjectAlignOutputSpec(TraitedSpec):
aff_file = File(
exists=True,
desc="shft_aff")
warp_file = File(
exists=True,
desc="shft_WARP.nii.gz")
warpinv_file = File(
exists=True,
desc="shft_WARPINV.nii.gz")
transfo_file = File(
exists=True,
desc="composite_linear_to_NMT.1D")
inv_transfo_file = File(
exists=True,
desc="_composite_linear_to_NMT_inv.1D")
class NMTSubjectAlign(CommandLine):
"""
Description: Align NMT subject to template (NMT 1.2)
Inputs:
Mandatory:
T1_file:
File, 'Target file'
NMT_SS_file:
File, 'Align to T1'
Outputs:
aff_file:
File, "aff"
warp_file:
File, "shft_WARP"
warpinv_file:
File, "shft_WARPINV"
transfo_file:
File, "composite_linear_to_NMT"
inv_transfo_file:
File, "_composite_linear_to_NMT_inv"
"""
input_spec = NMTSubjectAlignInputSpec
output_spec = NMTSubjectAlignOutputSpec
package_directory = os.path.dirname(os.path.abspath(__file__))
_cmd = 'tcsh -x {}/../bash/NMT_subject_align.csh'.format(package_directory)
def _list_outputs(self):
from nipype.utils.filemanip import split_filename as split_f
outputs = self._outputs().get()
path, fname, ext = split_f(self.inputs.T1_file)
outputs["aff_file"] = os.path.abspath(fname + "_shft_aff" + ext)
# TODO will require some checks
# outputs["warpinv_file"] = os.path.abspath(
# fname + "_shft_WARPINV.nii")
outputs["warpinv_file"] = os.path.abspath(
fname + "_shft_WARPINV.nii.gz")
outputs["warp_file"] = os.path.abspath(
fname + "_shft_WARP.nii.gz")
# outputs["warpinv_file"] = os.path.abspath(
# fname + "_shft_WARPINV" + ext)
outputs["transfo_file"] = os.path.abspath(
fname + "_composite_linear_to_NMT.1D")
outputs["inv_transfo_file"] = os.path.abspath(
fname + "_composite_linear_to_NMT_inv.1D")
return outputs
# NMTSubjectAlign2
class NMTSubjectAlign2InputSpec(CommandLineInputSpec):
T1_file = File(
exists=True,
desc='Target file',
mandatory=True, position=0, argstr="-i %s")
NMT_SS_file = File(
exists=True,
desc='Align to T1',
mandatory=True, position=1, argstr="-r %s")
afni_ext = traits.Enum(
"tlrc", "orig", exists=True, desc='Afni extension', mandatory=True,
position=2, usedefault=True, argstr="-e %s")
class NMTSubjectAlign2OutputSpec(TraitedSpec):
aff_file = File(
exists=True,
desc="affine (subject image linearly transformed to the NMT template)")
warp_file = File(
exists=True,
desc="WARP.nii.gz")
warpinv_file = File(
exists=True,
desc="WARPINV.nii.gz")
transfo_file = File(
exists=True,
desc="Combined Linear transform from subject to NMT)")
inv_transfo_file = File(
exists=True,
desc="Inverse Linear Transform from NMT to subject")
class NMTSubjectAlign2(CommandLine):
"""
Description: Align NMT subject to template (NMT 1.3)
Inputs:
Mandatory:
T1_file:
File, 'Target file'
NMT_SS_file:
File, 'Align to T1'
Outputs:
aff_file:
File, "subject image linearly transformed to the NMT template"
warp_file:
File, "shft_WARP"
warpinv_file:
File, "shft_WARPINV"
transfo_file:
File, "Combined Linear transform from subject to NMT"
inv_transfo_file:
File, "Inverse | |
expansion? Numeric integer.", default="OFF")
parser.add_option("--query", action="store", type="string", dest="query", help="Query collections of cells whose enrichment will be searched in target cells", default="OFF")
parser.add_option("--source", action="store", type="string", dest="source", help="File source for inputs...", default="OFF")
parser.add_option("--target", action="store", type="string", dest="target", help="Target collections of cells in which enrichment is searched for", default="OFF")
parser.add_option("--domain", action="store", type="string", dest="domain", help="Domain of co-associations for hybrid-type analyses", default="OFF")
parser.add_option("--A", action = "store", type = "string", dest = "a", help = "Paths to files of interest", default="OFF")
parser.add_option("--B", action = "store", type = "string", dest = "b", help = "Files to be hybridized", default="OFF")
parser.add_option("--indexes", action = "store", type = "string", dest = "indexes", help = "Indexes for matrix construction...", default="OFF")
parser.add_option("--values", action = "store", type = "string", dest = "values", help = "Values for matrix construction...", default="OFF")
parser.add_option("--contexts", action = "store", type = "string", dest = "contexts", help = "What contexts of development should I track?", default="OFF")
parser.add_option("--exclude", action="store", type="string", dest="exclude", help="Are there items that should be excluded?", default="")
parser.add_option("--start", action = "store", type = "int", dest = "start", help = "Start development time for cell search", default=1)
parser.add_option("--stop", action = "store", type = "int", dest = "stop", help = "End development time for cell search", default=250)
parser.add_option("--step", action = "store", type = "int", dest = "step", help = "Step size", default=1)
parser.add_option("--total", action = "store", type = "int", dest = "total", help = "Total simulations (indexes) for 'master' operations ", default=1000)
parser.add_option("--threads", action = "store", type = "int", dest = "threads", help = "Parallel processing threads", default=1)
parser.add_option("--chunks", action = "store", type = "int", dest = "chunks", help = "", default=100)
parser.add_option("--module", action = "store", type = "string", dest = "module", help = "", default="md1")
parser.add_option("--qsub", action = "store", type = "string", dest = "qsub", help = "Qsub configuration header", default="OFF")
parser.add_option("--server", action = "store", type = "string", dest = "server", help = "Are we on the server?", default="OFF")
parser.add_option("--job", action = "store", type = "string", dest = "job", help = "Job name for cluster", default="OFF")
parser.add_option("--copy", action = "store", type = "string", dest = "copy", help = "Copy simulated peaks to analysis folder?", default="OFF")
parser.add_option("--tag", action = "store", type = "string", dest = "tag", help = "Add tag to TFBS?", default="")
(option, args) = parser.parse_args()
# import paths:
if option.server == "OFF":
path_dict = modencode.configBuild(option.path + "/input/" + "configure_path.txt")
elif option.server == "ON":
path_dict = modencode.configBuild(option.path + "/input/" + "configure_server.txt")
# specify input and output paths:
inpath = path_dict["input"]
extraspath = path_dict["extras"]
pythonpath = path_dict["python"]
scriptspath = path_dict["scripts"]
downloadpath = path_dict["download"]
fastqpath = path_dict["fastq"]
bowtiepath = path_dict["bowtie"]
bwapath = path_dict["bwa"]
macspath = path_dict["macs"]
memepath = path_dict["meme"]
idrpath = path_dict["idr"]
igvpath = path_dict["igv"]
testpath = path_dict["test"]
processingpath = path_dict["processing"]
annotationspath = path_dict["annotations"]
peakspath = path_dict["peaks"]
gopath = path_dict["go"]
hotpath = path_dict["hot"]
qsubpath = path_dict["qsub"]
coassociationspath = path_dict["coassociations"]
bindingpath = path_dict["binding"]
neuronspath = path_dict["neurons"]
cellspath = path_dict["cells"]
# standardize paths for analysis:
alignerpath = bwapath
indexpath = alignerpath + "index/"
alignmentpath = alignerpath + "alignment/"
qcfilterpath = alignerpath + "qcfilter/"
qcmergepath = alignerpath + "qcmerge/"
# import configuration dictionaries:
source_dict = modencode.configBuild(inpath + "configure_source.txt")
method_dict = modencode.configBuild(inpath + "configure_method.txt")
context_dict = modencode.configBuild(inpath + "configure_context.txt")
# define organism parameters:
if option.organism == "hs" or option.organism == "h.sapiens":
organismTag = "hs"
#organismIGV = "ce6"
elif option.organism == "mm" or option.organism == "m.musculus":
organismTag = "mm"
#organismIGV = "ce6"
elif option.organism == "ce" or option.organism == "c.elegans":
organismTag = "ce"
#organismIGV = "ce6"
elif option.organism == "dm" or option.organism == "d.melanogaster":
organismTag = "dm"
#organismIGV = "dm5"
# specify genome size file:
if option.nuclear == "ON":
chromosomes = metrn.chromosomes[organismTag]["nuclear"]
genome_size_file = option.path + "/input/" + metrn.reference[organismTag]["nuclear_sizes"]
genome_size_dict = general.build_config(genome_size_file, mode="single", separator="\t", spaceReplace=True)
else:
chromosomes = metrn.chromosomes[organismTag]["complete"]
genome_size_file = option.path + "/input/" + metrn.reference[organismTag]["complete_sizes"]
genome_size_dict = general.build_config(genome_size_file, mode="single", separator="\t", spaceReplace=True)
# load gene ID dictionaries:
id2name_dict, name2id_dict = modencode.idBuild(inpath + metrn.reference[organismTag]["gene_ids"], "Sequence Name (Gene)", "Gene Public Name", mode="label", header=True, idUpper=True, nameUpper=True)
# update peaks path:
peakspath = peakspath + option.peaks + "/"
# define input/output folders:
expressionpath = cellspath + "expression/"
correctionpath = cellspath + "correction/"
lineagepath = cellspath + "lineage/"
bindingpath = cellspath + "peaks/"
overlappath = cellspath + "overlap/"
cellsetpath = cellspath + "cellset/"
genesetpath = cellspath + "geneset/"
reportspath = cellspath + "reports/"
comparepath = cellspath + "compare/"
matrixpath = cellspath + "matrix/"
tissuespath = cellspath + "tissues/"
distancepath = cellspath + "distance/"
hybridpath = cellspath + "hybrid/"
dynamicspath = cellspath + "dynamics/"
cubismpath = cellspath + "cubism/"
timepath = cellspath + "time/"
cellnotationspath = cellspath + "annotations/"
general.pathGenerator(expressionpath)
general.pathGenerator(correctionpath)
general.pathGenerator(lineagepath)
general.pathGenerator(bindingpath)
general.pathGenerator(overlappath)
general.pathGenerator(cellsetpath)
general.pathGenerator(genesetpath)
general.pathGenerator(reportspath)
general.pathGenerator(comparepath)
general.pathGenerator(matrixpath)
general.pathGenerator(tissuespath)
general.pathGenerator(distancepath)
general.pathGenerator(timepath)
general.pathGenerator(hybridpath)
general.pathGenerator(dynamicspath)
general.pathGenerator(cubismpath)
general.pathGenerator(cellnotationspath)
# generate expression flag:
if option.measure == "max.expression":
expression_flag = "maxCel_"
elif option.measure == "avg.expression":
expression_flag = "avgExp_"
# check that the index range is coherent:
if option.stop > option.total:
print
print "Error: Range exceeded! Stop index is larger than total."
print
return
# master mode:
if "master" in option.mode:
# capture master mode:
master, mode = option.mode.split(":")
# prepare for qsub:
bash_path = str(option.path + "/data/cells/runs/").replace("//","/")
bash_base = "_".join([mode, option.peaks, option.name]) + "-M"
qsub_base = "_".join([mode, option.peaks, option.name])
general.pathGenerator(bash_path)
if option.qsub != "OFF":
qsub_header = open(qsubpath + option.qsub).read()
qsub = True
else:
qsub_header = ""
qsub = False
if option.job == "QSUB":
qsub_header = qsub_header.replace("qsubRunner", "qsub-" + qsub_base)
elif option.job != "OFF":
qsub_header = qsub_header.replace("qsubRunner", "qsub-" + option.job)
bash_base = option.job + "-M"
# update server path:
if option.qsub != "OFF":
option.path = serverPath(option.path)
# prepare slave modules:
m, steps, modules, commands, sequences, chunks, start, complete = 1, 0, list(), list(), list(), option.chunks, option.start, False
for index in range(option.start, option.stop+1, option.step):
run = "rn" + general.indexTag(index, option.total)
steps += 1
# cellular peak generation mode:
if mode == "cell.peaks":
command = "python <<CODEPATH>>mapCells.py --path <<PATH>> --organism <<ORGANISM>> --mode <<MODE>> --peaks <<PEAKS>> --start <<START>> --stop <<STOP>> --total <<TOTAL>> --expression <<EXPRESSION>> --collection <<COLLECTION>> --times <<TIMES>> --fraction <<FRACTION>> --minimum <<MINIMUM>> --name <<NAME>> --qsub <<QSUB>> --server <<SERVER>> --module <<MODULE>>"
command = command.replace("<<CODEPATH>>", option.path + "/python/")
command = command.replace("<<PATH>>", option.path)
command = command.replace("<<ORGANISM>>", option.organism)
command = command.replace("<<MODE>>", mode)
command = command.replace("<<PEAKS>>", option.peaks)
command = command.replace("<<START>>", str(index))
command = command.replace("<<STOP>>", str(index))
command = command.replace("<<TOTAL>>", str(option.total))
command = command.replace("<<EXPRESSION>>", option.expression)
command = command.replace("<<COLLECTION>>", option.collection)
command = command.replace("<<TIMES>>", option.times)
command = command.replace("<<FRACTION>>", str(option.fraction))
command = command.replace("<<MINIMUM>>", str(option.minimum))
command = command.replace("<<NAME>>", option.name + general.indexTag(index, option.total))
command = command.replace("<<QSUB>>", option.qsub)
command = command.replace("<<SERVER>>", option.server)
command = command.replace("<<MODULE>>", "md" + str(m))
# cellular peak generation mode:
if mode == "cell.annotation":
command = "python <<CODEPATH>>mapCells.py --path <<PATH>> --organism <<ORGANISM>> --mode <<MODE>> --peaks <<PEAKS>> --start <<START>> --stop <<STOP>> --total <<TOTAL>> --infile <<INFILE>> --collection <<COLLECTION>> --times <<TIMES>> --name <<NAME>> --qsub <<QSUB>> --server <<SERVER>> --module <<MODULE>>"
command = command.replace("<<CODEPATH>>", option.path + "/python/")
command = command.replace("<<PATH>>", option.path)
command = command.replace("<<ORGANISM>>", option.organism)
command = command.replace("<<MODE>>", mode)
command = command.replace("<<PEAKS>>", option.peaks)
command = command.replace("<<START>>", str(index))
command = command.replace("<<STOP>>", str(index))
command = command.replace("<<TOTAL>>", str(option.total))
command = command.replace("<<INFILE>>", option.infile)
command = command.replace("<<COLLECTION>>", option.collection)
command = command.replace("<<TIMES>>", option.times)
command = command.replace("<<NAME>>", option.name + general.indexTag(index, option.total) + option.nametag)
command = command.replace("<<QSUB>>", option.qsub)
command = command.replace("<<SERVER>>", option.server)
command = command.replace("<<MODULE>>", "md" + str(m))
# cellular overlap mode:
if mode == "cell.overlap":
command = "python <<CODEPATH>>mapCells.py --path <<PATH>> --organism <<ORGANISM>> --mode <<MODE>> --peaks <<PEAKS>> --start <<START>> --stop <<STOP>> --total <<TOTAL>> --expression <<EXPRESSION>> --collection <<COLLECTION>> --times <<TIMES>> --fraction <<FRACTION>> --minimum <<MINIMUM>> --extend <<EXTEND>> --name <<NAME>> --qsub <<QSUB>> --server <<SERVER>> --module <<MODULE>>"
command = command.replace("<<CODEPATH>>", option.path + "/python/")
command = command.replace("<<PATH>>", option.path)
command = command.replace("<<ORGANISM>>", option.organism)
command = command.replace("<<MODE>>", mode)
command = command.replace("<<PEAKS>>", option.peaks)
command = command.replace("<<START>>", str(index))
command = command.replace("<<STOP>>", str(index))
command = command.replace("<<TOTAL>>", str(option.total))
command = command.replace("<<EXPRESSION>>", option.expression)
command = command.replace("<<COLLECTION>>", option.collection + general.indexTag(index, option.total) + option.nametag)
command = command.replace("<<TIMES>>", option.times)
command = command.replace("<<NAME>>", option.name)
command = command.replace("<<FRACTION>>", str(option.fraction))
command = command.replace("<<MINIMUM>>", str(option.minimum))
command = command.replace("<<EXTEND>>", str(option.extend))
command = command.replace("<<QSUB>>", option.qsub)
command = command.replace("<<SERVER>>", option.server)
command = command.replace("<<MODULE>>", "md" + str(m))
# coassociations hybrid mode:
if mode == "cell.hybrid":
collection = option.collection + general.indexTag(index, option.total) + option.nametag
command = "python <<CODEPATH>>mapCells.py --path <<PATH>> --organism <<ORGANISM>> --mode <<MODE>> --A <<A>> --B <<B>> --indexes <<INDEXES>> --values <<VALUES>> --contexts <<CONTEXTS>>"
command = command.replace("<<CODEPATH>>", option.path + "/python/")
command = command.replace("<<PATH>>", option.path)
command = command.replace("<<ORGANISM>>", option.organism)
command = command.replace("<<MODE>>", mode)
command = command.replace("<<A>>", option.a)
command = command.replace("<<B>>", collection + "/mapcells_" + collection + "_matrix_overlap")
command = command.replace("<<INDEXES>>", option.indexes)
command = command.replace("<<VALUES>>", option.values)
command = command.replace("<<CONTEXTS>>", option.contexts)
# is it time to export a chunk?
if index-start+option.step == chunks:
# update start, modules, commands, and module count (m):
start = index + option.step
commands.append(command)
modules.append(commands)
commands = list()
complete = True
m += 1
# store whether the most recent index/command has been stored:
else:
complete = False
# update if there are additional commands:
if not complete:
commands.append(command)
modules.append(commands)
m += 1
# launch commands:
print
print "Launching comparisons:", len(modules)
#for module in modules:
# for command in module:
# print command
runCommands(modules, threads=option.threads, mode="module.run", run_mode="verbose", run_path=bash_path, run_base=bash_base, record=True, qsub_header=qsub_header, qsub=qsub)
print "Analyses performed:", len(modules)
print
# filter cells :
elif option.mode == "filter":
# load cells to filter:
filterCells = open(path_dict[option.source] + option.target).read().strip().split("\n")
# generate output file:
f_output = open(path_dict[option.source] + option.name, "w")
# process input lines:
f, k = 0, 0
inlines = open(path_dict[option.source] + option.infile).readlines()
for inline in inlines:
process = True
items = inline.strip().split(",")
for item in items:
if item in filterCells:
process = False
f += 1
if process:
print >>f_output, inline.strip()
k += 1
print
print "Input lines:", len(inlines)
print "Output lines:", k, "(" + str(f) + " filtered)"
print
# close output:
f_output.close()
# simplify cell annotations :
elif option.mode == "simply":
# generate output file:
f_output = open(path_dict[option.source] | |
"""
server.py
Provides classes to create servers and handle their clients.
"""
import socket
from . import logger
from .settings import default_header_size, default_chunk_size, default_port, default_queue
from abc import ABC, abstractmethod
import threading
from typing import Tuple, Any, Callable, List, Union
import pickle
import traceback
from pathlib import Path
TimeoutException = socket.timeout
class Server(ABC):
"""
An Abstract Server object containing the ip and port it is bound to.
Args:
ip (str): The ip address(IPV4) of the server. Defaults to local machine's ip
port(int): The port the server must be bound to. Defaults to tcpsockets.settings.default_port if it is not set
to None else raises Exception.
queue(int): The waiting queue length of the server. Defaults to tcpsockets.settings.default_queue if it is not
set to None else raises Exception.
background(bool): Whether the server runs in background (in separate thread) or not. Defaults to True
Attributes:
ip (str): The ip address(IPV4) of the server.
port(str): The port the server is bound to.
socket(socket.socket): Reference to the socket object.
background(bool): Whether the server runs in separate thread or not.
running(bool): Whether the server is running or not.
server_thread(threading.Thread): The Thread in which the server will run if background is True.
"""
def __init__(self, ip: str = socket.gethostbyname(socket.gethostname()), port: int = None, queue: int = None,
background: bool = True):
self.background: bool = background
self.running: bool = False
self.port: int = port
if self.port is None:
if default_port is None:
raise Exception("Either Server port or Default Port must be set.")
self.port = default_port
self.queue = queue
if self.queue is None:
if default_queue is None:
raise Exception("Either queue parameter or Default Queue must be set.")
self.queue = default_queue
self.ip: str = ip
logger.log("Creating server socket")
self.socket: socket.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
logger.log(f"Binding socket to {self.ip} at {self.port}")
self.socket.bind((self.ip, self.port))
if self.background:
self.server_thread = threading.Thread(target=self.starter)
self.closing = False
def handler(self, client: "Client") -> None:
"""
The Function called when the client connects to the server. Must be overridden by inheritance or by calling
the client_handler decorator.
Args:
client(Client): The Client object that has connected to the server.
Returns:
None
"""
raise Exception("No Handler set")
def client_handler(self, func: Callable) -> None:
"""
Decorator to set the client handler.
Args:
func(Callable): The User Defined Client Handler function that must take one positional argument of type
tcpsockets.server.Client.
Returns:
None
"""
# noinspection PyAttributeOutsideInit
self.handler = func
def start(self) -> None:
"""
Start the server.
Returns:
None
"""
if self.running:
return
if self.background:
self.server_thread.start()
else:
self.starter()
@abstractmethod
def starter(self):
pass
class Client:
"""
A Client Class which represents a client a they connect to the server. Provides methods to send and receive any
python object that can be pickled.
Args:
sckt(socket.socket): reference to the client's socket returned by socket.accept()
address(Tuple[str,int]): a tuple containing the ip and the port.
Attributes:
total_client_connections(int): A Class variable which tracks the total number of client by tracking all its
Objects.
client_connection_id(int): An id uniquely identifying one instance of a connection. It is an int set to the
total number of connections made just after the client joins.
socket(socket.socket): reference to the client's socket returned by socket.accept()
ip(str): The ip address(IPV4) of the client returned by socket.accept()
port(int): The port the client is connected to.
"""
total_client_connections: int = 0
def __init__(self, sckt: socket.socket, address: Tuple[str, int]):
Client.total_client_connections += 1
self.client_connection_id: int = Client.total_client_connections
self.socket: socket.socket = sckt
self.ip: str = address[0]
self.port: int = address[1]
def close(self) -> None:
"""
Closes the socket.
Returns:
None
"""
self.socket.close()
def send(self, obj: Any, byte_converter: Callable[[Any], bytes] = None) -> None:
"""
Send a python object that can be pickled to the client. First sends a fixed length header defined in
tcpsockets.settings giving the size of outgoing message then sends the pickled object. default_header_size
can be set by using tcpsockets.settings.set_default_header_size function.
Args:
obj(Any): The Object that has to be sent to the client that can be pickled.
byte_converter(Callable[[Any], bytes]): Function to convert object to bytes.
Returns:
None
"""
if byte_converter is None:
bytes_obj = pickle.dumps(obj)
else:
bytes_obj = byte_converter(obj)
bytes_obj_size = len(bytes_obj)
header = str(bytes_obj_size).ljust(default_header_size).encode("utf-8")
self.socket.send(header)
self.socket.send(bytes_obj)
def send_to(self, obj: Any, client: "Client", byte_converter: Callable[[Any], bytes] = None):
"""
Send a python object that can be pickled to the client. First sends a fixed length header defined in
tcpsockets.settings giving the size of outgoing message then sends the pickled object. default_header_size
can be set by using tcpsockets.settings.set_default_header_size function.
Args:
client(Client): Which client to send it to
obj(Any): The Object that has to be sent to the client that can be pickled.
byte_converter(Callable[[Any], bytes]): Function to convert object to bytes.
Returns:
None
"""
if byte_converter is None:
bytes_obj = pickle.dumps(obj)
else:
bytes_obj = byte_converter(obj)
bytes_obj_size = len(bytes_obj)
header = str(bytes_obj_size).ljust(default_header_size).encode("utf-8")
self.socket.sendto(header, address=(client.ip, client.port))
self.socket.sendto(bytes_obj, address=(client.ip, client.port))
def receive(self, chunk_size: int = None, byte_converter: Callable[[bytes], Any] = None) -> Any:
"""
Receive a python object sent by the client. First receive a fixed length header then receive the pickled object
chunk by chunk using the chunk_size argument.
Args:
chunk_size(int): The amount of bytes to receive at once. Defaults to tcpsockets.settings.default_chunk_size.
byte_converter(Callable[[bytes], Any]): Function to convert bytes to object.
Returns:
Any: The object sent by the server
"""
if chunk_size is None:
chunk_size = default_chunk_size
obj_size_header: str = self.socket.recv(default_header_size).decode("utf-8")
obj_size: int = int(obj_size_header.strip())
bytes_obj = b""
for _ in range(obj_size // chunk_size):
bytes_obj += self.socket.recv(chunk_size)
bytes_obj += self.socket.recv(obj_size % chunk_size)
return pickle.loads(bytes_obj) if byte_converter is None else byte_converter(bytes_obj)
def send_file(self, file_location: Path, chunk_size: int) -> None:
"""
Send a file object in small chunks whose sizes are "chunk_size" each.
Args:
file_location(Path): Path object representing file location of the file to be sent.
chunk_size(int): Size of 1 chunk.
"""
self.send((file_location.name, file_location.stat().st_size))
with open(file_location, "rb") as file:
file_chunk = file.read(chunk_size)
self.socket.send(file_chunk)
while file_chunk:
file_chunk = file.read(chunk_size)
self.socket.send(file_chunk)
def receive_file(self, file_save_location: Path, chunk_size: int) -> None:
"""
Receive a file object in small chunks whose sizes are "chunk_size" each.
Args:
file_location(Path): Path object representing location of the folder where the file is to be saved.
chunk_size(int): Size of 1 chunk.
"""
name, size = self.receive()
with open(file_save_location / name, "wb") as file:
byte_number = 0
while byte_number < size:
byte_chunk = self.socket.recv(chunk_size)
byte_number += len(byte_chunk)
file.write(byte_chunk)
def set_receive_timeout(self, timeout: int) -> None:
"""
Sets the time out for Client.receive(). Raises socket.timeout after timeout.
Args:
timeout(int): Number of seconds for timeout.
"""
self.socket.settimeout(timeout)
def __eq__(self, other: "Client") -> bool:
"""
Checks if the client objects have same client_connection_id
Args:
other(Client): The other client object to be compared with.
Returns:
bool: bool saying whether both client objects have the same client_connection_id.
"""
return self.client_connection_id == other.client_connection_id
class SequentialServer(Server):
"""
A Sequential Server for handling clients one by one.
Args:
ip (str): The ip address(IPV4) of the server. Defaults to local machine's ip
port(int): The port the server must be bound to. Defaults to tcpsockets.settings.default_port if
it is not set to None else raises Exception.
queue(int): The waiting queue length of the server. Defaults to tcpsockets.settings.default_queue
if it is not set to None else raises Exception.
background(bool): Whether the server runs in background (in separate thread) or not. Defaults to True
Attributes:
handling(bool): A bool saying whether the server is handling a client or not.
stopper_thread(threading.Thread): A Thread that is responsible for stopping the Server.
current_client(Union[None, Client]): The Client Object of the client currently being handled.
If not handling then it is set to None.
"""
def __init__(self, ip: str = socket.gethostbyname(socket.gethostname()), port: int = None, queue: int = None,
background: bool = True):
super(SequentialServer, self).__init__(ip, port, queue, background)
self.handling: bool = False
self.stopper_thread: threading.Thread = threading.Thread(target=self.stopper)
self.current_client: Union[None, Client] = None
def stopper(self) -> None:
"""
A stopper method running in its own thread to stop the server if it is stuck in the blocking socket.accept.
Creates a new socket to stop socket.accept.
Returns:
None
"""
while self.running or self.handling:
pass
closer_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
closer_socket.connect((self.ip, self.port))
except ConnectionRefusedError:
pass
closer_socket.close()
def starter(self) | |
Check for connecting lanes. This is pretty much for the roundabouts, but some weird geometries
# make it possible for single junctions to have the same road entering and exiting. Two cases,
# Lanes that exit one junction and enter another (or viceversa)
exit_lane_keys = [get_lane_key(wp) for wp in exit_lane_wps]
entry_lane_keys = [get_lane_key(wp) for wp in entry_lane_wps]
for wp in list(entry_lane_wps):
if get_lane_key(wp) in exit_lane_keys:
entry_lane_wps.remove(wp)
if self.debug:
draw_point(self._world, wp.transform.location, 'small', 'connect', True)
for wp in list(exit_lane_wps):
if get_lane_key(wp) in entry_lane_keys:
exit_lane_wps.remove(wp)
if self.debug:
draw_point(self._world, wp.transform.location, 'small', 'connect', True)
# Lanes with a fake junction in the middle (maps junction exit to fake junction entry and viceversa)
for entry_key, exit_key in self._fake_lane_pair_keys:
entry_wp = None
for wp in entry_lane_wps:
if get_lane_key(wp) == exit_key: # A junction exit is a fake junction entry
entry_wp = wp
break
exit_wp = None
for wp in exit_lane_wps:
if get_lane_key(wp) == entry_key: # A junction entry is a fake junction exit
exit_wp = wp
break
if entry_wp and exit_wp:
entry_lane_wps.remove(entry_wp)
exit_lane_wps.remove(exit_wp)
if self.debug:
draw_point(self._world, entry_wp.transform.location, 'small', 'connect', True)
draw_point(self._world, exit_wp.transform.location, 'small', 'connect', True)
junction_data.entry_wps = entry_lane_wps
junction_data.exit_wps = exit_lane_wps
# Filter the entries and exits that correspond to the route
route_entry_wp = self._route[junction_data.route_entry_index]
# Junction entry
for wp in get_same_dir_lanes(route_entry_wp):
junction_wp = self._get_closest_junction_waypoint(wp, entry_lane_wps)
junction_data.route_entry_keys.append(get_lane_key(junction_wp))
for wp in get_opposite_dir_lanes(route_entry_wp):
junction_wp = self._get_closest_junction_waypoint(wp, exit_lane_wps)
junction_data.opposite_exit_keys.append(get_lane_key(junction_wp))
# Junction exit
if junction_data.route_exit_index: # Can be None if route ends at a junction
route_exit_wp = self._route[junction_data.route_exit_index]
for wp in get_same_dir_lanes(route_exit_wp):
junction_wp = self._get_closest_junction_waypoint(wp, exit_lane_wps)
junction_data.route_exit_keys.append(get_lane_key(junction_wp))
for wp in get_opposite_dir_lanes(route_exit_wp):
junction_wp = self._get_closest_junction_waypoint(wp, entry_lane_wps)
junction_data.opposite_entry_keys.append(get_lane_key(junction_wp))
# Add the entry directions of each lane with respect to the route. Used for scenarios 7 to 9
route_entry_yaw = route_entry_wp.transform.rotation.yaw
for wp in entry_lane_wps:
diff = (wp.transform.rotation.yaw - route_entry_yaw) % 360
if diff > 330.0:
direction = 'ref'
elif diff > 225.0:
direction = 'right'
elif diff > 135.0:
direction = 'opposite'
elif diff > 30.0:
direction = 'left'
else:
direction = 'ref'
junction_data.entry_directions[direction].append(get_lane_key(wp))
# Supposing scenario vehicles go straight, these correspond to the exit lanes of the entry directions
for wp in exit_lane_wps:
diff = (wp.transform.rotation.yaw - route_entry_yaw) % 360
if diff > 330.0:
direction = 'ref'
elif diff > 225.0:
direction = 'right'
elif diff > 135.0:
direction = 'opposite'
elif diff > 30.0:
direction = 'left'
else:
direction = 'ref'
junction_data.exit_directions[direction].append(get_lane_key(wp))
if self.debug:
exit_lane = self._route[junction_data.route_exit_index] if junction_data.route_exit_index else None
print('> R Entry Lane: {}'.format(get_lane_key(self._route[junction_data.route_entry_index])))
print('> R Exit Lane: {}'.format(get_lane_key(exit_lane)))
entry_print = '> J Entry Lanes: '
for entry_wp in entry_lane_wps:
key = get_lane_key(entry_wp)
entry_print += key + ' ' * (6 - len(key))
print(entry_print)
exit_print = '> J Exit Lanes: '
for exit_wp in exit_lane_wps:
key = get_lane_key(exit_wp)
exit_print += key + ' ' * (6 - len(key))
print(exit_print)
route_entry = '> R-J Entry Lanes: '
for entry_key in junction_data.route_entry_keys:
route_entry += entry_key + ' ' * (6 - len(entry_key))
print(route_entry)
route_exit = '> R-J Route Exit Lanes: '
for exit_key in junction_data.route_exit_keys:
route_exit += exit_key + ' ' * (6 - len(exit_key))
print(route_exit)
route_oppo_entry = '> R-J Oppo Entry Lanes: '
for oppo_entry_key in junction_data.opposite_entry_keys:
route_oppo_entry += oppo_entry_key + ' ' * (6 - len(oppo_entry_key))
print(route_oppo_entry)
route_oppo_exit = '> R-J Oppo Exit Lanes: '
for oppo_exit_key in junction_data.opposite_exit_keys:
route_oppo_exit += oppo_exit_key + ' ' * (6 - len(oppo_exit_key))
print(route_oppo_exit)
################################
## Waypoint related functions ##
################################
def _is_junction(self, waypoint):
if not waypoint.is_junction or waypoint.junction_id in self._fake_junction_ids:
return False
return True
################################
## Mode functions ##
################################
def _add_actor_dict_element(self, actor_dict, actor, exit_lane_key='', at_oppo_entry_lane=False):
"""Adds a new actor to the actor dictionary"""
actor_dict[actor] = {
'state': 'junction_entry' if not exit_lane_key else 'junction_exit',
'exit_lane_key': exit_lane_key,
'at_oppo_entry_lane': at_oppo_entry_lane
}
def _switch_to_junction_mode(self, junction):
"""Prepares the junction mode, changing the state of the actors"""
self._ego_state = 'junction'
for actor in list(self._road_actors):
self._add_actor_dict_element(junction.actor_dict, actor)
self._road_actors.remove(actor)
if not self._is_scenario_2_active:
self._tm.vehicle_percentage_speed_difference(actor, 0)
self._road_back_actors.clear()
self._road_extra_front_actors = 0
self._opposite_sources.clear()
def _initialise_junction_scenario(self, direction, remove_entries, remove_exits, remove_middle):
"""
Removes all vehicles in a particular 'direction' as well as all actors inside the junction.
Additionally, activates some flags to ensure the junction is empty at all times
"""
if self._active_junctions:
scenario_junction = self._active_junctions[0]
scenario_junction.scenario_info = {
'direction': direction,
'remove_entries': remove_entries,
'remove_middle': remove_middle,
'remove_exits': remove_exits,
}
entry_direction_keys = scenario_junction.entry_directions[direction]
actor_dict = scenario_junction.actor_dict
if remove_entries:
for entry_source in scenario_junction.entry_sources:
if get_lane_key(entry_source.entry_lane_wp) in entry_direction_keys:
# Source is affected
actors = entry_source.actors
for actor in list(actors):
if actor_dict[actor]['state'] == 'junction_entry':
# Actor is at the entry lane
self._destroy_actor(actor)
if remove_exits:
for exit_dir in scenario_junction.exit_directions[direction]:
for actor in list(scenario_junction.exit_dict[exit_dir]['actors']):
self._destroy_actor(actor)
if remove_middle:
actor_dict = scenario_junction.actor_dict
for actor in list(actor_dict):
if actor_dict[actor]['state'] == 'junction_middle':
self._destroy_actor(actor)
def _handle_junction_scenario_end(self, junction):
"""Ends the junction scenario interaction. This is pretty much useless as the junction
scenario ends at the same time as the active junction, but in the future it might not"""
junction.scenario_info = {
'direction': None,
'remove_entries': False,
'remove_middle': False,
'remove_exits': False,
}
def _monitor_scenario_4_end(self, ego_location):
"""Monitors the ego distance to the junction to know if the scenario 4 has ended"""
if self._ego_exitted_junction:
ref_location = self._start_ego_wp.transform.location
if ego_location.distance(ref_location) > self._crossing_dist:
for actor in self._scenario_4_actors:
self._tm.vehicle_percentage_speed_difference(actor, 0)
self._is_scenario_4_active = False
self._scenario_4_actors.clear()
self._ego_exitted_junction = False
self._crossing_dist = None
def _handle_scenario_4_interaction(self, junction, ego_wp):
"""
Handles the interation between the scenario 4 of the Leaderboard and the background activity.
This removes all vehicles near the bycicle path, and stops the others so that they don't interfere
"""
if not self._is_scenario_4_active:
return
self._ego_exitted_junction = True
self._start_ego_wp = ego_wp
min_crossing_space = 2
# Actor exitting the junction
exit_dict = junction.exit_dict
for exit_key in exit_dict:
if exit_key not in junction.route_exit_keys:
continue
actors = exit_dict[exit_key]['actors']
exit_lane_wp = exit_dict[exit_key]['ref_wp']
exit_lane_location = exit_lane_wp.transform.location
for actor in list(actors):
actor_location = CarlaDataProvider.get_location(actor)
if not actor_location:
self._destroy_actor(actor)
continue
dist_to_scenario = exit_lane_location.distance(actor_location) - self._crossing_dist
actor_length = actor.bounding_box.extent.x
if abs(dist_to_scenario) < actor_length + min_crossing_space:
self._destroy_actor(actor)
continue
if dist_to_scenario > 0:
continue # Don't stop the actors that have already passed the scenario
if get_lane_key(ego_wp) == get_lane_key(exit_lane_wp):
self._destroy_actor(actor)
continue # Actor at the ego lane and between the ego and scenario
self._scenario_4_actors.append(actor)
# Actor entering the junction
for entry_source in junction.entry_sources:
entry_lane_wp = entry_source.entry_lane_wp
if get_lane_key(entry_lane_wp) in junction.opposite_entry_keys:
# Source is affected
actors = entry_source.actors
entry_lane_location = entry_lane_wp.transform.location
for actor in list(actors):
actor_location = CarlaDataProvider.get_location(actor)
if not actor_location:
self._destroy_actor(actor)
continue
crossing_space = abs(entry_lane_location.distance(actor_location) - self._crossing_dist)
actor_length = actor.bounding_box.extent.x
if crossing_space < actor_length + min_crossing_space:
self._destroy_actor(actor)
continue # Actors blocking the path of the crossing obstacle
self._scenario_4_actors.append(actor)
# Actors entering the next junction
if len(self._active_junctions) > 1:
next_junction = self._active_junctions[1]
actors_dict = next_junction.actor_dict
for actor in list(actors_dict):
if actors_dict[actor]['state'] != 'junction_entry':
continue
actor_location = CarlaDataProvider.get_location(actor)
if not actor_location:
self._destroy_actor(actor)
continue
dist_to_scenario = exit_lane_location.distance(actor_location) - self._crossing_dist
actor_length = actor.bounding_box.extent.x
if abs(dist_to_scenario) < actor_length + min_crossing_space:
self._destroy_actor(actor)
continue
if dist_to_scenario > 0:
continue # Don't stop the actors that have already passed the scenario
actor_wp = self._map.get_waypoint(actor_location)
if get_lane_key(ego_wp) == get_lane_key(actor_wp):
self._destroy_actor(actor)
continue # Actor at the ego lane and between the ego and scenario
self._scenario_4_actors.append(actor)
# Immediately freeze the actors
for actor in self._scenario_4_actors:
try:
actor.set_target_velocity(carla.Vector3D(0, 0, 0))
self._tm.vehicle_percentage_speed_difference(actor, 100)
except RuntimeError:
pass # Just in case the actor is not alive
def _end_junction_behavior(self, ego_wp, junction):
"""
Destroys unneeded actors (those behind the ego), moves the rest to other data structures
and cleans up the variables. If no other junctions are active, starts road mode
"""
actor_dict = junction.actor_dict
route_exit_keys = junction.route_exit_keys
self._active_junctions.pop(0)
for actor in list(actor_dict):
location = CarlaDataProvider.get_location(actor)
if not location or self._is_location_behind_ego(location):
self._destroy_actor(actor)
continue
self._tm.vehicle_percentage_speed_difference(actor, 0)
if actor_dict[actor]['at_oppo_entry_lane']:
self._opposite_actors.append(actor)
self._tm.ignore_lights_percentage(actor, 100)
self._tm.ignore_signs_percentage(actor, 100)
continue
if not self._active_junctions and actor_dict[actor]['exit_lane_key'] in route_exit_keys:
self._road_actors.append(actor)
continue
self._destroy_actor(actor)
self._handle_scenario_4_interaction(junction, ego_wp)
self._handle_junction_scenario_end(junction)
self._switch_junction_road_sources(junction)
if not self._active_junctions:
self._ego_state = 'road'
self._initialise_opposite_sources()
self._initialise_road_checker()
self._road_ego_key = self._get_ego_route_lane_key(ego_wp)
for source in junction.exit_sources:
self._road_back_actors[source.mapped_key] = []
def _switch_junction_road_sources(self, junction):
"""
Removes the sources part of the previous road and gets the ones of the exitted junction.
"""
self._road_sources.clear()
new_sources = junction.exit_sources
self._road_sources.extend(new_sources)
def _search_for_next_junction(self):
"""Check if | |
is not exist in the current DB-Structure".format(dbname), exc_info=self._logger_traceback)
return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
### Update Attribute
if "info" in self.tables(dbname=dbname):
try:
#cursor = self._db.cursor()
self._threads_cursors[thread_name].execute(query)
self._commit(write_all_cash=False)
self._update_temp_attributsList_in_instance(thread_name=thread_name)
return Status(status=True)
except Exception as exception:
print_exc_plus() if self._ext_tb else ""
self.logger.error("Something happens while detaching of '{}'-DB: '{}'".format(attached_db_name, repr(exception) ), exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
else:
self.logger.error("Info-Table is wasn't found or not exist. Please initialize the Info Table, bevor you may add any attributes.", exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
def update_attrs(self, inp_dict, dbname="main", thread_name="Thread0"):
### Exception Handling
s = self._check_db_should_exist()
if not s["status"]:
return s
self._commit_if_inserts_was_did()
# Check if attributes and values have the same length
# Check if attributes and values have the same length
if not isinstance(inp_dict, dict):
self.logger.error("UpdateAttributes: InputDict is not an 'dict'.", exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
inp_dict = copy.deepcopy(inp_dict)
# if given attribute exist in the Info_Table
col_in_info_table = self.col("info", dbname=dbname)
if not all(elem in col_in_info_table for elem in inp_dict.keys()):
average = list(set(inp_dict.keys())-set(col_in_info_table))
self.logger.error("Some of the given Attributes ('{}') is not exist in this DataBase. ".format(average ), exc_info=self._logger_traceback)
return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
attrib_to_str = ",".join(["{}='{}'".format(k,v) for k,v in inp_dict.iteritems()])
if dbname in self.dbnames:
query = 'UPDATE {}.info \nSET {};'.format(dbname,attrib_to_str)
else:
self.logger.error("Given dbName ('{}') is not exist in the current DB-Structure".format(dbname), exc_info=self._logger_traceback)
return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
### Update Attribute
if "info" in self.tables(dbname=dbname):
try:
#cursor = self._db.cursor()
self._threads_cursors[thread_name].execute(query)
self._commit(write_all_cash=False)
self._update_temp_attributsList_in_instance(thread_name=thread_name)
return Status(status=True)
except Exception as exception:
print_exc_plus() if self._ext_tb else ""
self.logger.error("Something happens while detaching of '{}'-DB: '{}'".format(attached_db_name, repr(exception) ), exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
else:
self.logger.error("Info-Table is wasn't found or not exist. Please initialize the Info Table, bevor you may add any attributes.", exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
def get_attr(self,attributName, dbname="main"):
s = self._check_db_should_exist()
if not s["status"]:
return s
if not isinstance(attributName, (str, unicode)):
self.logger.error("Given AttributName should be an string or unicode object.", exc_info=self._logger_traceback)
#return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
return None
if not self._attributs_dict:
self.logger.warning("Temporary AttributesList is empty")
#return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
return None
# if given attribute exist in the Info_Table
#p((attributName, self._attributs_dict,dbname))
try:
if attributName not in self._attributs_dict[dbname]:
self.logger.error("Given Attribute ('{}') is not exist in the '{}'-DB.".format(attributName,dbname), exc_info=self._logger_traceback)
#return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
return None
except KeyError:
self.logger.error("'{}'-DB is not found.".format(dbname))
return None
if dbname in self.dbnames:
try:
return self._attributs_dict.get(dbname, None).get(attributName, None)
except:
return None
#[dbname][attributName]
else:
self.logger.error("Given dbName ('{}') is not exist in the current DB-Structure".format(dbname), exc_info=self._logger_traceback)
#return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
return None
def get_all_attr(self, dbname="main"):
s = self._check_db_should_exist()
if not s["status"]:
return s
if u"info" in self.tables(dbname=dbname):
if dbname in self.dbnames:
return self._attributs_dict[dbname]
else:
self.logger.error("Given dbName ('{}') is not exist in the current DB-Structure".format(dbname), exc_info=self._logger_traceback)
return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
else:
self.logger.error("Info-Table wasn't found or not exist. Please initialize the Info Table, bevor you may add any attributes.", exc_info=self._logger_traceback)
return Status(status=None, track_id=self._error_track_id.incr(), func_name=function_name(-2))
##########################DB-Execute Commands#####################
def execute(self, query, values=False, dbname="main", thread_name="Thread0"):
s = self._check_db_should_exist()
if not s["status"]:
return s
self._commit_if_inserts_was_did()
try:
#c =
s = self._execute(query, values=values, dbname=dbname, thread_name=thread_name, new_cursor=True)
#p(s, c="r")
if not s["status"]:
return False
else:
cur = s["out_obj"]
#p(cur, "cur")
self._update_temp_tablesList_in_instance(thread_name=thread_name)
self._update_temp_indexesList_in_instance(thread_name=thread_name)
self._update_database_pragma_list(thread_name=thread_name)
self._update_pragma_table_info(thread_name=thread_name)
return cur
except Exception as exception:
print_exc_plus() if self._ext_tb else ""
self.logger.error("Something happens while execution of the following query: '{}'. See following Exception: '{}'. ".format(query,str(exception)), exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
def executescript(self, query, thread_name="Thread0", dbname="main"):
s = self._check_db_should_exist()
if not s["status"]:
return s
self._commit_if_inserts_was_did()
try:
#cur = self._db.cursor()
self._threads_cursors[thread_name].executescript(query)
self._update_temp_tablesList_in_instance(thread_name=thread_name)
self._update_temp_indexesList_in_instance(thread_name=thread_name)
self._update_database_pragma_list(thread_name=thread_name)
self._update_pragma_table_info(thread_name=thread_name)
return cur
except Exception as exception:
print_exc_plus() if self._ext_tb else ""
self.logger.error("Something happens while execution of the following query: '{}'. See following Exception: '{}'. ".format(query,str(exception)), exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
def executemany(self, query, argument, thread_name="Thread0", dbname="main"):
s = self._check_db_should_exist()
if not s["status"]:
return s
self._commit_if_inserts_was_did()
try:
s = self._executemany(query, values=argument, dbname=dbname, thread_name=thread_name, new_cursor=True)
if not s["status"]:
return s
else:
cur = s["out_obj"]
self._update_temp_tablesList_in_instance(thread_name=thread_name)
self._update_temp_indexesList_in_instance(thread_name=thread_name)
self._update_database_pragma_list(thread_name=thread_name)
self._update_pragma_table_info(thread_name=thread_name)
return cur
except Exception as exception:
print_exc_plus() if self._ext_tb else ""
self.logger.error("Something happens while execution of the following query: '{}'. See following Exception: '{}'. ".format(query,str(exception)), exc_info=self._logger_traceback)
return Status(status=False, track_id=self._error_track_id.incr(), func_name=function_name(-2))
def _executemany(self, query, values=False, dbname="main", thread_name="Thread0", new_cursor = False):
return self._execution(query, values=values, dbname=dbname, many=True, thread_name=thread_name, new_cursor=new_cursor)
def _execute(self, query, values=False, dbname="main", thread_name="Thread0", new_cursor = False):
return self._execution(query, values=values, dbname=dbname, many=False,thread_name=thread_name, new_cursor=new_cursor)
def _execution(self,query, values=False, dbname="main", many=False, thread_name="Thread0", new_cursor = False):
#p("EXECUTION")
try:
try:
cursor = self._threads_cursors[thread_name]
except:
self._threads_cursors[thread_name] = self._db.cursor()
cursor = self._threads_cursors[thread_name]
cursor = self._db.cursor() if new_cursor else cursor
#p(type(cursor))
#p(query,"query")
if many:
if values:
cursor.executemany(query, values)
else:
cursor.executemany(query)
else:
if values:
cursor.execute(query, values)
else:
cursor.execute(query)
if self._thread_safe:
cursor.join()
#time.sleep(5)
return Status(status=True, out_obj=cursor)
except (sqlite.OperationalError, sqlite.IntegrityError) as exception:
track_id = self._error_track_id.incr()
l_query = query if self._log_content else "!!LogContentDisable!!"
l_values = values if self._log_content else "!!LogContentDisable!!"
if "UNIQUE constraint failed:" in str(exception):
msg = "UniquenessERROR: Redundant row was get and was out-sorted. |ErrorTrackID:'{}'| See Exception: '{}'. InpQuery: '{}'. InpValues: '{}'. ".format( track_id, repr(exception), l_query, l_values)
#self.logger.outsorted_corpus()
if self.typ(dbname=dbname) == "corpus":
level_name = "outsorted_corpus"
self.logger.outsorted_corpus(msg)
elif self.typ(dbname=dbname) == "stats":
level_name = "outsorted_stats"
self.logger.outsorted_stats(msg)
else:
level_name = "error_insertion"
self.logger.error_insertion(msg)
self.error_insertion_counter.incr()
return Status(status=False, track_id=track_id,
desc="Redundant row was get.",
level=level_name, action="outsorted",
inp_obj= (query, values,dbname),
error_name="{} (UniquenessERROR)".format(exception.__class__.__name__), exception=exception)
elif "SQL logic error" in str(exception):
msg = "SQL logic error (ThreadsCrash): Probably it is the result of ThreadsCrash. Please use option 'thread_safe' to ensure ThreadSafety and run script again. (Attention: Executed insertions could be inconsistent!) |ErrorTrackID:'{}'| See Exception: '{}'. InpQuery: '{}'. InpValues: '{}'. ".format( track_id, repr(exception), l_query, l_values)
#self.logger.outsorted_corpus()
level_name = "error_insertion"
self.logger.error_insertion(msg)
self.error_insertion_counter.incr()
#if self._raise_exceptions:
# raise ThreadsCrash,
# "SQL logic error: Probably it is the result of ThreadsCrash. Please use option 'thread_safe' to ensure ThreadSafety and run script again. |ErrorTrackID:'{}'| (Attention: Executed insertions could be inconsistent!) ".format(track_id)
return Status(status=False, track_id=track_id,
desc="SQL logic error. ",
level=level_name, action="ThreadsCrash",
inp_obj= (query, values,dbname),
error_name="{} (ErrorBindingParameter)".format(exception.__class__.__name__), exception=exception)
else:
msg = "ExecutionError: '{}'. (current Execution was ignored) |ErrorTrackID:'{}'|".format( repr(exception),track_id )
if "has no column named" in str(exception):
msg = "ExecutionError: '{}'. (current Execution was ignored) Possible Solution: 'Insert failed columns into SQL-DataBase or use Reader-Template to format and outsorte not needed columns. ' |ErrorTrackID:'{}'|".format( repr(exception),track_id )
self.logger.error_insertion(msg, exc_info=self._logger_traceback)
self.error_insertion_counter.incr()
return Status(status=False, track_id=track_id,
desc="It is not possible to insert all got columns into CorpDB. Possible Explanation: 1. Current DB was initialized with wrong and not full number of columns, please reinitialize current CorpusDB with right column names and types. Or use also option precomputed corp types. For this use option 'template_name' on the Corpus Level ( while Initialization) (ex:template_name='twitter',or template_name='blogger' ) or also on the Reader Level 'reader_formatter_name='twitter'.",
level="error_insertion", action="stop_execution",
inp_obj= (query, values,dbname), func_name=function_name(-3),
error_name=exception.__class__.__name__, exception=repr(exception))
except sqlite.InterfaceError as exception:
#p((query, values))
track_id = self._error_track_id.incr()
l_query = query if self._log_content else "!!LogContentDisable!!"
l_values = values if self._log_content else "!!LogContentDisable!!"
#self.error_insertion_counter.incr()
if "Error binding parameter " in str(exception):
msg = "Error binding parameter(ThreadsCrash): Probably it is the result of ThreadsCrash. Please use option 'thread_safe' to ensure ThreadSafety and run script again. (Attention: Executed insertions could be inconsistent!) |ErrorTrackID:'{}'| See Exception: '{}'. InpQuery: '{}'. InpValues: '{}'. ".format( track_id, repr(exception), l_query, l_values)
#self.logger.outsorted_corpus()
level_name = "error_insertion"
self.logger.error_insertion(msg)
#if self._raise_exceptions:
# raise ThreadsCrash, "Error binding parameter: Probably it is the result of ThreadsCrash. Please use option 'thread_safe' to ensure ThreadSafety and run script again. |ErrorTrackID:'{}'| (Attention: Executed insertions could be inconsistent!) ".format(track_id)
self.error_insertion_counter.incr()
return Status(status=False, track_id=track_id,
desc="Error binding parameter",
level=level_name, action="ThreadsCrash",
inp_obj= (query, values,dbname),
error_name="{} (ErrorBindingParameter)".format(exception.__class__.__name__), exception=exception)
else:
self.logger.error_insertion("ExecutionError: '{}'. (current Execution was ignored) |ErrorTrackID:'{}'|".format( repr(exception),track_id ), exc_info=self._logger_traceback)
self.error_insertion_counter.incr()
return Status(status=False, track_id=track_id,
desc=repr(exception),
level="error_insertion", action="ignored",
inp_obj= (query, values,dbname), func_name=function_name(-3),
error_name=exception.__class__.__name__, exception=exception)
except Exception as exception:
track_id = self._error_track_id.incr()
print_exc_plus() if self._ext_tb else ""
self.logger.low_debug("ExecutionError: |ErrorTrackID:'{}'| Following Query could have an Error: '{}'. Track the error in the 'error_insertion'-Level. ".format(track_id, query, ))
l_query = query if self._log_content else "!!LogContentDisable!!"
l_values = values if self._log_content else "!!LogContentDisable!!"
self.error_insertion_counter.incr()
if "has no column named" in str(exception):
self.logger.error_insertion("ExecutionError: One of the columns is not in the Table. See Exception: '{}'. (current Execution was ignored) |ErrorTrackID:'{}'| | |
# -*- coding: utf-8 -*-
"""
Created 5 March 2019
epsc_peak_x.y.z.py
"""
# from __main__ import *
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import elephant
from neo.io import IgorIO
import os
from collections import OrderedDict
import math
def get_metadata(file, data_notes):
'''Takes a filename and parses it for metadata, and returns metadata in an
orderedDict as a pandas DataFrame for saving later
Also takes information from the cell spreadsheet in data_notes'''
# pull out cell id, cell number, date and condition
file_split = file.split('_')
cell_id = file_split[0]+'_'+file_split[1]
cell_num = cell_id[-1:]
date = '20'+cell_id[2:4]+'-'+cell_id[4:6]+'-'+cell_id[6:8]
if 'drug' in file:
condition = 'TTX+4-AP'
else:
condition = 'control'
# grab metadata from data notes spreadsheet
file_data = data_notes[data_notes['Cell name'] == file]
cell_path = file_data['File Path'].tolist()[0]
genotype = file_data['Genotype'].tolist()[0]
cell_type = file_data['Cell type'].tolist()[0]
depol_sweep_start = file_data['Depol sweeps start'].tolist()[0]
depol_sweep_stop = file_data['Depol sweeps stop'].tolist()[0]
# save metadate into orderedDict pandas DataFrame
dict = OrderedDict()
dict['Date'] = date
dict['Cell ID'] = cell_id
dict['Cell Number'] = cell_num
dict['Cell Path'] = cell_path
# dict['Condition'] = condition
dict['Genotype'] = genotype
dict['Cell Type'] = cell_type
dict['Exclude Sweep Start'] = depol_sweep_start
dict['Exclude Sweep Stop'] = depol_sweep_stop
metadata = pd.DataFrame(dict, index=range(1))
return metadata
def igor_to_pandas(file, data_dir):
'''This function opens an igor binary file (.ibw), extracts the time
series data, and returns a pandas DataFrame'''
file_path = os.path.join(data_dir, file)
data_raw = IgorIO(filename=file_path)
data_neo = data_raw.read_block()
data_neo_array = data_neo.segments[0].analogsignals[0]
data_df = pd.DataFrame(data_neo_array.as_array())
return data_df
def mean_baseline(data, stim_time, pre_stim=100, sf=10):
'''
Find the mean baseline in a given time series
Parameters
----------
data: pandas.Series or pandas.DataFrame
The time series data for which you want a baseline.
stim_time: int or float
The time in ms when stimulus is triggered.
pre_stim: int or float
Time in ms before the stimulus trigger over which baseline is measured.
sf: int or float
The sampling frequency in kHz.
Returns
-------
baseline: float or pandas.Series
The mean baseline over the defined window
'''
start = (stim_time - pre_stim) * sf
stop = (stim_time - 1) * sf
window = data.iloc[start:stop]
baseline = window.mean()
return baseline
def epsc_peak(data, baseline, stim_time, polarity='-', post_stim=100, sf=10):
'''
Find the peak EPSC value for a pandas.Series or for each sweep (column) of
a pandas.DataFrame. This finds the absolute peak value of mean baseline
subtracted data.
Parameters:
-----------
data: pandas.Series or pandas.DataFrame
Time series data with stimulated synaptic response triggered at the
same time for each sweep.
baseline: scalar or pandas.Series
Mean baseline values used to subtract for each sweep.
stim_time: int or float
Time in ms at which stimulus is triggered each sweep.
polarity: str
The expected polarity of the EPSC; negative: '-'; postitive: '+'.
Default is '-'.
post_stim: int or float
Time in ms that marks the end of the sampling window post stimulus.
Default is 100 ms.
sf: int or float
The sampling frequency in kHz. Default is 10 kHz.
Returns
-------
epsc_peaks: pandas.Series
The absolute peak of mean baseline subtracted time series data.
'''
subtracted_data = data - baseline
start = stim_time * sf
end = (stim_time + post_stim) * sf
peak_window = subtracted_data.iloc[start:end]
if polarity == '-':
epsc_peaks = peak_window.min()
elif polarity == '+':
epsc_peaks =peak_window.max()
else:
raise ValueError(
"polarity must either be + or -"
)
return epsc_peaks
def series_resistance(data, tp_start, vm_jump, sf=10):
'''
Calculate the approximate series resistance (Rs) from a test pulse (tp).
Parameters
----------
data: pandas.Series or pandas.DataFrame
Raw time series daata of the v-clamp recording in nA.
tp_start: int or float
Time in ms when test pulse begins.
vm_jump: int or float
Amplitude ofwhatever windows needs here the test pulse voltage command in mV..
sf: int or float
Sampling frequency in kHz. Default is 10 kHz.
Returns:
rs: pandas.Series of float
The series resistance for each sweep in MOhms.
'''
# find the baseline 10 ms pre test pulse and subtract from raw data
rs_baseline = mean_baseline(data, stim_time=tp_start, pre_stim=11)
rs_subtracted = data - rs_baseline
# set up indices for starting and ending peak window
start = tp_start * sf
end = (tp_start + 2) * sf
rs_window = rs_subtracted.iloc[start:end]
if vm_jump > 0:
rs_peak = rs_window.max()
else:
rs_peak = rs_window.min()
# calculate Rs via V=IR -> Rs = V/I
rs = ((vm_jump * 10**-3) / (rs_peak * 10**-9)) * 10**-6
return rs
''' *********************************************************************** '''
''' ################## Define file structure on server #################### '''
# home_dir will depend on the OS, but the rest will not
# query machine identity and set home_dir from there
machine = os.uname()[0]
if machine == 'Darwin':
home_dir = '/Volumes/Urban'
elif machine == 'Linux':
home_dir = '/run/user/1000/gvfs/smb-share:server=172.16.17.32,share=urban'
else:
home_dir = os.path.join('Z:', os.sep)
project_dir = os.path.join(home_dir, 'Huang', 'OSN_OMPvGg8_MTC')
figure_dir = os.path.join(project_dir, 'figures')
table_dir = os.path.join(project_dir, 'tables')
data_dir = os.path.join(project_dir, 'data')
''' ## Open the notes spreadsheet and parse for what we want to analyze ## '''
# open metadata file
data_notes = pd.read_csv(os.path.join(table_dir, 'OSN_Gg8vOMP.csv'))
# pull out cell_id for directory, file name, and make the full path
file_name_list = data_notes['Cell name'].tolist()
cell_id_list = []
for file in file_name_list:
file_split = file.split('_')
cell_id = file_split[0]+'_'+file_split[1]
cell_id_list.append(cell_id)
file_path_list = []
for cell, file in zip(cell_id_list, file_name_list):
file_path = os.path.join(cell, file + '.ibw')
file_path_list.append(file_path)
data_notes = pd.concat([pd.DataFrame({'File Path': file_path_list}), data_notes], axis=1)
# drop cells that didn't save to igor
noigor_list = np.array(data_notes[data_notes['Igor saved?'] == 'No'].index)
data_notes = data_notes.drop(index=noigor_list)
# drop cells that don't have any # of drug sweeps
nodrug_list = np.array(data_notes[data_notes['# of drug sweeps'].isnull() == True].index)
data_notes = data_notes.drop(index=nodrug_list)
# update file name list to have only files you want to analyze after logic
file_name_list = data_notes['Cell name'].tolist()
''' ##########################################################################
This is all the analysis, figures, saving
Read in file metadata, open file from igor, convert to pandas
##############################################################################
'''
# loop through all the files in file_name_list for plots and saving
for file_name in file_name_list:
# set file name from list
file = file_name
# gather metadata and set some key parameters for use later on in loop
metadata = get_metadata(file, data_notes)
file_path = metadata['Cell Path'][0]
cell_id = metadata['Cell ID'][0]
genotype = metadata['Genotype'][0]
exclude_start = metadata['Exclude Sweep Start'][0]
exclude_stop = metadata['Exclude Sweep Stop'][0]
# open igor file and convert to pandas
data = igor_to_pandas(file_path, data_dir)
# process logic and build exclude sweeps list from metadata, and exclude sweeps
if math.isnan(exclude_start) is False:
# need to pull out the end of the excluded sweeps
# if all sweeps after start are excluded
if math.isnan(exclude_stop) is True:
data = data.iloc[:, :int(exclude_start)]
# else only exclude traces in between start and stop
else:
begin = data.iloc[:, :int(exclude_start)]
end = data.iloc[:, int(exclude_stop):]
data = pd.concat([begin, end], axis=1)
else:
pass
'''
Pull out EPSC peak from unfiltered signals
Baseline 100 ms preceding blue light
Peak within 250 ms of blue light
'''
baseline = mean_baseline(data, 500)
peaks = epsc_peak(data, baseline, 500)
'''
Pull out EPSC peaks from filtered signals
Baseline 100 ms preceding blue light
Peak within 250 ms of blue light
'''
# filter signal with butterworth filter at 500 Hz for data
filt_data = elephant.signal_processing.butter(data.T,
lowpass_freq=500.0,
fs=10000.0)
filt_data = pd.DataFrame(filt_data).T
filt_baseline = mean_baseline(filt_data, 500)
filt_peaks = epsc_peak(filt_data, filt_baseline, 500)
''' Calculating Series Resistance (rs) from test pulse (tp) '''
rs = series_resistance(data, 50, -5)
''' Plot EPSC peaks and Rs over time of experiemnt '''
# set up index markers for data | drug line and drug stimuli
# pull out number of sweeps for both conditions and all
n_control_sweeps = len(peaks)
# set up auto y max for peak plots (min since negative)
y_min = peaks.min()
y_min_lim = y_min * 1.15 * 1000
# set up logic for Rs y scaling: if < 20 MOhms, don't scale, if > scale
if rs.max() <= 20:
rs_y_min = 0
rs_y_max = 20
else:
rs_y_min = rs.min() * 0.5
rs_y_max = rs.max() * 1.2
# make a figure with 2 plots
fig, axs = plt.subplots(2, 2, figsize=(6, 6), constrained_layout=True)
fig.suptitle('Summary for ' + genotype + ' ' + cell_id)
# optional for plotting unfiltered on same graph for comparison
axs[0, 0].plot(peaks*1000, marker='.', color='darkgray', linestyle='', label='raw')
# plot the filterd peak currents NOTE: convert peak values to pA
axs[0, 0].plot(filt_peaks*1000, color='k', marker='.', linestyle='', label='filtered')
axs[0, 0].set_xlabel('Stimulus Number')
axs[0, 0].set_ylabel('EPSC Peak (pA)')
| |
#!python
# Produces the set of factorial implementations (defined by models argument) from input RT-level model
# for given configuration of implementation flow (config.flow in the input configuration argument)
# Author: <NAME>, Universitat Politecnica de Valencia
import sys
import xml.etree.ElementTree as ET
import re
import os
import subprocess
import string
import copy
import glob
import shutil
import datetime
import time
from sys import platform
from multiprocessing import Process, Manager
from multiprocessing.managers import BaseManager
from subprocess import call
from Datamanager import *
sys.path.insert(0, os.path.join(os.getcwd(), './SupportScripts'))
import VendorSpecific
TIMEOUT_IMPL_PHASE = 2500
MAXCONSTRVAL = 220.0
def implement_model(config, model, adjust_constraints, stat, ForceReimplement = False):
os.chdir(config.design_genconf.design_dir)
if (not ForceReimplement) and (update_metrics(model) != None): return
if not os.path.exists(config.design_genconf.tool_log_dir):
os.makedirs(config.design_genconf.tool_log_dir)
log = open(os.path.join(config.design_genconf.tool_log_dir, model.Label+".log"), 'w')
log.write("\nImplementing: " + model.Label + ', started: ' + datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
if stat == None: stat = ProcStatus('Config')
if not 'EvalTime' in model.Metrics: model.Metrics['EvalTime'] = dict()
if not isinstance(model.Metrics['EvalTime'], dict): model.Metrics['EvalTime'] = dict()
for k,v in model.Metrics['EvalTime'].iteritems():
stat.update(str(k), '{} sec'.format(v), 'ok')
if model.ModelPath == '': model.ModelPath = os.path.join(config.design_genconf.design_dir, model.Label)
#If this configuration has not been implemented previously - implement it, retrieve the results, update statistics for monitoring interface
if ForceReimplement:
if os.path.exists(model.ModelPath):
try:
# #backup_script = 'zip -r {0}_BACKUP {1} > {2}/ziplog_{3}.log'.format(model.Label, cleanup_path(get_relative_path(os.getcwd(), model.ModelPath)), config.design_genconf.tool_log_dir, model.Label)
# #proc = subprocess.Popen(backup_script, shell=True)
# #print('Running backup of previous results: {0}'.format(backup_script))
# #proc.wait()
shutil.rmtree(model.ModelPath)
except e:
print(str(e))
if not os.path.exists(model.ModelPath):
shutil.copytree(os.path.join(config.design_genconf.design_dir, config.design_genconf.template_dir), model.ModelPath)
os.chdir(model.ModelPath)
print("Started Process [" + model.Label + "], workdir: " + os.getcwd())
if not os.path.exists(config.design_genconf.log_dir):
os.makedirs(config.design_genconf.log_dir)
constraint_template = ''
all_constraints = [p.constraint_to_adjust for p in config.flow.get_phase_chain() if p.constraint_to_adjust!=None]
for c in all_constraints:
c.current_value = c.start_value
if os.path.exists(config.design_genconf.constraint_file):
with open(config.design_genconf.constraint_file, 'r') as f:
constraint_template = f.read()
implentability_checked, impl_test = False, False
phase = config.flow.entry_phase
while phase != None:
stat.update('Progress', phase.name, 'wait')
stat.update(phase.name, 'In progress', 'wait')
#update constraint file if any contraint defined
if len(phase.constraints_to_export) > 0:
constraint_content = constraint_template
for ce in all_constraints:
constraint_content = constraint_content.replace(ce.placeholder, str(ce.current_value))
stat.update('Iteration', ce.iteration, 'ok')
ce.iteration += 1
if ce.iteration > 14:
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
phase = None
log.write('\n{0}\tImplementation failed: too many iterations (hang detected)'.format(str(datetime.datetime.now().replace(microsecond=0))))
stat.update('Progress', 'Error', 'err')
model.serialize(SerializationFormats.XML, model.std_dumpfile_name)
return
if os.path.exists(config.design_genconf.constraint_file):
with open(config.design_genconf.constraint_file, 'w') as f:
f.write(constraint_content)
completed = False
attempt = 0
while not completed:
attempt+=1
script = getattr(VendorSpecific, phase.script_builder)(phase, config, model)
timestart = datetime.datetime.now().replace(microsecond=0)
start_t = time.time()
log.write('\n{0}\tStarting: {1}, attempt: {2}, script: {{{3}}}'.format(str(timestart), phase.name, attempt, script))
log.flush()
proc = subprocess.Popen(script, shell=True)
time.sleep(1)
while (proc.poll() == None) and (time.time() - start_t < TIMEOUT_IMPL_PHASE):
time.sleep(1)
if proc.poll() == None:
log.write('\n{0}\tTimeout: {1}, attempt: {2}, script: {{{3}}}'.format(str(datetime.datetime.now().replace(microsecond=0)), phase.name, attempt, script))
log.flush()
proc.kill()
success = False
else:
success = getattr(VendorSpecific, phase.postcondition_handler)(phase, config, model)
timetaken = datetime.datetime.now().replace(microsecond=0) - timestart
if success:
if not phase.name in model.Metrics['EvalTime']:
model.Metrics['EvalTime'][phase.name] = int(time_to_seconds(timetaken))
else:
model.Metrics['EvalTime'][phase.name] += int(time_to_seconds(timetaken))
stat.update(phase.name, '{} sec'.format(model.Metrics['EvalTime'][phase.name]), 'ok')
completed = True
else:
if attempt > config.retry_attempts:
#report an error and stop
stat.update(phase.name, 'Error', 'err')
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
model.serialize(SerializationFormats.XML, model.std_dumpfile_name)
log.write("\nPostcondition/Timeout error at {0}: , exiting".format(phase.name) )
log.close()
phase = None
return
res = getattr(VendorSpecific, phase.result_handler)(phase, config, model)
if not 'Implprop' in model.Metrics: model.Metrics['Implprop'] = dict()
if not isinstance(model.Metrics['Implprop'], dict): model.Metrics['Implprop'] = dict()
for k, v in res.iteritems():
model.Metrics['Implprop'][k] = v
stat.update(k, str(v), 'res')
if adjust_constraints and phase.constraint_to_adjust != None:
satisfied = getattr(VendorSpecific, phase.constraint_to_adjust.check_handler)(phase, config, model)
if satisfied:
implentability_checked = True
if impl_test:
impl_test == False
phase.constraint_to_adjust.current_value = saved_constraint
log.write('\n{0}\tImplementation test passed'.format(str(timestart)))
if phase.constraint_to_adjust.converged:
phase = phase.next
else:
#strengthen the constraint until not satisfied
if phase.constraint_to_adjust.goal == AdjustGoal.min:
phase.constraint_to_adjust.current_value -= phase.constraint_to_adjust.adjust_step
elif phase.constraint_to_adjust.goal == AdjustGoal.max:
phase.constraint_to_adjust.current_value += phase.constraint_to_adjust.adjust_step
if phase.constraint_to_adjust.current_value > MAXCONSTRVAL:
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
phase = None
break
log.write('\n{0}\tConstraint adjusted: {1} = {2}'.format(str(timestart), phase.constraint_to_adjust.placeholder, phase.constraint_to_adjust.current_value))
if phase.constraint_to_adjust.current_value <= 0:
#mask config as non implementable and exit
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
completed = True
phase = None
break
phase = phase.constraint_to_adjust.return_to_phase
else:
if (not implentability_checked) and phase.constraint_to_adjust.goal == AdjustGoal.max:
if impl_test:
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
completed = True
phase = None
log.write('\n{0}\tImplementation test failed'.format(str(timestart)))
break
else:
saved_constraint = phase.constraint_to_adjust.current_value - phase.constraint_to_adjust.adjust_step
phase.constraint_to_adjust.current_value = 2.0
impl_test = True
phase = phase.constraint_to_adjust.return_to_phase
log.write('\n{0}\tImplementation test started'.format(str(timestart)))
else:
#once not satisfied - converged
phase.constraint_to_adjust.converged = True
#relax the constraint until satisfied
if phase.constraint_to_adjust.goal == AdjustGoal.min:
phase.constraint_to_adjust.current_value += phase.constraint_to_adjust.adjust_step
if phase.constraint_to_adjust.current_value > MAXCONSTRVAL:
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
phase = None
break
elif phase.constraint_to_adjust.goal == AdjustGoal.max:
phase.constraint_to_adjust.current_value -= phase.constraint_to_adjust.adjust_step
if phase.constraint_to_adjust.current_value <= 0:
#mask config as non implementable and exit
model.Metrics['Implprop']['Error'] = 'ImplError'
model.Metrics['Error']='ImplError'
completed = True
phase = None
break
log.write('\n{0}\tConstraint adjusted: {1} = {2}'.format(str(timestart), phase.constraint_to_adjust.placeholder, phase.constraint_to_adjust.current_value))
phase = phase.constraint_to_adjust.return_to_phase
else:
phase = phase.next
model.serialize(SerializationFormats.XML, model.std_dumpfile_name)
stat.update('Progress', 'Completed', 'ok')
log.close()
def power_simulation(dut, davosconf):
os.chdir(davosconf.ExperimentalDesignConfig.design_genconf.design_dir)
dut.ModelPath = os.path.join(davosconf.ExperimentalDesignConfig.design_genconf.design_dir, dut.Label)
if not os.path.exists(dut.ModelPath):
print('power_simulation: path {0} not found, skipping {1}'.format(dut.ModelPath, dut.Label))
return()
if os.path.exists( os.path.join(dut.ModelPath,'pwr.log') ):
print('Activity file exists for config {0}, skipping simulation step'.format(dut.Label))
else:
print('Simulating switching activity for config {0}'.format(dut.Label))
workloadcyles = 14500
clockperiod = 1000.0/dut.Metrics['Implprop']['FREQUENCY']
with open(os.path.join(davosconf.ExperimentalDesignConfig.design_genconf.design_dir, davosconf.ExperimentalDesignConfig.design_genconf.template_dir, 'TbTop.v'), 'r') as src, open(os.path.join(dut.ModelPath, 'TbTop.v'), 'w') as dst:
content = src.read()
for k,v in {'#CLOCKPERIOD' : '{0:.3f}'.format(clockperiod)}.iteritems(): content=content.replace(k,v)
dst.write(content)
with open(os.path.join(davosconf.ExperimentalDesignConfig.design_genconf.design_dir, davosconf.ExperimentalDesignConfig.design_genconf.template_dir, 'simrun.do'), 'r') as src, open(os.path.join(dut.ModelPath, 'simrun.do'), 'w') as dst:
content = src.read()
for k,v in {'#PATH':dut.ModelPath.replace("\\","/"), '#WORKLOADTIME':'{0:d}ns'.format(int(workloadcyles*clockperiod))}.iteritems(): content=content.replace(k,v)
dst.write(content)
with open(os.path.join(davosconf.ExperimentalDesignConfig.design_genconf.design_dir, davosconf.ExperimentalDesignConfig.design_genconf.template_dir, 'pwrsim.do'), 'r') as src, open(os.path.join(dut.ModelPath, 'pwrsim.do'), 'w') as dst:
content = src.read()
for k,v in {'#PATH':dut.ModelPath.replace("\\","/"), '#WORKLOADTIME':'{0:d}ns'.format(int(workloadcyles*clockperiod))}.iteritems(): content=content.replace(k,v)
dst.write(content)
os.chdir(dut.ModelPath)
start_t = time.time()
script='vivado -mode batch -source {0} > {1} 2> {2}'.format(os.path.join(dut.ModelPath, 'pwrsim.do'), davosconf.ExperimentalDesignConfig.design_genconf.log_dir + '/powersim.log', davosconf.ExperimentalDesignConfig.design_genconf.log_dir + '/powersim.err')
proc = subprocess.Popen(script, shell=True)
time.sleep(1)
while (proc.poll() == None) and (time.time() - start_t < 2000):
time.sleep(1)
if proc.poll() == None:
proc.kill()
print('power_simulation : TIMEOUT DUT: {0}'.format(dut.Label))
dut.Metrics['Implprop']['POWER_PL'] = 0.0
return()
#check and fix swithing activity file
with open(os.path.join(dut.ModelPath,'pwrsim.saif'),'r') as f:
content = f.read()
#content = content.replace('(INSTANCE TbTop', ' (INSTANCE design_1_wrapper\n\t\t(INSTANCE design_1_i') + ')'
content = content.replace('(INSTANCE TbTop', ' (INSTANCE ZynqEnv_wrapper\n\t\t(INSTANCE ZynqEnv_i') + ')'
with open(os.path.join(dut.ModelPath,'pwrsim.saif'),'w') as f:
f.write(content)
script = """open_project AVR_ZC.xpr
open_run [get_runs {1}]
read_saif {{{0}/pwrsim.saif}} -strip_path ZynqEnv_wrapper -out_file rds.log
report_power -file {0}/pwr.log
""".format(dut.ModelPath, 'ImplementationPhase')
proc = subprocess.Popen('vivado -mode tcl'.format(), stdin=subprocess.PIPE, stdout=subprocess.PIPE , shell=True)
out, err = proc.communicate(script.replace('\\','/').encode())
with open(os.path.join(dut.ModelPath, 'pwr.log'), 'r') as f:
content = f.read()
dut.Metrics['Implprop']['POWER_DYNAMIC'] = float(re.findall("Dynamic \(W\).*?([0-9\.]+)", content)[0])
dut.Metrics['Implprop']['POWER_PL'] = float(re.findall(davosconf.ExperimentalDesignConfig.design_genconf.uut_root+".*?([0-9\.]+)", content)[0])
shutil.rmtree(os.path.join(dut.ModelPath, 'AVR_ZC.sim', 'sim_1'), ignore_errors=True, onerror=None)
print('Power simulated for {0}: {1:.4f} W'.format(dut.Label, dut.Metrics['Implprop']['POWER_PL']))
#returns dictionary dict[config_label] = (process_id=None, model_descriptor, statistic_descriptor)
#read from file statfile (xml)
def recover_statistics(model_list, statfile, recover_state = True):
procdict = dict()
recover_stat_tree = None
if recover_state and os.path.exists(statfile):
recover_stat_tree = ET.parse(statfile).getroot()
for i in model_list:
stat = ProcStatus('Config')
if(recover_stat_tree is not None):
stat.from_xml(recover_stat_tree, 'Config', 'Label', i.Label)
procdict[i.Label] = (None, i, stat)
stat.update('Label', i.Label,'')
return(procdict)
def proclist_stat(proclist):
active_proc = 0
finished_proc = 0
for p in proclist:
if p[0] != None:
if(p[0].is_alive()):
active_proc += 1
else:
finished_proc += 1
return(active_proc, finished_proc)
def allocate_gui_local(config):
os.chdir(config.design_genconf.design_dir)
copy_all_files(os.path.join(config.call_dir,'UserInterface/IMPL'), config.design_genconf.design_dir)
copy_all_files(os.path.join(config.call_dir,'UserInterface/libs'), os.path.join(config.design_genconf.design_dir, 'libs'))
with open(os.path.join(config.design_genconf.design_dir, 'Monitoring.js'), 'r') as f:
content = f.read()
content = content.replace('#FULLSTAT', '\'{0}\''.format(config.statfile)).replace('#MINSTAT', '\'{0}\''.format(config.statfile.replace('.xml','_min.xml')))
theaders = ['Label']
tlogdesc = ['./Logs/@.log']
for c in VendorSpecific.GetResultLabels():
theaders.append(c)
tlogdesc.append('./Logs/@.log')
theaders.append('Progress')
tlogdesc.append('./Logs/@.log')
theaders.append('Iteration')
tlogdesc.append('./Logs/@.log')
for p in config.flow.get_phase_chain():
theaders.append(p.name)
tlogdesc.append('./@/{0}/{1}'.format(config.design_genconf.log_dir, p.logfile))
content = content.replace('#THEADERS', '[{0}]'.format(', '.join(['\'{0}\''.format(c) for c in theaders])))
content = content.replace('#LOGDESC', '[{0}]'.format(', '.join(['\'{0}\''.format(c) for c in tlogdesc])))
content = content.replace('#GLOBALHEADERS', "['Phase', 'Progress', 'Time_Taken', 'Report']")
with open(os.path.join(config.design_genconf.design_dir, 'Monitoring.js'), 'w') as f:
f.write(content)
#Launch monitoring interface
try:
if platform == 'linux' or platform == 'linux2':
subprocess.check_output('xdg-open ' + os.path.join(config.call_dir, config.design_genconf.design_dir, 'Monitoring.html > ./dummylog.txt'), shell=True)
elif platform == 'cygwin':
subprocess.check_output('cygstart ' + os.path.join(config.call_dir, config.design_genconf.design_dir, 'Monitoring.html > ./dummylog.txt'), shell=True)
elif platform == 'win32' or platform == 'win64':
subprocess.check_output('start ' + os.path.join(config.call_dir, config.design_genconf.design_dir, 'Monitoring.html > ./dummylog.txt'), shell=True)
except subprocess.CalledProcessError as e:
print e.output
def update_metrics(m):
if os.path.isfile(os.path.join(m.ModelPath, HDLModelDescriptor.std_dumpfile_name)):
tag = ET.parse(os.path.join(m.ModelPath, HDLModelDescriptor.std_dumpfile_name)).getroot()
res = HDLModelDescriptor.deserialize(SerializationFormats.XML, tag).Metrics
for k, v in res.iteritems():
m.Metrics[k] = v
return(m.Metrics)
else:
return(None)
def export_results(models, dir):
with open(os.path.join(dir, 'IMPLEMENTATION_RESULTS.xml'), 'w') as f:
f.write('<?xml version="1.0"?>\n<data>\n{0}\n</data>'.format('\n\n'.join([m.serialize(SerializationFormats.XML) for m in models])))
with open(os.path.join(dir, 'IMPLEMENTATION_SUMMARY.xml'), 'w') as f:
f.write('<?xml version="1.0"?>\n<data>\n{0}\n</data>'.format('\n\n'.join([m.log_xml() for m in models])))
def build_summary_page(models, fname):
spage = HtmlPage('Summary')
spage.css_file = 'markupstyle.css'
T = Table('Summary')
T.add_column('Label')
factors = []
for f in models[0].Factors:
factors.append(f.FactorName)
T.add_column(f.FactorName)
for i in range(len(models)):
T.add_row()
T.put(i,0, str(models[i].Label))
for f in range(len(factors)):
| |
insert_xforwarded_for: Optional[pulumi.Input[str]] = None,
lws_separator: Optional[pulumi.Input[str]] = None,
lws_width: Optional[pulumi.Input[int]] = None,
name: Optional[pulumi.Input[str]] = None,
oneconnect_transformations: Optional[pulumi.Input[str]] = None,
proxy_type: Optional[pulumi.Input[str]] = None,
redirect_rewrite: Optional[pulumi.Input[str]] = None,
request_chunking: Optional[pulumi.Input[str]] = None,
response_chunking: Optional[pulumi.Input[str]] = None,
response_headers_permitteds: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
server_agent_name: Optional[pulumi.Input[str]] = None,
tm_partition: Optional[pulumi.Input[str]] = None,
via_host_name: Optional[pulumi.Input[str]] = None,
via_request: Optional[pulumi.Input[str]] = None,
via_response: Optional[pulumi.Input[str]] = None,
xff_alternative_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'ProfileHttp':
"""
Get an existing ProfileHttp resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] accept_xff: Enables or disables trusting the client IP address, and statistics from the client IP address, based on the request's XFF (X-forwarded-for) headers, if they exist.
:param pulumi.Input[str] app_service: The application service to which the object belongs.
:param pulumi.Input[str] basic_auth_realm: Specifies a quoted string for the basic authentication realm. The system sends this string to a client whenever authorization fails. The default value is `none`
:param pulumi.Input[str] defaults_from: Specifies the profile that you want to use as the parent profile. Your new profile inherits all settings and values from the parent profile specified.
:param pulumi.Input[str] description: Specifies user-defined description.
:param pulumi.Input[str] encrypt_cookie_secret: Type a passphrase for cookie encryption.
:param pulumi.Input[Sequence[pulumi.Input[str]]] encrypt_cookies: Type the cookie names for the system to encrypt.
:param pulumi.Input[str] fallback_host: Specifies an HTTP fallback host. HTTP redirection allows you to redirect HTTP traffic to another protocol identifier, host name, port number
:param pulumi.Input[Sequence[pulumi.Input[str]]] fallback_status_codes: Specifies one or more three-digit status codes that can be returned by an HTTP server,that should trigger a redirection to the fallback host.
:param pulumi.Input[str] head_erase: Specifies the header string that you want to erase from an HTTP request. Default is `none`.
:param pulumi.Input[str] head_insert: Specifies a quoted header string that you want to insert into an HTTP request.Default is `none`.
:param pulumi.Input[str] insert_xforwarded_for: Specifies, when enabled, that the system inserts an X-Forwarded-For header in an HTTP request with the client IP address, to use with connection pooling. The default is `Disabled`.
:param pulumi.Input[str] lws_separator: Specifies the linear white space (LWS) separator that the system inserts when a header exceeds the maximum width you
specify in the LWS Maximum Columns setting.
:param pulumi.Input[int] lws_width: Specifies the linear white space (LWS) separator that the system inserts when a header exceeds the maximum width you specify in the LWS Maximum Columns setting.
:param pulumi.Input[str] name: Specifies the name of the http profile,name of Profile should be full path. Full path is the combination of the `partition + profile name`,For example `/Common/test-http-profile`.
:param pulumi.Input[str] oneconnect_transformations: Enables the system to perform HTTP header transformations for the purpose of keeping server-side connections open. This feature requires configuration of a OneConnect profile
:param pulumi.Input[str] proxy_type: Specifies the proxy mode for this profile: reverse, explicit, or transparent. The default is `reverse`.
:param pulumi.Input[str] redirect_rewrite: Specifies whether the system rewrites the URIs that are part of HTTP redirect (3XX) responses. The default is `none`.
:param pulumi.Input[str] request_chunking: Specifies how the system handles HTTP content that is chunked by a client. The default is `preserve`.
:param pulumi.Input[str] response_chunking: Specifies how the system handles HTTP content that is chunked by a server. The default is `selective`.
:param pulumi.Input[Sequence[pulumi.Input[str]]] response_headers_permitteds: Specifies headers that the BIG-IP system allows in an HTTP response.If you are specifying more than one header, separate the headers with a blank space.
:param pulumi.Input[str] server_agent_name: Specifies the value of the Server header in responses that the BIG-IP itself generates. The default is BigIP. If no
string is specified, then no Server header will be added to such responses
:param pulumi.Input[str] tm_partition: Displays the administrative partition within which this profile resides.
:param pulumi.Input[str] via_host_name: Specifies the hostname to include into Via header
:param pulumi.Input[str] via_request: Specifies whether to append, remove, or preserve a Via header in an HTTP request
:param pulumi.Input[str] via_response: Specifies whether to append, remove, or preserve a Via header in an HTTP request
:param pulumi.Input[Sequence[pulumi.Input[str]]] xff_alternative_names: Specifies alternative XFF headers instead of the default X-forwarded-for header.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = _ProfileHttpState.__new__(_ProfileHttpState)
__props__.__dict__["accept_xff"] = accept_xff
__props__.__dict__["app_service"] = app_service
__props__.__dict__["basic_auth_realm"] = basic_auth_realm
__props__.__dict__["defaults_from"] = defaults_from
__props__.__dict__["description"] = description
__props__.__dict__["encrypt_cookie_secret"] = encrypt_cookie_secret
__props__.__dict__["encrypt_cookies"] = encrypt_cookies
__props__.__dict__["fallback_host"] = fallback_host
__props__.__dict__["fallback_status_codes"] = fallback_status_codes
__props__.__dict__["head_erase"] = head_erase
__props__.__dict__["head_insert"] = head_insert
__props__.__dict__["insert_xforwarded_for"] = insert_xforwarded_for
__props__.__dict__["lws_separator"] = lws_separator
__props__.__dict__["lws_width"] = lws_width
__props__.__dict__["name"] = name
__props__.__dict__["oneconnect_transformations"] = oneconnect_transformations
__props__.__dict__["proxy_type"] = proxy_type
__props__.__dict__["redirect_rewrite"] = redirect_rewrite
__props__.__dict__["request_chunking"] = request_chunking
__props__.__dict__["response_chunking"] = response_chunking
__props__.__dict__["response_headers_permitteds"] = response_headers_permitteds
__props__.__dict__["server_agent_name"] = server_agent_name
__props__.__dict__["tm_partition"] = tm_partition
__props__.__dict__["via_host_name"] = via_host_name
__props__.__dict__["via_request"] = via_request
__props__.__dict__["via_response"] = via_response
__props__.__dict__["xff_alternative_names"] = xff_alternative_names
return ProfileHttp(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="acceptXff")
def accept_xff(self) -> pulumi.Output[str]:
"""
Enables or disables trusting the client IP address, and statistics from the client IP address, based on the request's XFF (X-forwarded-for) headers, if they exist.
"""
return pulumi.get(self, "accept_xff")
@property
@pulumi.getter(name="appService")
def app_service(self) -> pulumi.Output[Optional[str]]:
"""
The application service to which the object belongs.
"""
return pulumi.get(self, "app_service")
@property
@pulumi.getter(name="basicAuthRealm")
def basic_auth_realm(self) -> pulumi.Output[str]:
"""
Specifies a quoted string for the basic authentication realm. The system sends this string to a client whenever authorization fails. The default value is `none`
"""
return pulumi.get(self, "basic_auth_realm")
@property
@pulumi.getter(name="defaultsFrom")
def defaults_from(self) -> pulumi.Output[str]:
"""
Specifies the profile that you want to use as the parent profile. Your new profile inherits all settings and values from the parent profile specified.
"""
return pulumi.get(self, "defaults_from")
@property
@pulumi.getter
def description(self) -> pulumi.Output[str]:
"""
Specifies user-defined description.
"""
return pulumi.get(self, "description")
@property
@pulumi.getter(name="encryptCookieSecret")
def encrypt_cookie_secret(self) -> pulumi.Output[Optional[str]]:
"""
Type a passphrase for cookie encryption.
"""
return pulumi.get(self, "encrypt_cookie_secret")
@property
@pulumi.getter(name="encryptCookies")
def encrypt_cookies(self) -> pulumi.Output[Optional[Sequence[str]]]:
"""
Type the cookie names for the system to encrypt.
"""
return pulumi.get(self, "encrypt_cookies")
@property
@pulumi.getter(name="fallbackHost")
def fallback_host(self) -> pulumi.Output[str]:
"""
Specifies an HTTP fallback host. HTTP redirection allows you to redirect HTTP traffic to another protocol identifier, host name, port number
"""
return pulumi.get(self, "fallback_host")
@property
@pulumi.getter(name="fallbackStatusCodes")
def fallback_status_codes(self) -> pulumi.Output[Optional[Sequence[str]]]:
"""
Specifies one or more three-digit status codes that can be returned by an HTTP server,that should trigger a redirection to the fallback host.
"""
return pulumi.get(self, "fallback_status_codes")
@property
@pulumi.getter(name="headErase")
def head_erase(self) -> pulumi.Output[str]:
"""
Specifies the header string that you want to erase from an HTTP request. Default is `none`.
"""
return pulumi.get(self, "head_erase")
@property
@pulumi.getter(name="headInsert")
def head_insert(self) -> pulumi.Output[str]:
"""
Specifies a quoted header string that you want to insert into an HTTP request.Default is `none`.
"""
return pulumi.get(self, "head_insert")
@property
@pulumi.getter(name="insertXforwardedFor")
def insert_xforwarded_for(self) -> pulumi.Output[str]:
"""
Specifies, when enabled, that the system inserts an X-Forwarded-For header in an HTTP request with the client IP address, to use with connection pooling. The default is `Disabled`.
"""
return pulumi.get(self, "insert_xforwarded_for")
@property
@pulumi.getter(name="lwsSeparator")
def lws_separator(self) -> pulumi.Output[str]:
"""
Specifies the linear white space (LWS) separator that the system inserts when a header exceeds the maximum width you
specify in the LWS Maximum Columns setting.
"""
return pulumi.get(self, "lws_separator")
@property
@pulumi.getter(name="lwsWidth")
def lws_width(self) -> pulumi.Output[int]:
"""
Specifies the linear white space (LWS) separator that the system inserts when a header exceeds the maximum width you specify in the LWS Maximum Columns setting.
"""
return pulumi.get(self, "lws_width")
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
"""
Specifies the name of the http profile,name of Profile should be full path. Full path is the combination of the `partition + profile name`,For example `/Common/test-http-profile`.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter(name="oneconnectTransformations")
def oneconnect_transformations(self) -> pulumi.Output[str]:
"""
Enables the system to perform HTTP header transformations for the purpose of keeping server-side connections open. This feature requires configuration of a OneConnect profile
"""
return pulumi.get(self, "oneconnect_transformations")
@property
@pulumi.getter(name="proxyType")
def proxy_type(self) -> pulumi.Output[str]:
"""
Specifies the proxy mode for this profile: reverse, explicit, or transparent. The | |
<gh_stars>0
from __future__ import annotations
import datetime as _datetime
import logging as _logging
import os
import pathlib
import re
from contextlib import contextmanager
from dataclasses import dataclass
from enum import Enum
from typing import Any, Dict, Generator, List, Optional
from flytekit.clients import friendly as friendly_client # noqa
from flytekit.common.core.identifier import WorkflowExecutionIdentifier as _SdkWorkflowExecutionIdentifier
from flytekit.common.tasks.sdk_runnable import ExecutionParameters
from flytekit.configuration import images, internal
from flytekit.configuration import sdk as _sdk_config
from flytekit.engines.unit import mock_stats as _mock_stats
from flytekit.interfaces.data import data_proxy as _data_proxy
from flytekit.models.core import identifier as _identifier
_DEFAULT_FLYTEKIT_ENTRYPOINT_FILELOC = "bin/entrypoint.py"
@dataclass(init=True, repr=True, eq=True, frozen=True)
class Image(object):
name: str
fqn: str
tag: str
@dataclass(init=True, repr=True, eq=True, frozen=True)
class ImageConfig(object):
default_image: Image
images: List[Image] = None
def find_image(self, name) -> Optional[Image]:
for i in self.images:
if i.name == name:
return i
return None
_IMAGE_FQN_TAG_REGEX = re.compile(r"([^:]+)(?=:.+)?")
def look_up_image_info(name: str, tag: str, optional_tag: bool = False) -> Image:
"""
Looks up the image tag from environment variable (should be set from the Dockerfile).
FLYTE_INTERNAL_IMAGE should be the environment variable.
This function is used when registering tasks/workflows with Admin.
When using the canonical Python-based development cycle, the version that is used to register workflows
and tasks with Admin should be the version of the image itself, which should ideally be something unique
like the sha of the latest commit.
:param optional_tag:
:param name:
:param Text tag: e.g. somedocker.com/myimage:someversion123
:rtype: Text
"""
if tag is None or tag == "":
raise Exception("Bad input for image tag {}".format(tag))
matches = _IMAGE_FQN_TAG_REGEX.findall(tag)
if matches is not None:
if len(matches) == 1 and optional_tag:
return Image(name=name, fqn=matches[0], tag=None)
elif len(matches) == 2:
return Image(name=name, fqn=matches[0], tag=matches[1])
else:
raise AssertionError(f"Incorrectly formatted image {tag}, missing tag value")
raise Exception("Could not parse given image and version from configuration.")
def get_image_config(img_name: str = None) -> ImageConfig:
image_name = img_name if img_name else internal.IMAGE.get()
default_img = look_up_image_info("default", image_name)
other_images = [look_up_image_info(k, tag=v, optional_tag=True) for k, v in images.get_specified_images().items()]
other_images.append(default_img)
return ImageConfig(default_image=default_img, images=other_images)
@dataclass
class InstanceVar(object):
module: str
name: str
o: Any
@dataclass
class EntrypointSettings(object):
path: str = None
command: str = None
version: int = 0
class SerializationSettings(object):
def __init__(
self,
project: str,
domain: str,
version: str,
image_config: ImageConfig,
env: Optional[Dict[str, str]],
flytekit_virtualenv_root: str = None,
entrypoint_settings: EntrypointSettings = None,
):
self._project = project
self._domain = domain
self._version = version
self._image_config = image_config
self._env = env or {}
self._instance_lookup = {}
self._flytekit_virtualenv_root = flytekit_virtualenv_root
self._entrypoint_settings = entrypoint_settings
@property
def project(self) -> str:
return self._project
@property
def domain(self) -> str:
return self._domain
@property
def version(self) -> str:
return self._version
@property
def image_config(self) -> ImageConfig:
return self._image_config
@property
def env(self) -> Dict[str, str]:
return self._env
@property
def flytekit_virtualenv_root(self) -> str:
return self._flytekit_virtualenv_root
@property
def entrypoint_settings(self) -> EntrypointSettings:
return self._entrypoint_settings
def add_instance_var(self, var: InstanceVar):
self._instance_lookup[var.o] = var
def get_instance_var(self, o: Any) -> InstanceVar:
if o in self._instance_lookup:
return self._instance_lookup[o]
raise KeyError(f"Instance Variable not found for object id {o}")
class CompilationState(object):
def __init__(self, prefix: str):
"""
:param prefix: This is because we may one day want to be able to have subworkflows inside other workflows. If
users choose to not specify their node names, then we can end up with multiple "n0"s. This prefix allows
us to give those nested nodes a distinct name, as well as properly identify them in the workflow.
# TODO: Ketan to revisit this whole concept when we re-organize the new structure
"""
from flytekit.annotated.node import Node
self._nodes: List[Node] = []
self._old_prefix = ""
self._prefix = prefix
self.mode = 1 # TODO: Turn into enum in the future, or remove if only one mode.
# TODO Branch mode should just be a new Compilation state context. But for now we are just
# storing the nodes separately
self._branch = False
self._branch_nodes: List[Node] = []
@property
def prefix(self) -> str:
return self._prefix
def add_node(self, n: Node):
if self._branch:
self._branch_nodes.append(n)
else:
self._nodes.append(n)
@property
def nodes(self):
if self._branch:
return self._branch_nodes
return self._nodes
def enter_conditional_section(self):
"""
We cannot use a context manager here, so we will mimic the context manager API
"""
self._branch = True
self._old_prefix = self._prefix
self._prefix = self._prefix + "branch"
def exit_conditional_section(self):
"""
Disables that we are in a branch
"""
self._branch = False
self._branch_nodes = []
self._prefix = self._old_prefix
def is_in_a_branch(self) -> bool:
return self._branch
class BranchEvalMode(Enum):
BRANCH_ACTIVE = "branch active"
BRANCH_SKIPPED = "branch skipped"
class ExecutionState(object):
class Mode(Enum):
# This is the mode that is used when a task execution mimics the actual runtime environment.
# NOTE: This is important to understand the difference between TASK_EXECUTION and LOCAL_TASK_EXECUTION
# LOCAL_TASK_EXECUTION, is the mode that is run purely locally and in some cases the difference between local
# and runtime environment may be different. For example for Dynamic tasks local_task_execution will just run it
# as a regular function, while task_execution will extract a runtime spec
TASK_EXECUTION = 1
# This represents when flytekit is locally running a workflow. The behavior of tasks differs in this case
# because instead of running a task's user defined function directly, it'll need to wrap the return values in
# NodeOutput
LOCAL_WORKFLOW_EXECUTION = 2
# This is the mode that is used to to indicate a purely local task execution - i.e. running without a container
# or propeller.
LOCAL_TASK_EXECUTION = 3
def __init__(
self, mode: Mode, working_dir: os.PathLike, engine_dir: os.PathLike, additional_context: Dict[Any, Any] = None
):
self._mode = mode
self._working_dir = working_dir
self._engine_dir = engine_dir
self._additional_context = additional_context
self._branch_eval_mode = None
@property
def working_dir(self) -> os.PathLike:
return self._working_dir
@property
def engine_dir(self) -> os.PathLike:
return self._engine_dir
@property
def additional_context(self) -> Dict[Any, Any]:
return self._additional_context
@property
def mode(self) -> Mode:
return self._mode
@property
def branch_eval_mode(self) -> Optional[BranchEvalMode]:
return self._branch_eval_mode
def enter_conditional_section(self):
"""
We cannot use a context manager here, so we will mimic the context manager API
Reason we cannot use is because branch is a functional api and the context block is not well defined
TODO we might want to create a new node manager here, as we want to capture all nodes in this branch
context
"""
self._branch_eval_mode = BranchEvalMode.BRANCH_SKIPPED
def take_branch(self):
"""
Indicates that we are within an if-else block and the current branch has evaluated to true.
Useful only in local execution mode
"""
self._branch_eval_mode = BranchEvalMode.BRANCH_ACTIVE
def branch_complete(self):
"""
Indicates that we are within a conditional / ifelse block and the active branch is not done.
Default to SKIPPED
"""
self._branch_eval_mode = BranchEvalMode.BRANCH_SKIPPED
def exit_conditional_section(self):
"""
Removes any current branch logic
"""
self._branch_eval_mode = None
class FlyteContext(object):
OBJS = []
def __init__(
self,
parent=None,
file_access: _data_proxy.FileAccessProvider = None,
compilation_state: CompilationState = None,
execution_state: ExecutionState = None,
flyte_client: friendly_client.SynchronousFlyteClient = None,
user_space_params: ExecutionParameters = None,
serialization_settings: SerializationSettings = None,
):
# TODO: Should we have this auto-parenting feature?
if parent is None and len(FlyteContext.OBJS) > 0:
parent = FlyteContext.OBJS[-1]
if compilation_state is not None and execution_state is not None:
raise Exception("Can't specify both")
self._parent: FlyteContext = parent
self._file_access = file_access
self._compilation_state = compilation_state
self._execution_state = execution_state
self._flyte_client = flyte_client
self._user_space_params = user_space_params
self._serialization_settings = serialization_settings
def __enter__(self):
# Should we auto-assign the parent here?
# Or detect if self's parent is not [-1]?
FlyteContext.OBJS.append(self)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
FlyteContext.OBJS.pop()
@classmethod
def current_context(cls) -> FlyteContext:
if len(cls.OBJS) == 0:
raise Exception("There should pretty much always be a base context object.")
return cls.OBJS[-1]
@property
def file_access(self) -> _data_proxy.FileAccessProvider:
if self._file_access is not None:
return self._file_access
elif self._parent is not None:
return self._parent.file_access
else:
raise Exception("No file_access initialized")
@contextmanager
def new_file_access_context(self, file_access_provider: _data_proxy.FileAccessProvider):
new_ctx = FlyteContext(parent=self, file_access=file_access_provider)
FlyteContext.OBJS.append(new_ctx)
try:
yield new_ctx
finally:
FlyteContext.OBJS.pop()
@property
def user_space_params(self) -> Optional[ExecutionParameters]:
if self._user_space_params is not None:
return self._user_space_params
elif self._parent is not None:
return self._parent.user_space_params
else:
raise Exception("No user_space_params initialized")
@property
def execution_state(self) -> Optional[ExecutionState]:
return self._execution_state
@contextmanager
def new_execution_context(
self,
mode: ExecutionState.Mode,
additional_context: Dict[Any, Any] = None,
execution_params: Optional[ExecutionParameters] = None,
working_dir: Optional[str] = None,
) -> Generator[FlyteContext, None, None]:
# Create a working directory for the execution to use
working_dir = working_dir or self.file_access.get_random_local_directory()
engine_dir = os.path.join(working_dir, "engine_dir")
pathlib.Path(engine_dir).mkdir(parents=True, exist_ok=True)
exec_state = ExecutionState(
mode=mode, working_dir=working_dir, engine_dir=engine_dir, additional_context=additional_context
)
# | |
self.printLevel >= 2: print("==== Current state: ", self.zt, ". Location: ", loc)
def evaluateCost(self, t, xt, bt):
return np.max(np.dot(self.V[t][xt].T, bt))
def updateBelief(self, xt, xNext, at, ot, bt):
return np.dot( self.M[at][xt][xNext][ot], bt )/np.sum(np.dot( self.M[at][xt][xNext][ot], bt ))
def getObservation(self, xt, obstOpt):
# obstacle observation options:
# - obstOpt = 0 ---> always measure 0 unless perfect measurement
# - obstOpt = 1 ---> always measure 1 unless perfect measurement
# - obstOpt = 2 ---> perfect measurement
# - obstOpt = 3 ---> random unless perfect measurement
if obstOpt == 2:
meas = self.zt
else:
locMeas = list(self.loc)
row, col = np.where(xt == self.stateMap)
for i in range(0, self.numObs):
dist = np.abs(row-self.row_obs[i]) + np.abs(col-self.col_obs[i]) # compute distance from obstacle number ii
if dist >= 2: # if dist >= 2 --> random measurment otherwise exact one
if obstOpt < 2:
locMeas[i] = obstOpt
else:
locMeas[i] = np.round(random.uniform(0, 1))
if self.unGoal == True:
for i in range(0, self.numUGoal):
dist = np.abs(row-self.row_goal[i]) + np.abs(col-self.col_goal[i]) # compute distance from obstacle number ii
if dist >= 1: # if dist >= 1 --> random measurment otherwise exact one
if obstOpt < 2:
locMeas[self.numObs + i] = obstOpt
else:
locMeas[self.numObs + i] = np.round(random.uniform(0, 1))
locMeas = tuple(locMeas)
for i in range(0,len(self.comb)):
if self.comb[i]==locMeas:
meas = i
return meas
class MOMDP_TOQ(MOMDP):
def __init__(self, gridVar, totTimeSteps, printLevel, policy, discOpt, unGoal = False):
super().__init__(gridVar, totTimeSteps, printLevel, policy, discOpt, unGoal)
def backupLoopBeliefPoint(self, t, xt):
J_out = np.zeros((np.shape(self.Belief)[0],np.shape(self.Belief)[1]))
V_out = np.zeros((np.shape(self.Belief)[0],np.shape(self.Belief)[1]))
for j in range(0, np.shape(self.Belief)[1]): # loop over belief points (this for loop can be parallelized)
# for each belief point we are going to compute a cost vector -->
# initialize cost and value function vector for all action. Afterwards,
# we are going to take the max
V_alpha_a = np.zeros((np.shape(self.Belief)[0], self.numA))
V_cost_alpha_a = np.zeros(self.numA)
J_alpha_a = np.zeros((np.shape(self.Belief)[0], self.numA))
J_cost_alpha_a = np.zeros( self.numA)
bt = self.Belief[:, j]
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
Mbt = np.dot(self.M[a,xt,xNext], bt)
J_lambda_kax = np.dot(self.J[t+1,xNext].T, Mbt.T)
V_lambda_kax = np.dot(self.V[t+1,xNext].T, Mbt.T)
idxOptList = []
for o in range(0, self.numZ):
J_lambda_kaxo = J_lambda_kax[:, o]
idxToChange = J_lambda_kaxo < (J_lambda_kaxo.max()-self.toll)
J_lambda_kaxo[idxToChange] = -1000 # Set non-max value to low numer
sumVec = J_lambda_kaxo + V_lambda_kax[:, o]
idxOptList.append(np.argmax(sumVec))
V_alpha_a[:, a] += np.tensordot(self.V[t+1,xNext,:,idxOptList], self.M[a,xt,xNext], 2)
J_alpha_a[:, a] += np.tensordot(self.J[t+1,xNext,:,idxOptList], self.M[a,xt,xNext], 2)
# Select Cost
if xt in self.goal:
V_cost_alpha_a[a] = 1 + np.dot(V_alpha_a[:, a].T, bt)
J_cost_alpha_a[a] = 1
else:
V_cost_alpha_a[a] = np.dot(V_alpha_a[:, a].T, bt)
J_cost_alpha_a[a] = np.dot(J_alpha_a[:, a].T, bt)
idxToChange = J_cost_alpha_a < (J_cost_alpha_a.max()-self.toll) # Where values are low
J_cost_alpha_a[idxToChange] = -1000 # Set non-max value to low numer
sumVec = J_cost_alpha_a + V_cost_alpha_a
idxOpt = np.argmax(sumVec)
if xt in self.goal:
V_out[:,j] = np.ones(np.shape(self.Belief)[0]) + V_alpha_a[:,idxOpt]
J_out[:,j] = np.ones(np.shape(self.Belief)[0])
else:
V_out[:,j] = V_alpha_a[:,idxOpt]
J_out[:,j] = J_alpha_a[:,idxOpt]
self.V[t,xt] = V_out
self.J[t,xt] = J_out
def evaluatePolicy(self, t, xt, bt):
V_alpha_a = np.zeros((self.numZ, self.numA))
J_alpha_a = np.zeros((self.numZ, self.numA))
actionCost = []
actionSpec = []
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
for o in range(0, self.numZ):
# Cost Value Function Update
J_lambda_kaxo = np.dot(self.J[t+1,xNext].T, np.dot( self.M[a,xt,xNext,o], bt ))
V_lambda_kaxo = np.dot(self.V[t+1,xNext].T, np.dot( self.M[a,xt,xNext,o], bt ))
idx = np.where( (J_lambda_kaxo >= np.max(J_lambda_kaxo)-self.toll) )
possOpt = -np.inf * np.ones(np.shape(V_lambda_kaxo)[0])
possOpt[idx] = V_lambda_kaxo[idx]
idxOpt = np.argmax(possOpt)
V_alpha_a[:, a] = V_alpha_a[:, a] + np.dot(self.M[a,xt,xNext,o].T, self.V[t+1,xNext,:, idxOpt])
J_alpha_a[:, a] = J_alpha_a[:, a] + np.dot(self.M[a,xt,xNext,o].T, self.J[t+1,xNext,:, idxOpt])
# Select Cost
if xt in self.goal: stageCost = 1;
else: stageCost = 0
actionCost.append(np.round(stageCost + np.dot(V_alpha_a[:, a], bt), self.digitPrecision))
actionSpec.append(np.round(np.dot(J_alpha_a[:, a], bt), self.digitPrecision))
# Pick best action
probability = max(actionSpec)
cost = max(actionCost)
if self.printLevel > 2: print("Constraint vector: ", actionSpec)
if self.printLevel > 2: print("Cost Vector: ", actionCost)
if probability == 0:
if self.printLevel >= 1: print("Abort Mission")
probability = 0
selectedAction = 0
cost = np.inf
else:
# Pick action with highest prob sat specs
action = np.where(np.array(actionSpec) >= probability-self.toll)
# Among the one with highest prob sat specs pick best cost
possOpt = -np.inf * np.ones(self.numA)
possOpt[action] = np.array(actionCost)[action]
actionSel = np.where(possOpt==np.max(possOpt))
# Print to sceen
if self.printLevel > 2: print("Possible Moves ", self.actVec[action])
if self.printLevel > 2: print("Same Cost Moves: ", self.actVec[actionSel])
if self.printLevel > 2: print("Selected Action: ", self.actVec[actionSel[0][0]])
selectedAction = actionSel[0][0]
if self.printLevel >= 2: print("Probability satinsfying spec: ", probability, ". Expected Cost: ", cost)
return selectedAction, probability, cost
class MOMDP_TO(MOMDP):
def __init__(self, gridVar, totTimeSteps, printLevel, policy, discOpt):
super().__init__(gridVar, totTimeSteps, printLevel, policy, discOpt)
def backupLoopBeliefPoint(self, t, xt):
V_out = np.zeros((np.shape(self.Belief)[0],np.shape(self.Belief)[1]))
for j in range(0, np.shape(self.Belief)[1]): # loop over belief points
# for each belief point we are going to compute a cost vector -->
# initialize cost and value function vector for all action. Afterwards,
# we are going to take the max
V_alpha_a = np.zeros((np.shape(self.Belief)[0], self.numA))
V_cost_alpha_a = np.zeros(self.numA)
bt = self.Belief[:, j]
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
Mbt = np.dot(self.M[a,xt,xNext], bt)
V_lambda_kax = np.dot(self.V[t+1,xNext].T, Mbt.T)
idxOptList = []
for o in range(0, self.numZ):
idxOptList.append(np.argmax(V_lambda_kax[:, o]))
V_alpha_a[:, a] += np.tensordot(self.V[t+1,xNext,:,idxOptList], self.M[a,xt,xNext], 2)
# Select Cost
if xt in self.goal:
V_cost_alpha_a[a] = 1 + np.dot(V_alpha_a[:, a].T, bt)
else:
V_cost_alpha_a[a] = np.dot(V_alpha_a[:, a].T, bt)
idxOpt = np.argmax(V_cost_alpha_a)
if xt in self.goal:
V_out[:,j] = np.ones(np.shape(self.Belief)[0]) + V_alpha_a[:,idxOpt]
else:
V_out[:,j] = V_alpha_a[:,idxOpt]
self.V[t,xt] = V_out
def evaluatePolicy(self, t, xt, bt):
V_alpha_a = np.zeros((self.numZ, self.numA))
actionCost = []
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
for o in range(0, self.numZ):
# Cost Value Function Update
V_lambda_kaxo = np.dot(self.V[t+1,xNext].T, np.dot( self.M[a,xt,xNext,o], bt ))
idxOpt = np.argmax(V_lambda_kaxo)
V_alpha_a[:, a] = V_alpha_a[:, a] + np.dot(self.M[a,xt,xNext,o].T, self.V[t+1,xNext,:, idxOpt])
# Select Cost
if xt in self.goal: stageCost = 1;
else: stageCost = 0
actionCost.append(stageCost + np.dot(V_alpha_a[:, a], bt))
# Pick best action
cost = max(actionCost)
probability = np.inf
if self.printLevel > 2: print("Cost Vector: ", actionCost)
if cost == 0:
if self.printLevel >= 1: print("Run out of time abort the mission")
probability = 0
selectedAction = 0
cost = np.inf
else:
actionSel = np.where(actionCost==np.max(actionCost))
# Print to sceen
if self.printLevel > 2: print("Same Cost Moves: ", self.actVec[actionSel])
if self.printLevel > 2: print("Selected Action: ", self.actVec[actionSel[0][0]])
selectedAction = actionSel[0][0]
probability = np.inf # the probability cannot be computed in TO, unless we run out of time --> failure
if self.printLevel >= 2: print("Probability satinsfying spec: ", probability, ". Expected Cost: ", cost)
return selectedAction, probability, cost
class MOMDP_Q(MOMDP):
def __init__(self, gridVar, totTimeSteps, printLevel, policy, discOpt):
super().__init__(gridVar, totTimeSteps, printLevel, policy, discOpt)
def backupLoopBeliefPoint(self, t, xt):
J_out = np.zeros((np.shape(self.Belief)[0],np.shape(self.Belief)[1]))
for j in range(0, np.shape(self.Belief)[1]): # loop over belief points
# for each belief point we are going to compute a cost vector -->
# initialize cost and value function vector for all action. Afterwards,
# we are going to take the max
J_alpha_a = np.zeros((np.shape(self.Belief)[0], self.numA))
J_cost_alpha_a = np.zeros( self.numA)
J_cost_alpha_a_vec = np.zeros( self.numA)
J_alpha_a_vec = np.zeros((np.shape(self.Belief)[0], self.numA))
bt = self.Belief[:, j]
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
Mbt_vec = np.dot(self.M[a,xt,xNext], bt)
J_lambda_kax = np.dot(self.J[t+1,xNext].T, Mbt_vec.T)
idxOptList = []
for o in range(0, self.numZ):
idxOptList.append(np.argmax(J_lambda_kax[:, o] ))
J_alpha_a[:, a] += np.tensordot(self.J[t+1,xNext,:,idxOptList], self.M[a,xt,xNext], 2)
# Select Cost
if xt in self.goal:
J_cost_alpha_a[a] = 1
else:
J_cost_alpha_a[a] = np.round(np.dot(J_alpha_a[:, a].T, bt), self.digitPrecision)
idxOpt = np.argmax( J_cost_alpha_a )
if xt in self.goal:
J_out[:,j] = np.ones(np.shape(self.Belief)[0])
else:
J_out[:,j] = J_alpha_a[:,idxOpt]
self.J[t,xt] = J_out
def evaluatePolicy(self, t, xt, bt):
J_alpha_a = np.zeros((self.numZ, self.numA))
actionSpec = []
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
for o in range(0, self.numZ):
# Cost Value Function Update
J_lambda_kaxo = np.dot(self.J[t+1][xNext].T, np.dot( self.M[a,xt,xNext,o], bt ))
idxOpt = np.argmax(J_lambda_kaxo)
J_alpha_a[:, a] = J_alpha_a[:, a] + np.dot(self.M[a,xt,xNext,o].T, self.J[t+1,xNext,:, idxOpt])
# Select Cost
actionSpec.append(np.round(np.dot(J_alpha_a[:, a], bt), self.digitPrecision))
# Pick best action
probability = max(actionSpec)
cost = np.inf # set cost to inf because no cost is computed for the Quantitative policy
# pdb.set_trace()
if self.printLevel > 2: print("Max spec vector: ", actionSpec)
if probability == 0:
if self.printLevel >= 1: print("Abort Mission")
probability = 0
selectedAction = 0
else:
actionSel = np.where(actionSpec==np.max(actionSpec))
# Print to sceen
if self.printLevel > 2: print("Possible Moves ", self.actVec[actionSel])
if self.printLevel > 2: print("Selected Action: ", self.actVec[actionSel[0][0]])
selectedAction = actionSel[0][0]
if self.printLevel >= 2: print("Probability satinsfying spec: ", probability, ". Expected Cost: ", cost)
return selectedAction, probability, cost
class MOMDP_TOQ_notVectorized(MOMDP):
def __init__(self, gridVar, totTimeSteps, printLevel, policy, discOpt):
super().__init__(gridVar, totTimeSteps, printLevel, policy, discOpt)
def backupLoopBeliefPoint(self, t, xt):
J_out = np.zeros((np.shape(self.Belief)[0],np.shape(self.Belief)[1]))
V_out = np.zeros((np.shape(self.Belief)[0],np.shape(self.Belief)[1]))
for j in range(0, np.shape(self.Belief)[1]): # loop over belief points
# for each belief point we are going to compute a cost vector -->
# initialize cost and value function vector for all action. Afterwards,
# we are going to take the max
V_alpha_a = np.zeros((np.shape(self.Belief)[0], self.numA))
V_cost_alpha_a = np.zeros(self.numA)
J_alpha_a = np.zeros((np.shape(self.Belief)[0], self.numA))
J_cost_alpha_a = np.zeros( self.numA)
bt = self.Belief[:, j]
for a in range(0, self.numA):
for xNext in self.sucessorStatesList[xt][a]:
for o in range(0, self.numZ):
J_lambda_kaxo = np.dot(self.J[t+1, xNext].T, np.dot(self.M[a,xt,xNext,o], bt))
V_lambda_kaxo = np.dot(self.V[t+1, xNext].T, np.dot(self.M[a,xt,xNext,o], bt))
idx = np.where( (J_lambda_kaxo >= np.max(J_lambda_kaxo)-self.toll) & (J_lambda_kaxo <= np.max(J_lambda_kaxo)+self.toll) )
possOpt = -np.inf * np.ones(np.shape(V_lambda_kaxo)[0])
possOpt[idx] = V_lambda_kaxo[idx]
idxOpt = np.argmax(possOpt)
V_alpha_a[:, a] += np.dot(self.M[a,xt,xNext,o].T, self.V[t+1,xNext,:, idxOpt])
J_alpha_a[:, a] += np.dot(self.M[a,xt,xNext,o].T, self.J[t+1,xNext,:, idxOpt])
# Select Cost
if xt in self.goal:
V_cost_alpha_a[a] = 1 + np.dot(V_alpha_a[:, a].T, bt)
J_cost_alpha_a[a] = 1
else:
V_cost_alpha_a[a] = np.dot(V_alpha_a[:, a].T, bt)
J_cost_alpha_a[a] = np.dot(J_alpha_a[:, a].T, bt)
# take the max to compute the vector at the belief point
optVector = -np.inf * np.ones(self.numA);
idx = np.where( (J_cost_alpha_a >= np.max(J_cost_alpha_a)-self.toll) & (J_cost_alpha_a <= np.max(J_cost_alpha_a)+self.toll) )
optVector[idx] = V_cost_alpha_a[idx]
idxOpt = np.argmax(optVector)
if xt in self.goal:
V_out[:,j] = np.ones(np.shape(self.Belief)[0]) + V_alpha_a[:,idxOpt]
J_out[:,j] = np.ones(np.shape(self.Belief)[0])
else:
V_out[:,j] = V_alpha_a[:,idxOpt]
J_out[:,j] = J_alpha_a[:,idxOpt]
self.V[t][xt] = V_out
self.J[t][xt] = J_out
def evaluatePolicy(self, t, xt, bt):
V_alpha_a = np.zeros((self.numZ, self.numA))
J_alpha_a = np.zeros((self.numZ, self.numA))
actionCost = []
actionSpec = | |
from enum import IntEnum
from ctypes import (
Union,
c_char, c_uint16,
c_uint8,
c_uint32,
c_uint64,
c_int32,
)
from DyldExtractor.structure import Structure
class LoadCommands(IntEnum):
"""An Enum for all the load commands.
"""
"""
After MacOS X 10.1 when a new load command is added that is required to be
understood by the dynamic linker for the image to execute properly the
LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic
linker sees such a load command it it does not understand will issue a
"unknown load command required for execution" error and refuse to use the
image. Other load commands without this bit that are not understood will
simply be ignored.
"""
LC_REQ_DYLD = 0x80000000
# Constants for the cmd field of all load commands, the type
LC_SEGMENT = 0x1 # segment of this file to be mapped
LC_SYMTAB = 0x2 # link-edit stab symbol table info
LC_SYMSEG = 0x3 # link-edit gdb symbol table info (obsolete)
LC_THREAD = 0x4 # thread
LC_UNIXTHREAD = 0x5 # unix thread (includes a stack)
LC_LOADFVMLIB = 0x6 # load a specified fixed VM shared library
LC_IDFVMLIB = 0x7 # fixed VM shared library identification
LC_IDENT = 0x8 # object identification info (obsolete)
LC_FVMFILE = 0x9 # fixed VM file inclusion (internal use)
LC_PREPAGE = 0xa # prepage command (internal use)
LC_DYSYMTAB = 0xb # dynamic link-edit symbol table info
LC_LOAD_DYLIB = 0xc # load a dynamically linked shared library
LC_ID_DYLIB = 0xd # dynamically linked shared lib ident
LC_LOAD_DYLINKER = 0xe # load a dynamic linker
LC_ID_DYLINKER = 0xf # dynamic linker identification
LC_PREBOUND_DYLIB = 0x10 # modules prebound for a dynamically
# linked shared library
LC_ROUTINES = 0x11 # image routines
LC_SUB_FRAMEWORK = 0x12 # sub framework
LC_SUB_UMBRELLA = 0x13 # sub umbrella
LC_SUB_CLIENT = 0x14 # sub client
LC_SUB_LIBRARY = 0x15 # sub library
LC_TWOLEVEL_HINTS = 0x16 # two-level namespace lookup hints
LC_PREBIND_CKSUM = 0x17 # prebind checksum
"""
load a dynamically linked shared library that is allowed to be missing
(all symbols are weak imported).
"""
LC_LOAD_WEAK_DYLIB = (0x18 | LC_REQ_DYLD)
LC_SEGMENT_64 = 0x19 # 64-bit segment of this file to be
# mapped
LC_ROUTINES_64 = 0x1a # 64-bit image routines
LC_UUID = 0x1b # the uuid
LC_RPATH = (0x1c | LC_REQ_DYLD) # runpath additions
LC_CODE_SIGNATURE = 0x1d # local of code signature
LC_SEGMENT_SPLIT_INFO = 0x1e # local of info to split segments
LC_REEXPORT_DYLIB = (0x1f | LC_REQ_DYLD) # load and re-export dylib
LC_LAZY_LOAD_DYLIB = 0x20 # delay load of dylib until first use
LC_ENCRYPTION_INFO = 0x21 # encrypted segment information
LC_DYLD_INFO = 0x22 # compressed dyld information
LC_DYLD_INFO_ONLY = (0x22 | LC_REQ_DYLD) # compressed dyld information only
LC_LOAD_UPWARD_DYLIB = (0x23 | LC_REQ_DYLD) # load upward dylib
LC_VERSION_MIN_MACOSX = 0x24 # build for MacOSX min OS version
LC_VERSION_MIN_IPHONEOS = 0x25 # build for iPhoneOS min OS version
LC_FUNCTION_STARTS = 0x26 # compressed table of function start addresses
LC_DYLD_ENVIRONMENT = 0x27 # string for dyld to treat
# like environment variable
LC_MAIN = (0x28 | LC_REQ_DYLD) # replacement for LC_UNIXTHREAD
LC_DATA_IN_CODE = 0x29 # table of non-instructions in __text
LC_SOURCE_VERSION = 0x2A # source version used to build binary
LC_DYLIB_CODE_SIGN_DRS = 0x2B # Code signing DRs copied from linked dylibs
LC_ENCRYPTION_INFO_64 = 0x2C # 64-bit encrypted segment information
LC_LINKER_OPTION = 0x2D # linker options in MH_OBJECT files
LC_LINKER_OPTIMIZATION_HINT = 0x2E # optimization hints in MH_OBJECT files
LC_VERSION_MIN_TVOS = 0x2F # build for AppleTV min OS version
LC_VERSION_MIN_WATCHOS = 0x30 # build for Watch min OS version
LC_NOTE = 0x31 # arbitrary data included within a Mach-O file
LC_BUILD_VERSION = 0x32 # build for platform min OS version
LC_DYLD_EXPORTS_TRIE = (0x33 | LC_REQ_DYLD) # used with linkedit_data_command, payload is trie
LC_DYLD_CHAINED_FIXUPS = (0x34 | LC_REQ_DYLD) # used with linkedit_data_command
LC_FILESET_ENTRY = (0x35 | LC_REQ_DYLD) # used with fileset_entry_command
class mach_header_64(Structure):
SIZE = 32
magic: int # mach magic number identifier
cputype: int # cpu specifier
cpusubtype: int # machine specifier
filetype: int # type of file
ncmds: int # number of load commands
sizeofcmds: int # the size of all the load commands
flags: int # flags
reserved: int # reserved
_fields_ = [
("magic", c_uint32),
("cputype", c_uint32),
("cpusubtype", c_uint32),
("filetype", c_uint32),
("ncmds", c_uint32),
("sizeofcmds", c_uint32),
("flags", c_uint32),
("reserved", c_uint32),
]
class load_command(Structure):
cmd: int # type of load command
cmdsize: int # total size of command in bytes
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
]
class UnknownLoadCommand(load_command):
pass
class segment_command_64(Structure):
"""
The 64-bit segment load command indicates that a part of this file is to be
mapped into a 64-bit task's address space. If the 64-bit segment has
sections then section_64 structures directly follow the 64-bit segment
command and their size is reflected in cmdsize.
for 64-bit architectures
"""
SIZE = 72
cmd: int # LC_SEGMENT_64
cmdsize: int # includes sizeof section_64 structs
segname: bytes # segment name
vmaddr: int # memory address of this segment
vmsize: int # memory size of this segment
fileoff: int # file offset of this segment
filesize: int # amount to map from the file
maxprot: int # maximum VM protection
initprot: int # initial VM protection
nsects: int # number of sections in segment
flags: int # flags
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("segname", c_char * 16),
("vmaddr", c_uint64),
("vmsize", c_uint64),
("fileoff", c_uint64),
("filesize", c_uint64),
("maxprot", c_int32),
("initprot", c_int32),
("nsects", c_uint32),
("flags", c_uint32),
]
class section_64(Structure):
# for 64-bit architectures
SIZE = 80
sectname: bytes # name of this section
segname: bytes # segment this section goes in
addr: int # memory address of this section
size: int # size in bytes of this section
offset: int # file offset of this section
align: int # section alignment (power of 2)
reloff: int # file offset of relocation entries
nreloc: int # number of relocation entries
flags: int # flags (section type and attributes
reserved1: int # reserved (for offset or index)
reserved2: int # reserved (for count or sizeof)
reserved3: int # reserved
_fields_ = [
("sectname", c_char * 16),
("segname", c_char * 16),
("addr", c_uint64),
("size", c_uint64),
("offset", c_uint32),
("align", c_uint32),
("reloff", c_uint32),
("nreloc", c_uint32),
("flags", c_uint32),
("reserved1", c_uint32),
("reserved2", c_uint32),
("reserved3", c_uint32),
]
class lc_str(Structure):
offset: int # offset to the string
_fields_ = [
("offset", c_uint32),
]
class Fvmlib(Structure):
name: lc_str # library's target pathname
minor_version: int # library's minor version number
header_addr: int # library's header address
_fields_ = [
("name", lc_str),
("minor_version", c_uint32),
("header_addr", c_uint32),
]
class fvmlib_command(Structure):
cmd: int # LC_IDFVMLIB or LC_LOADFVMLIB
cmdsize: int # includes pathname string
fvmlib: Fvmlib # the library identification
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("fvmlib", Fvmlib),
]
class Dylib(Structure):
name: lc_str # library's path name
timestamp: int # library's build time stamp
current_version: int # library's current version number
compatibility_version: int # library's compatibility vers number
_fields_ = [
("name", lc_str),
("timestamp", c_uint32),
("current_version", c_uint32),
("compatibility_version", c_uint32),
]
class dylib_command(Structure):
cmd: int # LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB,
# LC_REEXPORT_DYLIB
cmdsize: int # includes pathname string
dylib: Dylib # the library identification
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("dylib", Dylib),
]
class sub_framework_command(Structure):
cmd: int # LC_SUB_FRAMEWORK
cmdsize: int # includes umbrella string
umbrella: lc_str # the umbrella framework name
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("umbrella", lc_str),
]
class sub_client_command(Structure):
cmd: int # LC_SUB_CLIENT
cmdsize: int # includes client string
client: lc_str # the client name
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("client", lc_str),
]
class sub_umbrella_command(Structure):
cmd: int # LC_SUB_UMBRELLA
cmdsize: int # includes sub_umbrella string
sub_umbrella: lc_str # the sub_umbrella framework name
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("sub_umbrella", lc_str),
]
class sub_library_command(Structure):
cmd: int # LC_SUB_LIBRARY
cmdsize: int # includes sub_library string
sub_library: lc_str # the sub_library name
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("sub_library", lc_str),
]
class prebound_dylib_command(Structure):
cmd: int # LC_PREBOUND_DYLIB
cmdsize: int # includes strings
name: lc_str # library's path name
nmodules: int # number of modules in library
linked_modules: lc_str # bit vector of linked modules
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("name", lc_str),
("nmodules", c_uint32),
("linked_modules", lc_str),
]
class dylinker_command(Structure):
cmd: int # LC_ID_DYLINKER, LC_LOAD_DYLINKER or
# LC_DYLD_ENVIRONMENT
cmdsize: int # includes pathname string
name: lc_str # dynamic linker's path name
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("name", lc_str),
]
class routines_command_64(Structure):
# for 64-bit architectures
cmd: int # LC_ROUTINES_64
cmdsize: int # total size of this command
init_address: int # address of initialization routine
init_module: int # index into the module table that
# the init routine is defined in
reserved1: int
reserved2: int
reserved3: int
reserved4: int
reserved5: int
reserved6: int
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("init_address", c_uint64),
("init_module", c_uint64),
("reserved1", c_uint64),
("reserved2", c_uint64),
("reserved3", c_uint64),
("reserved4", c_uint64),
("reserved5", c_uint64),
("reserved6", c_uint64),
]
class symtab_command(Structure):
cmd: int # LC_SYMTAB
cmdsize: int # sizeof(struct symtab_command)
symoff: int # symbol table offset
nsyms: int # number of symbol table entries
stroff: int # string table offset
strsize: int # string table size in bytes
_fields_ = [
("cmd", c_uint32),
("cmdsize", c_uint32),
("symoff", c_uint32),
("nsyms", c_uint32),
("stroff", c_uint32),
("strsize", c_uint32),
]
class N_un(Union):
n_strx: int # index into the string table
_fields_ = [
("n_strx", c_uint32)
]
class nlist_64(Structure):
SIZE: int = 16
n_un: N_un
n_type: int # type flag, see below
n_sect: int # section number or NO_SECT
n_desc: int # see <mach-o/stab.h>
n_value: int # value of this symbol (or stab offset)
_fields_ = [
("n_un", N_un),
("n_type", c_uint8),
("n_sect", c_uint8),
("n_desc", c_uint16),
("n_value", c_uint64),
]
class dysymtab_command(Structure):
cmd: int # LC_DYSYMTAB
cmdsize: int # sizeof(struct dysymtab_command)
ilocalsym: int # index to local symbols
nlocalsym: int # number of local symbols
iextdefsym: int # index to externally defined symbols
nextdefsym: int # number of externally defined symbols
iundefsym: int # index to undefined symbols
nundefsym: int # number of undefined symbols
tocoff: int # file offset to table of contents
ntoc: int # number of entries in table of contents
modtaboff: int # file | |
<gh_stars>0
from scoring import scoring
from objects import Spectrum, SequenceAlignment, HybridSequenceAlignment, Database, Alignments, DEVFallOffEntry
from alignment import alignment_utils, hybrid_alignment
import objects
import utils
import database
import gen_spectra
import math
import re
import time
FIRST_ALIGN_TIME = 0
AMBIGUOUS_REMOVAL_TIME = 0
PRECURSOR_MASS_TIME = 0
OBJECTIFY_TIME = 0
FIRST_ALIGN_COUNT = 0
AMBIGUOUS_REMOVAL_COUNT = 0
PRECURSOR_MASS_COUNT = 0
OBJECTIFY_COUNT = 0
OUT_OF_RANGE_SEQS = 0
TOTAL_ITERATIONS = 0
global extension_times
extension_times = []
global initial_alignment_times
initial_alignment_times = []
global Non_hybrid_refine_time
Non_hybrid_refine_time = []
global non_hybrid_scoring_times
non_hybrid_scoring_times = []
global Hybrid_refine_times
Hybrid_refine_times = []
global hybrid_scoring_times
hybrid_scoring_times = []
def same_protein_alignment(seq1: str, seq2: str, parent_sequence: str):
if seq1 == seq2:
return (seq1, None)
if seq1 in seq2:
return (seq2, None)
if seq2 in seq1:
return (seq1, None)
gap_aa = max(1, len(parent_sequence) // 100)
left_start = [m.start() for m in re.finditer(seq1, parent_sequence)]
right_start = [m.start() for m in re.finditer(seq2, parent_sequence)]
if all([r < l for r in right_start for l in left_start]):
return hybrid_alignment.hybrid_alignment(seq1, seq2)
nonhybrid_alignments = []
for l in left_start:
for r in right_start:
if r < l:
continue
if r - (l + len(seq1)) <= gap_aa:
overlapped = parent_sequence[l: r + len(seq2)]
nonhybrid_alignments.append(overlapped)
if len(nonhybrid_alignments) == 0:
return hybrid_alignment.hybrid_alignment(seq1, seq2)
nonhybrid_alignments.sort(key=lambda x: len(x))
return (nonhybrid_alignments[0], None)
def align_b_y(b_kmers: list, y_kmers: list, spectrum: Spectrum, db: Database):
spec_alignments = []
for b_kmer in b_kmers:
b_seq = b_kmer[2][2]
b_proteins = database.get_proteins_with_subsequence(db, b_seq)
for y_kmer in y_kmers:
y_seq = y_kmer[2][2]
y_proteins = database.get_proteins_with_subsequence(db, y_seq)
if any([x in y_proteins for x in b_proteins]):
shared_prots = [x for x in y_proteins if x in b_proteins]
for sp in shared_prots:
prot_seqs = database.get_entry_by_name(db, sp)
for prot_entry in prot_seqs:
spec_alignments.append(
same_protein_alignment(b_seq, y_seq, prot_entry.sequence)
)
spec_alignments.append((f'{b_seq}{y_seq}', f'{b_seq}-{y_seq}'))
else:
spec_alignments.append(hybrid_alignment.hybrid_alignment(b_seq, y_seq))
return list(set([x for x in spec_alignments if x is not None]))
def extend_base_kmers(b_kmers: list, y_kmers: list, spectrum: Spectrum, db: Database):
extended_b = []
extended_y = []
for seq in b_kmers:
extended_b += [x for x in alignment_utils.extend_non_hybrid(seq, spectrum, 'b', db)]
for seq in y_kmers:
extended_y += [x for x in alignment_utils.extend_non_hybrid(seq, spectrum, 'y', db)]
return extended_b, extended_y
def refine_alignments(spectrum: Spectrum, db: Database, alignments: list, precursor_tolerance: int = 10,
DEV: bool = False, truth: dict = None, fall_off: dict = None):
global PRECURSOR_MASS_COUNT, AMBIGUOUS_REMOVAL_COUNT, OUT_OF_RANGE_SEQS
global PRECURSOR_MASS_TIME, AMBIGUOUS_REMOVAL_TIME
predicted_len = utils.predicted_len(spectrum.precursor_mass, spectrum.precursor_charge)
allowed_gap = math.ceil(predicted_len * .25)
st = time.time()
precursor_matches = []
for sequence_pairs in alignments:
sequence = sequence_pairs[0] if sequence_pairs[1] is None else sequence_pairs[1]
p_ms = [
x for x in \
alignment_utils.match_precursor(spectrum, sequence, db, gap=allowed_gap, tolerance=precursor_tolerance)
]
if len(p_ms) and p_ms[0] is None:
OUT_OF_RANGE_SEQS += 1
continue
precursor_matches += p_ms
PRECURSOR_MASS_COUNT += len(alignments)
PRECURSOR_MASS_TIME += time.time() - st
if DEV:
_id = spectrum.id
is_hybrid = truth[_id]['hybrid']
truth_seq = truth[_id]['sequence']
if not utils.DEV_contains_truth_exact(truth_seq, is_hybrid, precursor_matches):
metadata = {
'sequences_before_precursor_filling': alignments,
'sequences_after_precursor_filling': precursor_matches,
'observed_precursor_mass': spectrum.precursor_mass,
'observed_percursor_charge': spectrum.precursor_charge,
'allowed_gap': allowed_gap
}
fall_off[_id] = DEVFallOffEntry(
is_hybrid,
truth_seq,
'precursor_filling',
metadata
)
return Alignments(spectrum, [])
nonhyba, hyba = [], []
for p_m in precursor_matches:
if '-' in p_m or '(' in p_m or ')' in p_m:
hyba.append((p_m.replace('-', '').replace('(', '').replace(')', ''), p_m))
else:
nonhyba.append((p_m, None))
st = time.time()
updated_hybrids = [] if len(hyba) == 0 else hybrid_alignment.replace_ambiguous_hybrids(hyba, db, spectrum)
if DEV and truth[spectrum.id]['hybrid']:
_id = spectrum.id
is_hybrid = truth[_id]['hybrid']
truth_seq = truth[_id]['sequence']
if not utils.DEV_contains_truth_exact(truth_seq, is_hybrid, [x[0] for x in updated_hybrids]):
metadata = {
'before_ambiguous_removal': hyba,
'after_ambiguous_removal': updated_hybrids
}
fall_off[_id] = DEVFallOffEntry(
is_hybrid,
truth_seq,
'removing_ambiguous_hybrids',
metadata
)
return Alignments(spectrum, [])
AMBIGUOUS_REMOVAL_COUNT += len(hyba)
AMBIGUOUS_REMOVAL_TIME += time.time() - st
return nonhyba + updated_hybrids
def attempt_alignment_dev(spectrum: Spectrum, truth: bool = None, fall_off: bool = None,a: list = None):
b_seqs = [x[0] for x in a]
y_seqs = [x[0] for x in a]
_id = spectrum.id
is_hybrid = truth[_id]['hybrid']
truth_seq = truth[_id]['sequence']
if not utils.DEV_contains_truth_parts(truth_seq, is_hybrid, b_seqs, y_seqs):
metadata = {
'alignments': a,
'before_alignments_b': b_seqs,
'before_alignments_y': y_seqs
}
fall_off[_id] = DEVFallOffEntry(
is_hybrid,
truth_seq,
'first_alignment_round',
metadata
)
return Alignments(spectrum, [], None)
def attempt_alignment_first_pass(spectrum: Spectrum, db: Database, n: int = 3, ppm_tolerance: int = 20,
precursor_tolerance: int = 10,digest_type: str = '',truth: bool = None, fall_off: bool = None,
DEV: bool = False,OBJECTIFY_COUNT: int = 0,OBJECTIFY_TIME: int = 0,a: list = None,is_last: bool = False):
refine_start = time.time()
non_hybrid_refined = refine_alignments(spectrum, db, [x for x in a if x[1] is None],
precursor_tolerance=precursor_tolerance, DEV=DEV, truth=truth, fall_off=fall_off)
refine_time = time.time() - refine_start
Non_hybrid_refine_time.append(refine_time)
non_hybrid_alignments = []
tracker = {}
st = time.time()
for nhr, _ in non_hybrid_refined:
if nhr in tracker:
continue
tracker[nhr] = True
scoring_start = time.time()
p_d = scoring.precursor_distance(
spectrum.precursor_mass,
gen_spectra.get_precursor(nhr, spectrum.precursor_charge)
)
b_score = scoring.score_sequence(
spectrum.mz_values,
sorted(gen_spectra.gen_spectrum(nhr, ion='b')['spectrum']),
ppm_tolerance
)
y_score = scoring.score_sequence(
spectrum.mz_values,
sorted(gen_spectra.gen_spectrum(nhr, ion='y')['spectrum']),
ppm_tolerance
)
total_error = scoring.total_mass_error(spectrum, nhr, ppm_tolerance)
t_score = b_score + y_score + scoring.digest_score(nhr, db, digest_type)
non_hybrid_scoring_times.append(time.time() - scoring_start)
parents = alignment_utils.get_parents(nhr, db)
non_hybrid_alignments.append(
SequenceAlignment(
parents[0],
nhr,
b_score,
y_score,
t_score,
p_d,
total_error
)
)
OBJECTIFY_COUNT += len(non_hybrid_refined)
OBJECTIFY_TIME += time.time() - st
if any([x.total_score >= 1.5 * len(x.sequence) for x in non_hybrid_alignments]):
sorted_alignments = sorted(
non_hybrid_alignments,
key=lambda x: (
x.total_score,
math.inf if x.total_mass_error <= 0 else 1/x.total_mass_error,
math.inf if x.precursor_distance <= 0 else 1/x.precursor_distance,
x.b_score,
x.y_score
),
reverse=True
)
top_n_alignments = sorted_alignments[:n]
return top_n_alignments
else:
return None, non_hybrid_alignments
def attempt_alignment_second_pass(spectrum: Spectrum, db: Database, n: int = 3,
ppm_tolerance: int = 20, precursor_tolerance: int = 10,digest_type: str = '',truth: bool = None,
fall_off: bool = None,DEV: bool = False,OBJECTIFY_COUNT: int = 0,OBJECTIFY_TIME: int = 0,
a: list = [],non_hybrid_alignments: list = []):
refine_start = time.time()
hybrid_refined = refine_alignments(
spectrum,
db,
[x for x in a if x[1] is not None],
precursor_tolerance=precursor_tolerance,
DEV=DEV,
truth=truth,
fall_off=fall_off
)
refine_time = time.time() - refine_start
Hybrid_refine_times.append(refine_time)
hybrid_alignments = []
tracker = {}
st = time.time()
for hr, special_hr in hybrid_refined:
if hr in tracker:
continue
tracker[hr] = True
scoring_start = time.time()
p_d = scoring.precursor_distance(
spectrum.precursor_mass,
gen_spectra.get_precursor(hr, spectrum.precursor_charge)
)
b_score = scoring.score_sequence(
spectrum.mz_values,
sorted(gen_spectra.gen_spectrum(hr, ion='b')['spectrum']),
ppm_tolerance
)
y_score = scoring.score_sequence(
spectrum.mz_values,
sorted(gen_spectra.gen_spectrum(hr, ion='y')['spectrum']),
ppm_tolerance
)
total_error = scoring.total_mass_error(spectrum, hr, ppm_tolerance)
hybrid_scoring_times.append(time.time() - scoring_start)
parents = alignment_utils.get_parents(hr, db)
t_score = None
if special_hr is None:
t_score = b_score + y_score + scoring.digest_score(hr, db, digest_type)
non_hybrid_alignments.append(
SequenceAlignment(
parents[0],
hr,
b_score,
y_score,
t_score,
p_d,
total_error
)
)
i = 0
avg_b_score = 0
avg_y_score = 0
avg_total_score = 0
for score in non_hybrid_alignments:
avg_b_score = avg_b_score + score[2]
avg_y_score = avg_y_score + score[3]
avg_total_score = avg_total_score + score[4]
i = i + 1
alignment_instrumentation = objects.Alignment_Instrumentation(
avg_b_score = avg_b_score/i,
avg_y_score = avg_y_score/i,
avg_total_score = avg_total_score/i
)
else:
t_score = scoring.hybrid_score(spectrum, special_hr, ppm_tolerance)\
+ scoring.digest_score(special_hr, db, digest_type)
hybrid_alignments.append(
HybridSequenceAlignment(
parents[0],
parents[1],
hr,
special_hr,
b_score,
y_score,
t_score,
p_d,
total_error
)
)
i = 0
avg_b_score = 0
avg_y_score = 0
avg_total_score = 0
for score in hybrid_alignments:
avg_b_score = avg_b_score + score[4]
avg_y_score = avg_y_score + score[5]
avg_total_score = avg_total_score + score[6]
i = i + 1
alignment_instrumentation = objects.Alignment_Instrumentation(
avg_b_score = avg_b_score/i,
avg_y_score = avg_y_score/i,
avg_total_score = avg_total_score/i
)
OBJECTIFY_COUNT += len(hybrid_refined)
OBJECTIFY_TIME += time.time() - st
all_alignments = non_hybrid_alignments + hybrid_alignments
sorted_alignments = sorted(
all_alignments,
key=lambda x: (
x.total_score,
math.inf if x.total_mass_error <= 0 else 1/x.total_mass_error,
math.inf if x.precursor_distance <= 0 else 1/x.precursor_distance,
1/len(x),
x.b_score,
x.y_score
),
reverse=True
)
top_n_alignments = sorted_alignments[:n]
return Alignments(spectrum, top_n_alignments)
def attempt_alignment(spectrum: Spectrum, db: Database, b_hits: list,y_hits: list, n: int = 3,
ppm_tolerance: int = 20, precursor_tolerance: int = 10,digest_type: str = '',DEBUG: bool = False,
truth: bool = None, fall_off: bool = None):
global FIRST_ALIGN_TIME, AMBIGUOUS_REMOVAL_TIME, PRECURSOR_MASS_TIME, OBJECTIFY_TIME
global FIRST_ALIGN_COUNT, AMBIGUOUS_REMOVAL_COUNT, PRECURSOR_MASS_COUNT, OBJECTIFY_COUNT
global TOTAL_ITERATIONS
TOTAL_ITERATIONS += 1
DEV = truth is not None and fall_off is not None
b_non_hybrids, y_non_hybrids = extend_base_kmers(b_hits, y_hits, spectrum, db)
non_hybrids = b_non_hybrids + y_non_hybrids
a = align_b_y(b_hits, y_hits, spectrum, db) | |
from __future__ import annotations
import dataclasses
import enum
import io
import secrets
import struct
from typing import Callable, Generator, Optional, Sequence, Tuple
from . import exceptions, extensions
from .typing import Data
try:
from .speedups import apply_mask
except ImportError: # pragma: no cover
from .utils import apply_mask
__all__ = [
"Opcode",
"OP_CONT",
"OP_TEXT",
"OP_BINARY",
"OP_CLOSE",
"OP_PING",
"OP_PONG",
"DATA_OPCODES",
"CTRL_OPCODES",
"Frame",
"prepare_data",
"prepare_ctrl",
"Close",
]
class Opcode(enum.IntEnum):
"""Opcode values for WebSocket frames."""
CONT, TEXT, BINARY = 0x00, 0x01, 0x02
CLOSE, PING, PONG = 0x08, 0x09, 0x0A
OP_CONT = Opcode.CONT
OP_TEXT = Opcode.TEXT
OP_BINARY = Opcode.BINARY
OP_CLOSE = Opcode.CLOSE
OP_PING = Opcode.PING
OP_PONG = Opcode.PONG
DATA_OPCODES = OP_CONT, OP_TEXT, OP_BINARY
CTRL_OPCODES = OP_CLOSE, OP_PING, OP_PONG
# See https://www.iana.org/assignments/websocket/websocket.xhtml
CLOSE_CODES = {
1000: "OK",
1001: "going away",
1002: "protocol error",
1003: "unsupported type",
# 1004 is reserved
1005: "no status code [internal]",
1006: "connection closed abnormally [internal]",
1007: "invalid data",
1008: "policy violation",
1009: "message too big",
1010: "extension required",
1011: "unexpected error",
1012: "service restart",
1013: "try again later",
1014: "bad gateway",
1015: "TLS failure [internal]",
}
# Close code that are allowed in a close frame.
# Using a set optimizes `code in EXTERNAL_CLOSE_CODES`.
EXTERNAL_CLOSE_CODES = {
1000,
1001,
1002,
1003,
1007,
1008,
1009,
1010,
1011,
1012,
1013,
1014,
}
OK_CLOSE_CODES = {1000, 1001}
BytesLike = bytes, bytearray, memoryview
@dataclasses.dataclass
class Frame:
"""
WebSocket frame.
Attributes:
opcode: Opcode.
data: Payload data.
fin: FIN bit.
rsv1: RSV1 bit.
rsv2: RSV2 bit.
rsv3: RSV3 bit.
Only these fields are needed. The MASK bit, payload length and masking-key
are handled on the fly when parsing and serializing frames.
"""
opcode: Opcode
data: bytes
fin: bool = True
rsv1: bool = False
rsv2: bool = False
rsv3: bool = False
def __str__(self) -> str:
"""
Return a human-readable represention of a frame.
"""
coding = None
length = f"{len(self.data)} byte{'' if len(self.data) == 1 else 's'}"
non_final = "" if self.fin else "continued"
if self.opcode is OP_TEXT:
# Decoding only the beginning and the end is needlessly hard.
# Decode the entire payload then elide later if necessary.
data = repr(self.data.decode())
elif self.opcode is OP_BINARY:
# We'll show at most the first 16 bytes and the last 8 bytes.
# Encode just what we need, plus two dummy bytes to elide later.
binary = self.data
if len(binary) > 25:
binary = binary[:16] + b"\x00\x00" + binary[-8:]
data = " ".join(f"{byte:02x}" for byte in binary)
elif self.opcode is OP_CLOSE:
data = str(Close.parse(self.data))
elif self.data:
# We don't know if a Continuation frame contains text or binary.
# Ping and Pong frames could contain UTF-8. Attempt to decode as
# UTF-8 and display it as text; fallback to binary.
try:
data = repr(self.data.decode())
coding = "text"
except UnicodeDecodeError:
binary = self.data
if len(binary) > 25:
binary = binary[:16] + b"\x00\x00" + binary[-8:]
data = " ".join(f"{byte:02x}" for byte in binary)
coding = "binary"
else:
data = "''"
if len(data) > 75:
data = data[:48] + "..." + data[-24:]
metadata = ", ".join(filter(None, [coding, length, non_final]))
return f"{self.opcode.name} {data} [{metadata}]"
@classmethod
def parse(
cls,
read_exact: Callable[[int], Generator[None, None, bytes]],
*,
mask: bool,
max_size: Optional[int] = None,
extensions: Optional[Sequence[extensions.Extension]] = None,
) -> Generator[None, None, Frame]:
"""
Parse a WebSocket frame.
This is a generator-based coroutine.
Args:
read_exact: generator-based coroutine that reads the requested
bytes or raises an exception if there isn't enough data.
mask: whether the frame should be masked i.e. whether the read
happens on the server side.
max_size: maximum payload size in bytes.
extensions: list of extensions, applied in reverse order.
Raises:
PayloadTooBig: if the frame's payload size exceeds ``max_size``.
ProtocolError: if the frame contains incorrect values.
"""
# Read the header.
data = yield from read_exact(2)
head1, head2 = struct.unpack("!BB", data)
# While not Pythonic, this is marginally faster than calling bool().
fin = True if head1 & 0b10000000 else False
rsv1 = True if head1 & 0b01000000 else False
rsv2 = True if head1 & 0b00100000 else False
rsv3 = True if head1 & 0b00010000 else False
try:
opcode = Opcode(head1 & 0b00001111)
except ValueError as exc:
raise exceptions.ProtocolError("invalid opcode") from exc
if (True if head2 & 0b10000000 else False) != mask:
raise exceptions.ProtocolError("incorrect masking")
length = head2 & 0b01111111
if length == 126:
data = yield from read_exact(2)
(length,) = struct.unpack("!H", data)
elif length == 127:
data = yield from read_exact(8)
(length,) = struct.unpack("!Q", data)
if max_size is not None and length > max_size:
raise exceptions.PayloadTooBig(
f"over size limit ({length} > {max_size} bytes)"
)
if mask:
mask_bytes = yield from read_exact(4)
# Read the data.
data = yield from read_exact(length)
if mask:
data = apply_mask(data, mask_bytes)
frame = cls(opcode, data, fin, rsv1, rsv2, rsv3)
if extensions is None:
extensions = []
for extension in reversed(extensions):
frame = extension.decode(frame, max_size=max_size)
frame.check()
return frame
def serialize(
self,
*,
mask: bool,
extensions: Optional[Sequence[extensions.Extension]] = None,
) -> bytes:
"""
Serialize a WebSocket frame.
Args:
mask: whether the frame should be masked i.e. whether the write
happens on the client side.
extensions: list of extensions, applied in order.
Raises:
ProtocolError: if the frame contains incorrect values.
"""
self.check()
if extensions is None:
extensions = []
for extension in extensions:
self = extension.encode(self)
output = io.BytesIO()
# Prepare the header.
head1 = (
(0b10000000 if self.fin else 0)
| (0b01000000 if self.rsv1 else 0)
| (0b00100000 if self.rsv2 else 0)
| (0b00010000 if self.rsv3 else 0)
| self.opcode
)
head2 = 0b10000000 if mask else 0
length = len(self.data)
if length < 126:
output.write(struct.pack("!BB", head1, head2 | length))
elif length < 65536:
output.write(struct.pack("!BBH", head1, head2 | 126, length))
else:
output.write(struct.pack("!BBQ", head1, head2 | 127, length))
if mask:
mask_bytes = secrets.token_bytes(4)
output.write(mask_bytes)
# Prepare the data.
if mask:
data = apply_mask(self.data, mask_bytes)
else:
data = self.data
output.write(data)
return output.getvalue()
def check(self) -> None:
"""
Check that reserved bits and opcode have acceptable values.
Raises:
ProtocolError: if a reserved bit or the opcode is invalid.
"""
if self.rsv1 or self.rsv2 or self.rsv3:
raise exceptions.ProtocolError("reserved bits must be 0")
if self.opcode in CTRL_OPCODES:
if len(self.data) > 125:
raise exceptions.ProtocolError("control frame too long")
if not self.fin:
raise exceptions.ProtocolError("fragmented control frame")
def prepare_data(data: Data) -> Tuple[int, bytes]:
"""
Convert a string or byte-like object to an opcode and a bytes-like object.
This function is designed for data frames.
If ``data`` is a :class:`str`, return ``OP_TEXT`` and a :class:`bytes`
object encoding ``data`` in UTF-8.
If ``data`` is a bytes-like object, return ``OP_BINARY`` and a bytes-like
object.
Raises:
TypeError: if ``data`` doesn't have a supported type.
"""
if isinstance(data, str):
return OP_TEXT, data.encode("utf-8")
elif isinstance(data, BytesLike):
return OP_BINARY, data
else:
raise TypeError("data must be str or bytes-like")
def prepare_ctrl(data: Data) -> bytes:
"""
Convert a string or byte-like object to bytes.
This function is designed for ping and pong frames.
If ``data`` is a :class:`str`, return a :class:`bytes` object encoding
``data`` in UTF-8.
If ``data`` is a bytes-like object, return a :class:`bytes` object.
Raises:
TypeError: if ``data`` doesn't have a supported type.
"""
if isinstance(data, str):
return data.encode("utf-8")
elif isinstance(data, BytesLike):
return bytes(data)
else:
raise TypeError("data must be str or bytes-like")
@dataclasses.dataclass
class Close:
"""
Code and reason for WebSocket close frames.
Attributes:
code: Close code.
reason: Close reason.
"""
code: int
reason: str
def __str__(self) -> str:
"""
Return a human-readable represention of a close code and reason.
"""
if 3000 <= self.code < 4000:
explanation = "registered"
elif 4000 <= self.code < 5000:
explanation = "private use"
else:
explanation = CLOSE_CODES.get(self.code, "unknown")
result = f"{self.code} ({explanation})"
if self.reason:
result = f"{result} {self.reason}"
return result
@classmethod
def parse(cls, data: bytes) -> Close:
"""
Parse the payload of a close frame.
Args:
data: payload of the close frame.
Raises:
ProtocolError: if data is ill-formed.
UnicodeDecodeError: if the reason isn't valid UTF-8.
"""
if len(data) >= 2:
(code,) = struct.unpack("!H", data[:2])
reason = data[2:].decode("utf-8")
close = cls(code, reason)
close.check()
return close
elif len(data) == 0:
return cls(1005, "")
else:
raise exceptions.ProtocolError("close frame too short")
def serialize(self) -> bytes:
"""
Serialize the payload of | |
bid=_bid)
saliva_sample_data = self._get_usable_saliva_sample(pid=participant_matrix.pids[i],
bid=_bid)
# Determine which sample ID to use
sample_data = self._determine_best_sample(blood_sample_data, saliva_sample_data)
# update the sample id, collected site, and biobank order
if sample_data is not None:
participant_matrix.sample_ids[i] = sample_data[0]
participant_matrix.site_ids[i] = sample_data[1]
participant_matrix.order_ids[i] = sample_data[2]
else:
logging.info(f'No valid samples for pid {participant_matrix.pids[i]}.')
# insert new members and make the manifest
return self.process_samples_into_manifest(
participant_matrix,
cohort=cohort,
saliva=saliva,
local=local
)
def genomic_members_insert(self, *, members, session, set_id, bids):
"""
Bulk save of member for genomic_set_member as well as PDR
batch updating of members
:param: members
:param: session
:param: set_id
:param: bids
"""
try:
session.bulk_save_objects(members)
session.commit()
members = self.member_dao.get_members_from_set_id(set_id, bids=bids)
member_ids = [m.id for m in members]
bq_genomic_set_member_batch_update(member_ids, project_id=self.controller.bq_project_id)
genomic_set_member_batch_update(member_ids)
except Exception as e:
raise Exception("Error occurred on genomic member insert: {0}".format(e))
def _get_new_biobank_samples(self, from_date):
"""
Retrieves BiobankStoredSample objects with `rdr_created`
after the last run of the new participant workflow job.
The query filters out participants that do not match the
genomic validation requirements.
:param: from_date
:return: list of tuples (bid, pid, biobank_identifier.value, collected_site_id)
"""
_new_samples_sql = self.query.new_biobank_samples()
params = {
"sample_status_param": SampleStatus.RECEIVED.__int__(),
"dob_param": GENOMIC_VALID_AGE,
"general_consent_param": QuestionnaireStatus.SUBMITTED.__int__(),
"ai_param": Race.AMERICAN_INDIAN_OR_ALASKA_NATIVE.__int__(),
"from_date_param": from_date.strftime("%Y-%m-%d"),
"withdrawal_param": WithdrawalStatus.NOT_WITHDRAWN.__int__(),
"suspension_param": SuspensionStatus.NOT_SUSPENDED.__int__(),
"cohort_3_param": ParticipantCohort.COHORT_3.__int__(),
"ignore_param": GenomicWorkflowState.IGNORE.__int__(),
}
with self.samples_dao.session() as session:
result = session.execute(_new_samples_sql, params).fetchall()
result = self._prioritize_samples_by_participant(result)
return list(zip(*result))[:-2] # Slicing to remove the last two columns retrieved for prioritization
def _prioritize_samples_by_participant(self, sample_results):
preferred_samples = {}
for sample in sample_results:
preferred_sample = sample
previously_found_sample = preferred_samples.get(sample.participant_id, None)
if previously_found_sample is not None:
preferred_sample = self._determine_best_sample(previously_found_sample, sample)
preferred_samples[sample.participant_id] = preferred_sample
return list(preferred_samples.values())
@staticmethod
def _determine_best_sample(sample_one, sample_two):
if sample_one is None:
return sample_two
if sample_two is None:
return sample_one
# Return the usable sample (status less than NOT_RECEIVED) if one is usable and the other isn't
if sample_one.status < int(SampleStatus.SAMPLE_NOT_RECEIVED) <= sample_two.status:
return sample_one
elif sample_two.status < int(SampleStatus.SAMPLE_NOT_RECEIVED) <= sample_two.status:
return sample_two
elif sample_one.status >= int(SampleStatus.SAMPLE_NOT_RECEIVED) \
and sample_two.status >= int(SampleStatus.SAMPLE_NOT_RECEIVED):
return None
# Both are usable
# Return the sample by the priority of the code: 1ED04, then 1ED10, and 1SAL2 last
test_codes_by_preference = ['1ED04', '1ED10', '1SAL2'] # most desirable first
samples_by_code = {}
for sample in [sample_one, sample_two]:
samples_by_code[sample.test] = sample
for test_code in test_codes_by_preference:
if samples_by_code.get(test_code):
return samples_by_code[test_code]
logging.error(f'Should have been able to select between '
f'{sample_one.biobank_stored_sample_id} and {sample_two.biobank_stored_sample_id}')
def _get_new_c2_participants(self, from_date):
"""
Retrieves C2 participants and validation data.
Broken out so that DNA samples' business logic is handled separately
:param from_date:
:return:
"""
_c2_participant_sql = self.query.new_c2_participants()
params = {
"sample_status_param": SampleStatus.RECEIVED.__int__(),
"dob_param": GENOMIC_VALID_AGE,
"general_consent_param": QuestionnaireStatus.SUBMITTED.__int__(),
"ai_param": Race.AMERICAN_INDIAN_OR_ALASKA_NATIVE.__int__(),
"from_date_param": from_date.strftime("%Y-%m-%d"),
"withdrawal_param": WithdrawalStatus.NOT_WITHDRAWN.__int__(),
"suspension_param": SuspensionStatus.NOT_SUSPENDED.__int__(),
"cohort_2_param": ParticipantCohort.COHORT_2.__int__(),
"ignore_param": GenomicWorkflowState.IGNORE.__int__(),
}
with self.ps_dao.session() as session:
result = session.execute(_c2_participant_sql, params).fetchall()
return list([list(r) for r in zip(*result)])
def _get_remaining_c2_participants(self):
_c2_participant_sql = self.query.remaining_c2_participants()
params = {
"sample_status_param": SampleStatus.RECEIVED.__int__(),
"dob_param": GENOMIC_VALID_AGE,
"general_consent_param": QuestionnaireStatus.SUBMITTED.__int__(),
"ai_param": Race.AMERICAN_INDIAN_OR_ALASKA_NATIVE.__int__(),
"withdrawal_param": WithdrawalStatus.NOT_WITHDRAWN.__int__(),
"suspension_param": SuspensionStatus.NOT_SUSPENDED.__int__(),
"cohort_2_param": ParticipantCohort.COHORT_2.__int__(),
"ignore_param": GenomicWorkflowState.IGNORE.__int__(),
}
with self.ps_dao.session() as session:
result = session.execute(_c2_participant_sql, params).fetchall()
return list([list(r) for r in zip(*result)])
def _get_new_c1_participants(self, from_date):
"""
Retrieves C1 participants and validation data.
:param from_date:
:return:
"""
_c1_participant_sql = self.query.new_c1_participants()
params = {
"sample_status_param": SampleStatus.RECEIVED.__int__(),
"dob_param": GENOMIC_VALID_AGE,
"general_consent_param": QuestionnaireStatus.SUBMITTED.__int__(),
"ai_param": Race.AMERICAN_INDIAN_OR_ALASKA_NATIVE.__int__(),
"from_date_param": from_date.strftime("%Y-%m-%d"),
"withdrawal_param": WithdrawalStatus.NOT_WITHDRAWN.__int__(),
"suspension_param": SuspensionStatus.NOT_SUSPENDED.__int__(),
"cohort_1_param": ParticipantCohort.COHORT_1.__int__(),
"c1_reconsent_param": COHORT_1_REVIEW_CONSENT_YES_CODE,
"ignore_param": GenomicWorkflowState.IGNORE.__int__(),
}
with self.ps_dao.session() as session:
result = session.execute(_c1_participant_sql, params).fetchall()
return list([list(r) for r in zip(*result)])
def _get_long_read_participants(self, limit=None):
"""
Retrieves participants based on filters that have
been denoted to use in the long read pilot program
"""
with self.member_dao.session() as session:
gsm_alias = aliased(GenomicSetMember)
result = session.query(GenomicSetMember).join(
ParticipantSummary,
GenomicSetMember.participantId == ParticipantSummary.participantId,
).join(
ParticipantRaceAnswers,
ParticipantRaceAnswers.participantId == ParticipantSummary.participantId,
).join(
Code,
ParticipantRaceAnswers.codeId == Code.codeId,
).join(
GenomicGCValidationMetrics,
GenomicSetMember.id == GenomicGCValidationMetrics.genomicSetMemberId,
).outerjoin(
gsm_alias,
sqlalchemy.and_(
gsm_alias.participantId == ParticipantSummary.participantId,
gsm_alias.genomeType == 'long_read'
)
).filter(
Code.value == 'WhatRaceEthnicity_Black',
GenomicSetMember.genomeType.in_(['aou_wgs']),
GenomicSetMember.genomicWorkflowState != GenomicWorkflowState.IGNORE,
GenomicGCValidationMetrics.ignoreFlag == 0,
GenomicGCValidationMetrics.contamination <= 0.01,
ParticipantSummary.participantOrigin == 'vibrent',
ParticipantSummary.ehrUpdateTime.isnot(None),
gsm_alias.id.is_(None),
).distinct(gsm_alias.biobankId)
if limit:
result = result.limit(limit)
return result.all()
def _get_usable_blood_sample(self, pid, bid):
"""
Select 1ED04 or 1ED10 based on max collected date
:param pid: participant_id
:param bid: biobank_id
:return: tuple(blood_collected date, blood sample, blood site, blood order)
"""
_samples_sql = self.query.usable_blood_sample()
params = {
"pid_param": pid,
"bid_param": bid,
}
with self.samples_dao.session() as session:
result = session.execute(_samples_sql, params).first()
return result
def _get_usable_saliva_sample(self, pid, bid):
"""
Select 1SAL2 based on max collected date
:param pid: participant_id
:param bid: biobank_id
:return: tuple(saliva date, saliva sample, saliva site, saliva order)
"""
_samples_sql = self.query.usable_saliva_sample()
params = {
"pid_param": pid,
"bid_param": bid,
}
with self.samples_dao.session() as session:
result = session.execute(_samples_sql, params).first()
return result
def _get_remaining_saliva_participants(self, config):
_saliva_sql = self.query.remaining_saliva_participants(config)
params = {
"sample_status_param": SampleStatus.RECEIVED.__int__(),
"dob_param": GENOMIC_VALID_AGE,
"general_consent_param": QuestionnaireStatus.SUBMITTED.__int__(),
"ai_param": Race.AMERICAN_INDIAN_OR_ALASKA_NATIVE.__int__(),
"withdrawal_param": WithdrawalStatus.NOT_WITHDRAWN.__int__(),
"suspension_param": SuspensionStatus.NOT_SUSPENDED.__int__(),
"ignore_param": GenomicWorkflowState.IGNORE.__int__(),
}
with self.samples_dao.session() as session:
result = session.execute(_saliva_sql, params).fetchall()
return list([list(r) for r in zip(*result)])
def _create_new_genomic_set(self):
"""Inserts a new genomic set for this run"""
attributes = {
'genomicSetName': f'new_participant_workflow_{self.run_id}',
'genomicSetCriteria': '.',
'genomicSetVersion': 1,
'genomicSetStatus': GenomicSetStatus.VALID,
}
new_set_obj = GenomicSet(**attributes)
inserted_set = self.set_dao.insert(new_set_obj)
# Insert new set for PDR
bq_genomic_set_update(inserted_set.id, project_id=self.controller.bq_project_id)
genomic_set_update(inserted_set.id)
return inserted_set
def _create_new_set_member(self, **kwargs):
"""Inserts new GenomicSetMember object"""
new_member_obj = GenomicSetMember(**kwargs)
return self.member_dao.insert(new_member_obj)
def _get_new_york_flag_from_site(self, collected_site_id):
"""
Looks up whether a collected site's state is NY
:param collected_site_id: the id of the site
:return: int (1 or 0 for NY or Not)
"""
return int(self.site_dao.get(collected_site_id).state == 'NY')
def _get_new_york_flag_from_state_id(self, state_id):
"""
Looks up whether a collected site's state is NY
:param state_id: the code ID for the state
:return: int (1 or 0 for NY or Not)
"""
return int(self.code_dao.get(state_id).value.split('_')[1] == 'NY')
def _calculate_validation_flags(self, validation_criteria):
"""
Determines validation and flags for genomic sample
:param validation_criteria:
:return: list of validation flags
"""
# Process validation flags for inserting into genomic_set_member
flags = [flag for (passing, flag) in
zip(validation_criteria, self._VALIDATION_FLAGS)
if not passing]
return flags
class ManifestDefinitionProvider:
"""
Helper class to produce the definitions for each manifest
"""
# Metadata for the various manifests
ManifestDef = namedtuple('ManifestDef', ["job_run_field",
"source_data",
"destination_bucket",
"output_filename",
"columns",
"signal"])
def __init__(
self,
job_run_id=None,
bucket_name=None,
**kwargs
):
# Attributes
self.job_run_id = job_run_id
self.bucket_name = bucket_name
self.kwargs = kwargs
self.query = GenomicQueryClass(
input_manifest=self.kwargs['kwargs'].get('input_manifest')
)
self.manifest_columns_config = {
GenomicManifestTypes.CVL_W1: (
"genomic_set_name",
"biobank_id",
"sample_id",
"sex_at_birth",
"ny_flag",
"site_id",
"secondary_validation",
"date_submitted",
"test_name",
),
GenomicManifestTypes.AW3_ARRAY: (
"chipwellbarcode",
"biobank_id",
"sample_id",
"biobankidsampleid",
"sex_at_birth",
"site_id",
"red_idat_path",
"red_idat_md5_path",
"green_idat_path",
"green_idat_md5_path",
"vcf_path",
"vcf_index_path",
"vcf_md5_path",
"callrate",
"sex_concordance",
"contamination",
"processing_status",
"research_id",
"sample_source",
"pipeline_id"
),
GenomicManifestTypes.GEM_A1: (
'biobank_id',
'sample_id',
"sex_at_birth",
"consent_for_ror",
"date_of_consent_for_ror",
"chipwellbarcode",
"genome_center",
),
GenomicManifestTypes.GEM_A3: (
'biobank_id',
'sample_id',
'date_of_consent_removal',
),
GenomicManifestTypes.CVL_W3: (
"value",
"sample_id",
"biobank_id",
"collection_tubeid",
"sex_at_birth",
"genome_type",
"ny_flag",
"request_id",
"package_id",
"ai_an",
"site_id",
),
GenomicManifestTypes.AW3_WGS: (
"biobank_id",
"sample_id",
"biobankidsampleid",
"sex_at_birth",
"site_id",
"vcf_hf_path",
"vcf_hf_index_path",
"vcf_hf_md5_path",
"cram_path",
"cram_md5_path",
"crai_path",
"gvcf_path",
"gvcf_md5_path",
"contamination",
"sex_concordance",
"processing_status",
"mean_coverage",
"research_id",
"sample_source",
"mapped_reads_pct",
"sex_ploidy"
),
GenomicManifestTypes.AW2F: (
"PACKAGE_ID",
"BIOBANKID_SAMPLEID",
"BOX_STORAGEUNIT_ID",
"BOX_ID/PLATE_ID",
"WELL_POSITION",
"SAMPLE_ID",
"PARENT_SAMPLE_ID",
"COLLECTION_TUBE_ID",
"MATRIX_ID",
"COLLECTION_DATE",
"BIOBANK_ID",
"SEX_AT_BIRTH",
"AGE",
"NY_STATE_(Y/N)",
"SAMPLE_TYPE",
"TREATMENTS",
"QUANTITY_(uL)",
"TOTAL_CONCENTRATION_(ng/uL)",
"TOTAL_DNA(ng)",
"VISIT_DESCRIPTION",
"SAMPLE_SOURCE",
"STUDY",
"TRACKING_NUMBER",
"CONTACT",
"EMAIL",
"STUDY_PI",
"TEST_NAME",
"FAILURE_MODE",
"FAILURE_MODE_DESC",
"PROCESSING_STATUS",
"CONTAMINATION",
"CONTAMINATION_CATEGORY",
"CONSENT_FOR_ROR",
),
}
def _get_source_data_query(self, manifest_type):
"""
Returns the query to use for manifest's source data
:param manifest_type:
:return: query object
"""
try:
return self.query.genomic_data_config[manifest_type]
except KeyError:
logging.warning(f"Manifest type {manifest_type} does not resolve query")
def get_def(self, manifest_type):
"""
Returns the manifest definition based on manifest_type
:param manifest_type:
:return: ManifestDef()
"""
now_formatted = clock.CLOCK.now().strftime("%Y-%m-%d-%H-%M-%S")
def_config = {
GenomicManifestTypes.CVL_W1: {
'job_run_field': 'cvlW1ManifestJobRunId',
'output_filename': f'{CVL_W1_MANIFEST_SUBFOLDER}/AoU_CVL_Manifest_{now_formatted}.csv',
'signal': 'manifest-generated'
},
GenomicManifestTypes.GEM_A1: {
'job_run_field': 'gemA1ManifestJobRunId',
'output_filename': f'{GENOMIC_GEM_A1_MANIFEST_SUBFOLDER}/AoU_GEM_A1_manifest_{now_formatted}.csv',
'signal': 'manifest-generated'
},
GenomicManifestTypes.GEM_A3: {
'job_run_field': 'gemA3ManifestJobRunId',
'output_filename': f'{GENOMIC_GEM_A3_MANIFEST_SUBFOLDER}/AoU_GEM_A3_manifest_{now_formatted}.csv',
'signal': 'manifest-generated'
},
GenomicManifestTypes.CVL_W3: {
'job_run_field': 'cvlW3ManifestJobRunID',
'output_filename': f'{CVL_W3_MANIFEST_SUBFOLDER}/AoU_CVL_W1_{now_formatted}.csv',
'signal': 'manifest-generated'
},
GenomicManifestTypes.AW3_ARRAY: {
'job_run_field': 'aw3ManifestJobRunID',
'output_filename': f'{GENOMIC_AW3_ARRAY_SUBFOLDER}/AoU_DRCV_GEN_{now_formatted}.csv',
'signal': 'bypass'
},
GenomicManifestTypes.AW3_WGS: {
'job_run_field': 'aw3ManifestJobRunID',
'output_filename': f'{GENOMIC_AW3_WGS_SUBFOLDER}/AoU_DRCV_SEQ_{now_formatted}.csv',
'signal': 'bypass'
},
GenomicManifestTypes.AW2F: {
'job_run_field': 'aw2fManifestJobRunID',
'output_filename': f'{BIOBANK_AW2F_SUBFOLDER}/GC_AoU_DataType_PKG-YYMM-xxxxxx_contamination.csv',
'signal': 'bypass'
}
}
return self.ManifestDef(
job_run_field=def_config[manifest_type]['job_run_field'],
source_data=self._get_source_data_query(manifest_type),
destination_bucket=f'{self.bucket_name}',
output_filename=def_config[manifest_type]['output_filename'],
columns=self.manifest_columns_config[manifest_type],
signal=def_config[manifest_type]['signal'],
)
class ManifestCompiler:
"""
This component compiles Genomic manifests
based on definitions provided by ManifestDefinitionProvider
"""
def __init__(
self,
run_id,
bucket_name=None,
max_num=None,
controller=None
):
self.run_id = run_id
self.bucket_name = bucket_name
self.max_num = max_num
self.controller = controller
self.output_file_name = None
self.manifest_def = None
self.def_provider = None
# Dao components
self.member_dao = GenomicSetMemberDao()
self.metrics_dao = GenomicGCValidationMetricsDao()
def generate_and_transfer_manifest(self, manifest_type, genome_type, version=None, **kwargs):
"""
Main execution method for ManifestCompiler
:return: result | |
# -*- coding: utf-8 -*-
"""
modify and save the xml file for icc profile.
============================================
"""
# import standard libraries
import os
import xml.etree.ElementTree as ET
from datetime import datetime
# import third-party libraries
import numpy as np
# import my libraries
import icc_profile_calc_param as ipcp
import color_space as cs
# information
__author__ = '<NAME>'
__copyright__ = 'Copyright (C) 2020 - <NAME>'
__license__ = 'New BSD License - https://opensource.org/licenses/BSD-3-Clause'
__maintainer__ = '<NAME>'
__email__ = 'toru.ver.11 at-sign gmail.com'
__all__ = []
RENDERING_INTENT_ABSOLUTE = "Absolute Colorimetric"
RENDERING_INTENT_RELATIVE = "Relative Colorimetric"
RENDERING_INTENT_PERCEPTUAL = "Perceptual"
RENDERING_INTENT_SATURATION = "Saturation"
def get_value_from_specific_header_tag(root, header_name):
"""
Example
-------
>>> tree = ET.parse("./aces_ap0_gm30.xml")
>>> root = tree.getroot()
>>> get_value_from_specific_header_tag(root, "RenderingIntent")
"Perceptual"
"""
header_value = None
for element in root.iter(header_name):
header_value = element.text
return header_value
def set_value_to_specific_header_tag(root, header_name, value):
"""
Example
-------
>>> tree = ET.parse("./aces_ap0_gm30.xml")
>>> root = tree.getroot()
>>> set_value_to_specific_header_tag(
... root, "RenderingIntent", "Absolute Colorimetric")
>>> get_value_from_specific_header_tag(root, "RenderingIntent")
"Absolute Colorimetric"
"""
for element in root.iter(header_name):
element.text = value
def create_current_date_str():
"""
create "YYYY-MM-DDTHH:MM:SS" format str.
"""
return datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
def get_icc_tag_element(
root, parent_tag='s15Fixed16ArrayType',
key_tag="TagSignature", key_text='chad',
target_tag='Array'):
icc_tag_element = None
for parent_element in root.iter(parent_tag):
if parent_element.find(key_tag).text == key_text:
icc_tag_element = parent_element.find(target_tag)
return icc_tag_element
def get_icc_header_element(root, tag="ProfileVersion"):
header_element = None
for element in root.iter(tag):
header_element = element
break
return header_element
def get_chad_mtx_element(root):
return get_icc_tag_element(
root, parent_tag="s15Fixed16ArrayType",
key_tag="TagSignature", key_text="chad", target_tag="Array")
def get_desc_element(root):
return get_icc_tag_element(
root, parent_tag="multiLocalizedUnicodeType",
key_tag="TagSignature", key_text="desc", target_tag="LocalizedText")
def get_cprt_element(root):
return get_icc_tag_element(
root, parent_tag="multiLocalizedUnicodeType",
key_tag="TagSignature", key_text="cprt", target_tag="LocalizedText")
def get_wtpt_element(root):
return get_icc_tag_element(
root, parent_tag="XYZType",
key_tag="TagSignature", key_text="wtpt", target_tag="XYZNumber")
def get_lumi_element(root):
return get_icc_tag_element(
root, parent_tag="XYZType",
key_tag="TagSignature", key_text="lumi", target_tag="XYZNumber")
def get_parametric_curve_element(root):
parametric_curve_element = None
parent_tag = 'parametricCurveType'
key_tag = 'ParametricCurve'
for parent_element in root.iter(parent_tag):
if parent_element.find(key_tag) is not None:
parametric_curve_element = parent_element.find(key_tag)
return parametric_curve_element
def get_rgbXYZ_element_list(root):
rgbXYZ_element_list = [None, None, None]
parent_tag = 'XYZType'
key_tag = 'TagSignature'
target_tag = 'XYZNumber'
key_text_list = ['<KEY> <KEY>']
for idx, key_text in enumerate(key_text_list):
for parent_element in root.iter(parent_tag):
if parent_element.find(key_tag).text == key_text:
rgbXYZ_element_list[idx] = parent_element.find(target_tag)
return rgbXYZ_element_list
def get_chad_matrix_from_chad_mtx_element(chad_mtx_element):
"""
Parameters
----------
chad_mtx_element : xml.etree.ElementTree.Element
An instance of the Element class. It indicate the chad tag.
Returns
-------
ndarray
chromatic adaptation matrix.
Examples
--------
>>> tree = ET.parse("./aces_ap0_gm30.xml")
>>> root = tree.getroot()
>>> chad_mtx_element = get_chad_mtx_element(root)
>>> get_chad_matrix_from_chad_mtx_element(chad_mtx_element)
[[ 1.04788208 0.02958679 -0.00924683]
[ 0.0229187 0.99047852 0.01507568]
[-0.05021667 -0.01707458 0.75167847]]
"""
text_data = chad_mtx_element.text
text_mtx_list = text_data.strip().replace("\n", "").split()
mtx = np.array([float(x) for x in text_mtx_list]).reshape((3, 3))
return mtx
def set_chad_matrix_to_chad_mtx_element(mtx, chad_mtx_element):
"""
Parameters
----------
mtx : ndarray
chromatic adaptation matrix
chad_mtx_element : xml.etree.ElementTree.Element
An instance of the Element class. It indicate the chad tag.
Returns
-------
None
Examples
--------
>>> tree = ET.parse("./aces_ap0_gm30.xml")
>>> root = tree.getroot()
>>> chad_mtx_element = get_chad_mtx_element(root)
>>> print(chad_mtx_element.text)
1.04788208 0.02291870 -0.05021667
0.02958679 0.99047852 -0.01707458
-0.00924683 0.01507568 0.75167847
>>> mtx = np.array([
... [0.1, 0.2, 0.3],
... [0.4, 0.5, 0.6],
... [0.7, 0.8, 0.9]])
>>> set_chad_matrix_to_chad_mtx_element(mtx, chad_mtx_element)
>>> print(chad_mtx_element.text)
0.10000000 0.20000000 0.30000000
0.40000000 0.50000000 0.60000000
0.70000000 0.80000000 0.90000000
"""
head_space = " " * 12
foot_space = " " * 6
buf = "\n"
buf += f"{head_space}{mtx[0][0]:.8f} {mtx[0][1]:.8f} {mtx[0][2]:.8f}\n"
buf += f"{head_space}{mtx[1][0]:.8f} {mtx[1][1]:.8f} {mtx[1][2]:.8f}\n"
buf += f"{head_space}{mtx[2][0]:.8f} {mtx[2][1]:.8f} {mtx[2][2]:.8f}\n"
buf += foot_space
chad_mtx_element.text = buf
def get_parametric_curve_params_from_element(parameteric_curve_element):
"""
Parameters
----------
parameteric_curve_element : xml.etree.ElementTree.Element
An instance of the Element class. It indicate the ParametricCurve tag.
Returns
-------
function_type_str : str
A string of function type.
params : ndarray
A one-dimensional parameter array.
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> parameteric_curve_element = get_parametric_curve_element(root)
>>> function_type, params = get_parametric_curve_params_from_element(
... parameteric_curve_element)
>>> print(function_type)
3
>>> print(params)
[ 2.39999390 0.94786072 0.05213928 0.07739258 0.04045105 ]
"""
function_type_str = parameteric_curve_element.attrib['FunctionType']
text_data = parameteric_curve_element.text
param_str_list = text_data.strip().replace("\n", "").split()
param_ndarray = np.array([float(x) for x in param_str_list])
return function_type_str, param_ndarray
def set_parametric_curve_params_to_element(
function_type_str, params, parameteric_curve_element):
"""
Parameters
----------
function_type_str : str
A function type.
'0' : simple power function
'3' : sRGB like function
params : ndarray
An array of the function parameters.
parameteric_curve_element : xml.etree.ElementTree.Element
An instance of the Element class. It indicate the ParametricCurve tag.
Returns
-------
None
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> parameteric_curve_element = get_parametric_curve_element(root)
>>> function_type = "2"
>>> params = np.array([2.4, 0.1, 0.2, 0.3])
>>> set_parametric_curve_params_to_element(
... function_type, params, parameteric_curve_element)
>>> print(parameteric_curve_element.attrib)
{'FunctionType': '2'}
>>> print(parameteric_curve_element.text)
2.39999390 0.10000000 0.20000000 0.30000000
"""
parameteric_curve_element.attrib['FunctionType'] = function_type_str
head_space = '\n' + " " * 8
foot_space = " " * 6
buf = head_space
param_str_array = [f"{x:.8f}" for x in params]
buf += " ".join(param_str_array) + '\n' + foot_space
parameteric_curve_element.text = buf
def get_rgbXYZ_params_from_element(rgbXYZ_element_list):
"""
Parameters
----------
rgbXYZ_element_list : list
list of xml.etree.ElementTree.Element.
Returns
-------
ndarray
A 3x3 matrix that convert from src color space to the PCS.
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> rgb_XYZ_element_list = get_rgbXYZ_element_list(root)
>>> get_rgbXYZ_params_from_element(rgbXYZ_element_list)
[[ 0.51512146 0.29197693 0.15710449]
[ 0.24119568 0.69224548 0.0665741 ]
[-0.00105286 0.04188538 0.78407288]]
"""
src2pcs_mtx = np.zeros((3, 3))
for idx, rgb_XYZ_element in enumerate(rgbXYZ_element_list):
src2pcs_mtx[0][idx] = float(rgb_XYZ_element.attrib['X'])
src2pcs_mtx[1][idx] = float(rgb_XYZ_element.attrib['Y'])
src2pcs_mtx[2][idx] = float(rgb_XYZ_element.attrib['Z'])
return np.array(src2pcs_mtx)
def set_rgbXYZ_params_to_element(src2pcs_mtx, rgb_XYZ_element_list):
"""
Parameters
----------
src2pcs_mtx : ndarray
A 3x3 matrix that convert from src color space to the PCS.
rgbXYZ_element_list : list
list of xml.etree.ElementTree.Element.
Returns
-------
ndarray
A 3x3 matrix that convert from src color space to the PCS.
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> rgb_XYZ_element_list = get_rgbXYZ_element_list(root)
>>> src2pcs_mtx = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
>>> set_rgbXYZ_params_to_element(src2pcs_mtx, rgb_XYZ_element_list)
>>> for rgb_XYZ_element in rgb_XYZ_element_list:
... print(rgb_XYZ_element.attrib)
{'X': '0.00000000', 'Y': '3.00000000', 'Z': '6.00000000'}
{'X': '1.00000000', 'Y': '4.00000000', 'Z': '7.00000000'}
{'X': '2.00000000', 'Y': '5.00000000', 'Z': '8.00000000'}
"""
for idx, rgb_XYZ_element in enumerate(rgb_XYZ_element_list):
rgb_XYZ_element.attrib['X'] = f"{src2pcs_mtx[0][idx]:.08f}"
rgb_XYZ_element.attrib['Y'] = f"{src2pcs_mtx[1][idx]:.08f}"
rgb_XYZ_element.attrib['Z'] = f"{src2pcs_mtx[2][idx]:.08f}"
def get_lumi_params_from_element(lumi_element):
"""
Parameters
----------
lumi_element : xml.etree.ElementTree.Element
elemnent of the lumi tag.
Returns
-------
float
luminance of the reference white.
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> lumi_element = get_lumi_element(root)
>>> get_lumi_params_from_element(lumi_element)
100.0
"""
return float(lumi_element.attrib['Y'])
def set_lumi_params_to_element(luminance, lumi_element):
"""
Parameters
----------
luminance : float
luminance of the reference white.
lumi_element : xml.etree.ElementTree.Element
elemnent of the lumi tag.
Returns
-------
None
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> lumi_element = get_lumi_element(root)
>>> set_lumi_params_to_element(333.3, lumi_element)
>>> get_lumi_params_from_element(lumi_element)
333.3
"""
lumi_element.attrib['Y'] = f"{luminance:.8f}"
def get_wtpt_params_from_element(wtpt_element):
"""
Parameters
----------
wtpt_element : xml.etree.ElementTree.Element
elemnent of the wtpt tag.
Returns
-------
ndarray
white point in large XYZ format.
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> wtpt_element = get_wtpt_element(root)
>>> get_wtpt_params_from_element(wtpt_element)
[ 0.96420288 1. 0.8249054 ]
"""
large_xyz = np.array(
[float(wtpt_element.attrib['X']),
float(wtpt_element.attrib['Y']),
float(wtpt_element.attrib['Z'])])
return large_xyz
def set_wtpt_params_to_element(wtpt, wtpt_element):
"""
Parameters
----------
wtpt : ndarray
white point in large XYZ format.
wtpt_element : xml.etree.ElementTree.Element
elemnent of the wtpt tag.
Returns
-------
None
Examples
--------
>>> tree = ET.parse("./p3-2.xml")
>>> root = tree.getroot()
>>> wtpt_element = get_wtpt_element(root)
>>> wtpt = np.array([0.9, 1.0, 0.8])
>>> set_wtpt_params_to_element(wtpt, wtpt_element)
>>> get_wtpt_params_from_element(wtpt_element)
[ 0.90000000 1.0000000 0.80000000 ]
"""
wtpt_element.attrib['X'] = f"{wtpt[0]:.8f}"
wtpt_element.attrib['Y'] = f"{wtpt[1]:.8f}"
wtpt_element.attrib['Z'] = f"{wtpt[2]:.8f}"
def xml_parse_test():
tree = ET.parse("./icc_profile_sample/p3-2.xml")
root = tree.getroot()
chad_mtx_element = get_chad_mtx_element(root)
print(chad_mtx_element.text)
get_chad_matrix_from_chad_mtx_element(chad_mtx_element)
set_chad_matrix_to_chad_mtx_element(
mtx=np.ones((3, 3)), chad_mtx_element=chad_mtx_element)
print(chad_mtx_element.text)
desc_element = get_desc_element(root)
print(desc_element.text)
cprt_element = get_cprt_element(root)
print(cprt_element.text)
profile_ver_element = get_icc_header_element(root, tag="ProfileVersion")
print(profile_ver_element.text)
color_space_element = get_icc_header_element(root, tag="DataColourSpace")
print(color_space_element.text)
parameteric_curve_element = get_parametric_curve_element(root)
print(parameteric_curve_element.text)
function_type, params = get_parametric_curve_params_from_element(
parameteric_curve_element)
print(function_type)
print(params)
function_type = "2"
params = np.array([2.4, 0.1, 0.2, 0.3])
set_parametric_curve_params_to_element(
function_type, params, parameteric_curve_element)
print(parameteric_curve_element.attrib)
print(parameteric_curve_element.text)
rgb_XYZ_element_list = get_rgbXYZ_element_list(root)
for rgb_XYZ_element in rgb_XYZ_element_list:
print(rgb_XYZ_element.attrib)
src2pcs_mtx = get_rgbXYZ_params_from_element(rgb_XYZ_element_list)
print(src2pcs_mtx)
src2pcs_mtx = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
set_rgbXYZ_params_to_element(src2pcs_mtx, rgb_XYZ_element_list)
for rgb_XYZ_element in rgb_XYZ_element_list:
print(rgb_XYZ_element.attrib)
ri = get_value_from_specific_header_tag(root, "RenderingIntent")
print(ri)
set_value_to_specific_header_tag(
root, "RenderingIntent", RENDERING_INTENT_PERCEPTUAL)
current_time_str = create_current_date_str()
print(current_time_str)
wtpt_element = get_wtpt_element(root)
print(wtpt_element.attrib)
lumi_element = get_lumi_element(root)
print(get_lumi_params_from_element(lumi_element))
set_lumi_params_to_element(1000.0, lumi_element)
wtpt_element = get_wtpt_element(root)
print(wtpt_element.attrib)
print(get_wtpt_params_from_element(wtpt_element))
wtpt = np.array([0.123, 0.46, 0.88])
set_wtpt_params_to_element(wtpt, wtpt_element)
tree.write("test_out.xml")
def create_profle_header(root):
"""
create the profile header.
"""
set_value_to_specific_header_tag(
root, "PreferredCMMType", "ADBE")
set_value_to_specific_header_tag(
root, "ProfileVersion", "4.30")
set_value_to_specific_header_tag(
root, "CreationDateTime", create_current_date_str())
set_value_to_specific_header_tag(
root, "PrimaryPlatform", "MSFT")
set_value_to_specific_header_tag(
root, "DeviceManufacturer", "")
set_value_to_specific_header_tag(
root, "DeviceModel", "")
set_value_to_specific_header_tag(
root, "ProfileCreator", "")
set_value_to_specific_header_tag(
root, "ProfileID", "")
def create_simple_power_gamma_profile(
gamma=2.4, src_white=np.array([0.3127, 0.3290]),
src_primaries=np.array([[0.680, 0.320], [0.265, 0.690], [0.15, 0.06]]),
desc_str="Gamam=2.4_DCI-P3_D65",
cprt_str="Copyright 2020 HOGEHOGE Corp.",
output_name="Gamam=2.4_DCI-P3_D65.xml"):
"""
create simple profile.
gamma function must be "y = x ** gamma" format.
"""
tree = ET.parse("./icc_profile_sample/base_profile_v4.xml")
root = tree.getroot()
| |
lista de asistencias de mes son {0}".format(asistencias_curso_mes))
matriculados_aula = AulaMatricula.objects.filter(aula=aula).order_by('matricula__alumno__apellido_pa')
alumnos = []
for matriculado in matriculados_aula:
alumnos.append(matriculado.matricula.alumno)
num_alumnos = len(alumnos)
logger.info("El número de alumnos matriculados en esta aula es {0}".format(num_alumnos))
fechas = []
lista_asistencias_dia = []
for dia in range(0, num_dias):
asistencias_curso_dia = asistencias_curso_mes.filter(fecha__day=dia+1)
logger.info("La lista de asistencias del día {0} mes son {1}".format(dia+1, asistencias_curso_dia))
n = 0
for asistencias_dias in asistencias_curso_dia:
lista_asistencias_dia.append(asistencias_dias.estado_asistencia)
if n == 0:
fechas.append(asistencias_dias.fecha)
n = n + 1
num_horizontal = len(fechas)
num_vertical = len(alumnos)
aula_selected = Aula.objects.get(id_aula=aula)
logger.info("La lista de asistencias de mes son {0}".format(lista_asistencias_dia))
logger.info("La lista de fechas de mes son {0}".format(fechas))
contexto = self.VisualizarAsistenciaform(request)
contexto['asistencias'] = asistencias_curso_mes
contexto['num_hor'] = num_horizontal
contexto['num_ver'] = num_vertical
contexto['fechas'] = fechas
contexto['alumnos'] = alumnos
contexto['mes_selected'] = mes
contexto['aula_selected'] = aula_selected
return render(request, template_name=self.template_name, context=contexto)
#################################################
##### NOTAS ALUMNOS #####
#################################################
#################################################
##### EVENTOS #####
#################################################
class EventoCreateView(CreateView):
model = Evento
form_class = EventoForm
template_name = "evento_form.html"
success_url = reverse_lazy("academic:evento_list")
def form_valid(self, form):
form.instance.colegio = Colegio.objects.get(pk=get_current_colegio())
return super(EventoCreateView, self).form_valid(form)
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
personalcolegio = PersonalColegio.objects.filter(colegio_id=get_current_colegio(), activo=True)
personal = []
for personalcol in personalcolegio:
personal.append(personalcol.personal)
return render(request, template_name=self.template_name, context={
'form': self.form_class,
'empleados': personal,
})
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
class EventoListView(ListView):
model = Evento
form_class = EventoForm
template_name = "evento_list.html"
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
evento = Evento.objects.filter(colegio_id=get_current_colegio())
return render(request, template_name=self.template_name, context={
'eventos':evento,
})
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
class EventoDetailView(DetailView):
model = Evento
form_class = EventoForm
template_name = "evento_detail.html"
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
evento = Evento.objects.get(id_evento=request.GET['evento'])
return render(request, template_name=self.template_name, context={
'evento':evento,
})
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
#################################################
##### CRUD DE MATRICULA AULA #####
#################################################
class AulaMatriculaCreateView(TemplateView):
model = AulaMatricula
success_url = reverse_lazy('academic:aula_list')
template_name = 'aulamatricula_form.html'
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
no_matriculados_aulas = []
aula_actual = Aula.objects.get(id_aula=request.GET['aula'])
matriculas = Matricula.objects.filter(tipo_servicio=aula_actual.tipo_servicio,colegio_id=get_current_colegio(), activo=True)
for matricula in matriculas:
alumno_aula = AulaMatricula.objects.filter(matricula=matricula, activo = True)
if alumno_aula:
logger.info("El alumno {0} ya tiene aula".format(matricula.alumno))
else:
no_matriculados_aulas.append(matricula)
return render(request, template_name=self.template_name, context={
'aula': aula_actual,
'matriculas': no_matriculados_aulas,
})
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
def post(self, request, *args, **kwargs):
logger.info(request.POST)
aula_actual = Aula.objects.get(id_aula=request.POST['aula'])
matriculas = Matricula.objects.filter(tipo_servicio=aula_actual.tipo_servicio, colegio_id=get_current_colegio(),
activo=True)
data_form = request.POST
for matricula in matriculas:
try:
text = "item{0}".format(matricula.id_matricula)
if data_form[text]:
aulamatricula = self.model(
aula=aula_actual,
matricula=matricula,
)
aulamatricula.save()
logger.info("se creo un registro")
except:
logger.info("hay un error")
return HttpResponseRedirect(reverse('academic:aula_list'))
class AulaMatriculaDeleteView(TemplateView):
model = AulaMatricula
template_name = "aulamatricula_form.html"
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
print(request.GET['alumno'])
matricula = Matricula.objects.get(id_matricula=int(request.GET['alumno']))
alumno = AulaMatricula.objects.get(matricula=matricula)
alumno.activo = False
alumno.save()
return HttpResponseRedirect(reverse('academic:aula_list'))
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
#################################################
##### CRUD DE PERIODO ACADEMICO #####
#################################################
class PeriodoAcademicoListView(MyLoginRequiredMixin, ListView):
model = PeriodoAcademico
template_name = 'periodo_list.html'
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
return super(PeriodoAcademicoListView, self).get(request, *args, **kwargs)
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
def get_context_data(self, **kwargs):
context = super(PeriodoAcademicoListView, self).get_context_data(**kwargs)
request = get_current_request()
if request.session.get('colegio'):
id = request.session.get('colegio')
context['idcolegio'] = id
return context
class PeriodoAcademicoDetailView(UpdateView):
model = PeriodoAcademico
form_class = PeriodoAcademicoForm
template_name = 'periodo_detail.html'
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
return super(PeriodoAcademicoDetailView, self).get(request, *args, **kwargs)
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
class PeriodoAcademicoCreationView(CreateView):
model = PeriodoAcademico
form_class = PeriodoAcademicoForm
success_url = reverse_lazy('academic:periodo_list')
template_name = 'periodo_form.html'
def form_valid(self, form):
form.instance.colegio = Colegio.objects.get(pk=get_current_colegio())
return super(PeriodoAcademicoCreationView, self).form_valid(form)
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo']
if validar_roles(roles=roles):
return super(PeriodoAcademicoCreationView, self).get(request, *args, **kwargs)
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
class PeriodoAcademicoUpdateView(UpdateView):
model = PeriodoAcademico
form_class = PeriodoAcademicoForm
success_url = reverse_lazy('academic:periodo_list')
template_name = 'periodo_form.html'
#####################################################
##### NOTAS DE ALUMNOS #####
#####################################################
class RegistrarNotasAlumnosView(TemplateView):
model = Notas
template_name = 'notas_registrar.html'
success_url = reverse_lazy('academic:asistencia_registrar_dia')
form2 = RegistrarNotas2Form
def RegistrarNotas1Form(self, request):
roles = ['promotor', 'director']
if validar_roles(roles=roles):
# Cargamos las aulas relacionadas al colegio
id_colegio = get_current_colegio()
periodos_colegio = PeriodoAcademico.objects.filter(colegio=id_colegio).order_by('nombre')
if periodos_colegio.count() == 0:
periodos_colegio = ["No hay periodos registrados"]
# Cargamos las aulas relacionadas al colegio
id_colegio = get_current_colegio()
aulas_colegio = Aula.objects.filter(tipo_servicio__colegio=id_colegio).order_by('nombre')
if aulas_colegio.count() == 0:
aulas_colegio = ["No hay aulas registradas"]
cursos =[]
cursos_aula = AulaCurso.objects.filter(curso__colegio=id_colegio)
for curso_aula in cursos_aula:
cursos.append(curso_aula.curso)
return {'aulas_colegio': aulas_colegio, 'periodos_colegio': periodos_colegio, 'cursos_aula': cursos}
else:
mensaje_error = "No tienes acceso a esta vista"
return {'mensaje_error': mensaje_error} # return context
def get(self, request, *args, **kwargs):
super(RegistrarNotasAlumnosView, self).get(request, *args, **kwargs)
contexto = self.RegistrarNotas1Form(request)
contexto2 ={'form2': self.form2}
contexto.update(contexto2)
if 'mensaje_error' in contexto.keys():
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
else:
return render(request, self.template_name, contexto) # return context
def post(self, request, *args, **kwargs):
logger.info("Estoy en el POST")
logger.info("Los datos de llegada son {0}".format(request.POST))
if 'aula' in request.POST.keys():
aula = request.POST["aula"]
periodo = request.POST["periodo_academico"]
curso = request.POST["curso"]
aula_selected = Aula.objects.get(id_aula=aula)
periodo_selected = PeriodoAcademico.objects.get(id_periodo_academico=periodo)
curso_selected = Curso.objects.get(id_curso=curso)
matriculadosaula = AulaMatricula.objects.filter(aula=aula).order_by('matricula__alumno__apellido_pa')
logger.info("Datos son {0}".format(matriculadosaula))
alumnos = []
for matriculado in matriculadosaula:
alumnos.append(matriculado.matricula.alumno)
contexto = self.RegistrarNotas1Form(request)
contexto2 = {'form2': self.form2}
contexto.update(contexto2)
contexto['alumnos'] = alumnos
contexto['aula_selected'] = aula_selected
contexto['periodo_selected'] = periodo_selected
contexto['curso_selected'] = curso_selected
return render(request, template_name=self.template_name, context=contexto)
else:
logger.info("Estoy en el POST")
logger.info("Los datos de llegada son {0}".format(request.POST))
data_post = request.POST
alumnos_id = data_post.getlist('id')
notas = data_post.getlist('nota')
curso_id = data_post['curso']
periodo_id = data_post['periodo']
colegio_id = get_current_colegio()
curso = Curso.objects.get(id_curso=curso_id)
periodo = PeriodoAcademico.objects.get(id_periodo_academico=periodo_id)
colegio = Colegio.objects.get(id_colegio=colegio_id)
num = len(alumnos_id)
for n in range(0, num):
alumno = Alumno.objects.get(id_alumno=alumnos_id[n])
nota = Notas(alumno=alumno, curso=curso, periodo_academico=periodo, nota=notas[n], colegio=colegio)
nota.save()
return redirect('academic:notas_ver')
class VisualizarNotasView(TemplateView):
model = Notas
template_name = "notas_ver.html"
def VisualizarNotasform(self, request):
roles = ['promotor', 'director']
if validar_roles(roles=roles):
# Cargamos los meses
meses_todos = ["Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto",
"Setiembre", "Octubre", "Noviembre", "Diciembre"]
num_mes = datetime.date.today().month
meses = []
for i in range(0, num_mes + 1):
meses.append(meses_todos[i])
id_colegio = get_current_colegio()
aulas = Aula.objects.filter(tipo_servicio__colegio=id_colegio).order_by('nombre')
return {'meses': meses_todos, 'aulas': aulas}
else:
mensaje_error = "No tienes acceso a esta vista"
return {'mensaje_error': mensaje_error} # return context
def get(self, request, *args, **kwargs):
super(VisualizarAsistenciaView, self).get(request, *args, **kwargs)
contexto = self.VisualizarAsistenciaform(request)
if 'mensaje_error' in contexto.keys():
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
else:
return render(request, self.template_name, contexto) # return context
def post(self, request, *args, **kwargs):
mes = request.POST["mes"]
aula = request.POST["aula"]
num_mes = obtener_mes(mes)
logger.info("Estoy en el Post, datos de llegada son {0}".format(request.POST))
meses_dias = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
num_dias = meses_dias[num_mes - 1]
# id_curso =
asistencias_curso = self.model.objects.filter()
# Proceso de filtrado según el año
anio = datetime.date.today().year
asistencias_curso_anio = asistencias_curso.filter(fecha__year=anio)
# Proceso de filtrado según el mes
asistencias_curso_mes = asistencias_curso_anio.filter(fecha__month=num_mes)
logger.info("La lista de asistencias de mes son {0}".format(asistencias_curso_mes))
matriculados_aula = AulaMatricula.objects.filter(aula=aula).order_by('matricula__alumno__apellido_pa')
alumnos = []
for matriculado in matriculados_aula:
alumnos.append(matriculado.matricula.alumno)
num_alumnos = len(alumnos)
logger.info("El número de alumnos matriculados en esta aula es {0}".format(num_alumnos))
fechas = []
lista_asistencias_dia = []
for dia in range(0, num_dias):
asistencias_curso_dia = asistencias_curso_mes.filter(fecha__day=dia + 1)
logger.info(
"La lista de asistencias del día {0} mes son {1}".format(dia + 1, asistencias_curso_dia))
n = 0
for asistencias_dias in asistencias_curso_dia:
lista_asistencias_dia.append(asistencias_dias.estado_asistencia)
if n == 0:
fechas.append(asistencias_dias.fecha)
n = n + 1
num_horizontal = len(fechas)
num_vertical = len(alumnos)
aula_selected = Aula.objects.get(id_aula=aula)
logger.info("La lista de asistencias de mes son {0}".format(lista_asistencias_dia))
logger.info("La lista de fechas de mes son {0}".format(fechas))
contexto = self.VisualizarAsistenciaform(request)
contexto['asistencias'] = asistencias_curso_mes
contexto['num_hor'] = num_horizontal
contexto['num_ver'] = num_vertical
contexto['fechas'] = fechas
contexto['alumnos'] = alumnos
contexto['mes_selected'] = mes
contexto['aula_selected'] = aula_selected
return render(request, template_name=self.template_name, context=contexto)
#################################################
##### HORARIOS DE CURSOS #####
#################################################
class HorarioAulaCreateView(CreateView):
model = HorarioAula
form_class = HorarioAulaForm
success_url = reverse_lazy('academic:aula_list')
template_name = 'horarios_aula.html'
"""
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo', 'tesorero']
if validar_roles(roles=roles):
curso = CursoDocente.objects.filter(curso=request.GET["curso"], activo=True)
return render(request, template_name=self.template_name, context={
'form': self.form_class,
'curso': curso,
})
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
"""
def get_cursos(request):
if request.is_ajax():
id_aula = request.GET.get("id_aula", " ")
aula_cursos = AulaCurso.objects.filter(aula__id_aula=int(id_aula))
results = []
for aula_curso in aula_cursos:
aula_curso_json = {}
aula_curso_json['id'] = aula_curso.curso.id_curso
aula_curso_json['value'] = aula_curso.curso.nombre
results.append(aula_curso_json)
data = json.dumps(results)
else:
data = 'fail'
mimetype = 'application/json'
return HttpResponse(data, mimetype)
#########################################
###### RECORDATORIOS TAREAS Y PCS #######
#########################################
class RecordatorioAulaCreateView(CreateView):
model = RecordatorioAula
success_url = reverse_lazy('academic:aula_list')
template_name = 'recordatorio_aula_form.html'
form_class = RecordatorioAulaForm
def get(self, request, *args, **kwargs):
roles = ['promotor', 'director', 'administrativo', 'tesorero']
if validar_roles(roles=roles):
aula_actual = Aula.objects.get(id_aula=request.GET['aula'])
return render(request, template_name=self.template_name, context={
'aula': aula_actual,
'form': self.form_class,
})
else:
return HttpResponseRedirect(settings.REDIRECT_PERMISOS)
def post(self, request, *args, **kwargs):
data_form = request.POST
aula = Aula.objects.get(id_aula=request.POST['aula'])
nombre = data_form['nombre']
fecha = data_form['fecha_programacion']
estado = 1 # ESTO SIGNIFICA QUE EL EVENTO FUE CREADO
descripcion | |
import xarray as xr
import numpy as np
import datetime
import healpy as hp
import time
from torch.utils.data import Dataset, DataLoader
from modules.data import WeatherBenchDatasetIterative
# Utils
def _inner(x, y):
result = np.matmul(x[..., np.newaxis, :], y[..., :, np.newaxis])
return result[..., 0, 0]
def inner_product(x, y, dim):
return xr.apply_ufunc(_inner, x, y, input_core_dims=[[dim], [dim]])
def create_iterative_observations_healpix(ds, lead_time, max_lead_time, nb_timesteps, test_years, nodes):
lead_times = np.arange(lead_time, max_lead_time + lead_time, lead_time)
data = ds.to_array(dim='level', name='Dataset').transpose('time', 'node', 'level')
n_samples = data.isel(time=slice(0, -nb_timesteps*lead_time)).shape[0] - max_lead_time
obs_list = []
for lead in lead_times:
obs_list.append(data.isel(time=slice(lead, lead + n_samples)).isel(level=slice(0, 2)).values)
observations_numpy = np.array(obs_list)
# Lat lon coordinates
nside = int(np.sqrt(nodes/12))
out_lon, out_lat = hp.pix2ang(nside, np.arange(nodes), lonlat=True)
# Actual times
start = np.datetime64(test_years[0], 'h') + np.timedelta64(lead_time, 'h')
stop = start + np.timedelta64(n_samples, 'h')
times = np.arange(start, stop)
# Variables
var_dict_out = {var: None for var in ['z', 't']}
das = [];
lev_idx = 0
for var, levels in var_dict_out.items():
if levels is None:
das.append(xr.DataArray(
observations_numpy[:, :, :, lev_idx],
dims=['lead_time', 'time', 'node'],
coords={'lead_time': lead_times, 'time': times, 'node': np.arange(nodes)},
name=var
))
lev_idx += 1
else:
nlevs = len(levels)
das.append(xr.DataArray(
observations_numpy[:, :, :, lev_idx:lev_idx+nlevs],
dims=['lead_time', 'time', 'node', 'level'],
coords={'lead_time': lead_times, 'time': valid_time, 'node': nodes, 'level': nlevs},
name=var
))
lev_idx += nlevs
observation_ds = xr.merge(das)
observation_ds = observation_ds.assign_coords({'lat': out_lat, 'lon': out_lon})
return observation_ds
def create_iterative_observations_hp(input_dir, test_years, lead_time, max_lead_time, nside, nb_timesteps=2):
z500 = xr.open_mfdataset(f'{input_dir}geopotential_500/*.nc', combine='by_coords').sel(time=slice(*test_years))
t850 = xr.open_mfdataset(f'{input_dir}temperature_850/*.nc', combine='by_coords').sel(time=slice(*test_years))
test_data = xr.merge([z500, t850], compat='override')
n_samples = test_data.isel(time=slice(0, -nb_timesteps*lead_time)).dims['time'] - max_lead_time
nb_iter = max_lead_time // lead_time
n_pixels = 12*(nside**2)
# Lead times
lead_times = np.arange(lead_time, max_lead_time + lead_time, lead_time)
# Lat lon coordinates
out_lon, out_lat = hp.pix2ang(nside, np.arange(n_pixels), lonlat=True)
# Actual times
start = np.datetime64(test_years[0], 'h') + np.timedelta64(lead_time, 'h')
stop = start + np.timedelta64(n_samples, 'h')
times = np.arange(start, stop, 1)
# Variables
data_vars = ['z', 't']
var_dict_out = {var: None for var in data_vars}
data = np.zeros((2, nb_iter, n_samples, 32, 64))
for i in range(nb_iter):
data[0, i, :, :, :] = test_data.z.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values
data[1, i, :, :, :] = test_data.t.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values
das = [];
lev_idx = 0
for var in data_vars:
das.append(xr.DataArray(
data[lev_idx, :, :, :],
dims=['lead_time', 'time', 'node'],
coords={'lead_time': lead_times, 'time': times, 'node': np.arange(n_pixels)},
name=var
))
lev_idx += 1
observations = xr.merge(das)
observations = observations.assign_coords({'lat': out_lat, 'lon': out_lon})
return observations
def create_iterative_observations_eq(input_dir, test_years, lead_time, max_lead_time, nside, nb_timesteps=2):
z500 = xr.open_mfdataset(f'{input_dir}geopotential_500/*.nc', combine='by_coords').sel(time=slice(*test_years))
t850 = xr.open_mfdataset(f'{input_dir}temperature_850/*.nc', combine='by_coords').sel(time=slice(*test_years))
test_data = xr.merge([z500, t850], compat='override')
n_samples = test_data.isel(time=slice(0, -nb_timesteps*lead_time)).dims['time'] - max_lead_time
nb_iter = max_lead_time // lead_time
n_pixels = 12*(nside**2)
# Lead times
lead_times = np.arange(lead_time, max_lead_time + lead_time, lead_time)
# Actual times
start = np.datetime64(test_years[0], 'h') + np.timedelta64(lead_time, 'h')
stop = start + np.timedelta64(n_samples, 'h')
times = np.arange(start, stop, 1)
# Variables
data_vars = ['z', 't']
var_dict_out = {var: None for var in data_vars}
data = np.zeros((2, nb_iter, n_samples, 32, 64))
for i in range(nb_iter):
data[0, i, :, :, :] = test_data.z.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values
data[1, i, :, :, :] = test_data.t.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values
das = [];
lev_idx = 0
for var in data_vars:
das.append(xr.DataArray(
data[lev_idx, :, :, :, :],
dims=['lead_time', 'time', 'lat', 'lon'],
coords={'lead_time': lead_times, 'time': times, 'lat': test_data.lat.values, 'lon': test_data.lon.values},
name=var
))
lev_idx += 1
observations = xr.merge(das)
return observations
# Predict
def create_iterative_predictions_healpix(model, device, dg):
batch_size = dg.batch_size
delta_t = dg.dataset.lead_time
max_lead_time = dg.dataset.max_lead_time
initial_lead_time = delta_t
nodes = dg.dataset.nodes
nside = int(np.sqrt(nodes/12))
n_samples = dg.dataset.n_samples
in_feat = dg.dataset.in_features
out_feat = dg.dataset.out_features
data_vars = dg.dataset.mean.level.values.tolist()[:out_feat]
train_std = dg.dataset.std.values[:out_feat]
train_mean = dg.dataset.mean.values[:out_feat]
# Lead times
lead_times = np.arange(delta_t, max_lead_time + delta_t, delta_t)
# Lat lon coordinates
out_lon, out_lat = hp.pix2ang(nside, np.arange(nodes), lonlat=True)
# Actual times
start = np.datetime64(dg.dataset.years[0], 'h') + np.timedelta64(initial_lead_time, 'h')
stop = start + np.timedelta64(dg.dataset.n_samples, 'h')
times = np.arange(start, stop)
# Variables
var_dict_out = {var: None for var in data_vars}
# Radiation
constants = np.array(dg.dataset.data.isel(level=slice(out_feat, None)).values)
dataloader = dg
predictions = []
model.eval()
for lead in lead_times:
outputs = []
state = []
states = np.empty((n_samples, nodes, in_feat))
time1 = time.time()
for i, (sample, _) in enumerate(dataloader):
inputs = sample[0].to(device)
output = model(inputs)
outputs.append(output.detach().cpu().clone().numpy()[:, :, :out_feat])
state.append(output.detach().cpu().clone().numpy())
preds = np.concatenate(outputs)
states[:, :, :out_feat] = np.concatenate(state)
states[:, :, out_feat:] = constants[lead:n_samples+lead, :]
predictions.append(preds * train_std + train_mean)
new_set = WeatherBenchDatasetIterative(states)
dataloader = DataLoader(new_set, batch_size=batch_size, shuffle=False, num_workers=10)
time2 = time.time()
predictions = np.array(predictions)
das = [];
lev_idx = 0
for var in data_vars:
das.append(xr.DataArray(
predictions[:, :, :, lev_idx],
dims=['lead_time', 'time', 'node'],
coords={'lead_time': lead_times, 'time': times, 'node': np.arange(nodes)},
name=var
))
lev_idx += 1
prediction_ds = xr.merge(das)
prediction_ds = prediction_ds.assign_coords({'lat': out_lat, 'lon': out_lon})
return prediction_ds
def create_predictions(model, device, dg):
"""Create direct predictions for models using 1D signals (eg GCNN)
Parameters
----------
model : torch.nn.Module
Trained model
device
GPU / CPU where model is running
dg : DataLoader
Test data
Returns
-------
predictions : xr.Dataset
Model predictions
"""
lats = np.arange(-90+dg.dataset.res/2, 90+dg.dataset.res/2, dg.dataset.res)
lons = np.arange(0, 360, dg.dataset.res)
lat = xr.DataArray(lats, coords=[lats], dims=['lat'], name='lat')
lon = xr.DataArray(lons, coords=[lons], dims=['lon'], name='lon')
start = np.datetime64(dg.dataset.years[0], 'h') + np.timedelta64(dg.dataset.lead_time, 'h')
stop = np.datetime64(str(int(dg.dataset.years[1])+1), 'h')
times = np.arange(start, stop)
valid_time = xr.DataArray(times, coords=[times], dims='time', name='time', attrs={'long_name': 'time'})
out_features = dg.dataset.out_features
output_dim = (len(lats), len(lons), dg.dataset.out_features)
outputs = []
for i, (sample, _) in enumerate(dg):
sample = sample.to(device)
output = model(sample).detach().cpu().clone().numpy().reshape((-1, *output_dim))
outputs.append(output)
preds = np.concatenate(outputs)
# Unnormalize
preds = preds * dg.dataset.std.values[:out_features] + dg.dataset.mean.values[:out_features]
das = []
lev_idx = 0
for var, levels in dg.dataset.var_dict_out.items():
if levels is None:
das.append(xr.DataArray(
preds[:, :, :, lev_idx],
dims=['time', 'lat', 'lon'],
coords={'time': valid_time, 'lat': lat, 'lon': lon},
name=var
))
lev_idx += 1
else:
nlevs = len(levels)
das.append(xr.DataArray(
preds[:, :, :, lev_idx:lev_idx+nlevs],
dims=['time', 'lat', 'lon', 'level'],
coords={'time': valid_time, 'lat': lat, 'lon': lon, 'level': levels},
name=var
))
lev_idx += nlevs
return xr.merge(das)
def create_predictions_2D(model, dg, mean, std):
"""Create direct predictions for models using 2D signals (images)
Parameters
----------
model : torch.nn.Module
Trained model
dg : DataLoader
Test data
mean : np.ndarray
Training set mean
std : np.ndarray
Training set std
Returns
-------
predictions : xr.Dataset
Model predictions
"""
outputs = []
for i, (sample, _) in enumerate(dg):
sample = sample.to(device)
output = model(sample).detach().cpu().clone().permute(0, 2, 3, 1).numpy()
outputs.append(output)
preds = np.concatenate(outputs)
# Unnormalize
preds = preds * std.values + mean.values
das = []
lev_idx = 0
for var, levels in dg.dataset.var_dict.items():
if levels is None:
das.append(xr.DataArray(
preds[:, :, :, lev_idx],
dims=['time', 'lat', 'lon'],
coords={'time': dg.dataset.valid_time, 'lat': dg.dataset.data.lat, 'lon': dg.dataset.data.lon},
name=var
))
lev_idx += 1
else:
nlevs = len(levels)
das.append(xr.DataArray(
preds[:, :, :, lev_idx:lev_idx+nlevs],
dims=['time', 'lat', 'lon', 'level'],
coords={'time': dg.dataset.valid_time, 'lat': dg.dataset.data.lat, 'lon': dg.dataset.data.lon, 'level': levels},
name=var
))
lev_idx += nlevs
return xr.merge(das)
def compute_anomalies(ds, mean):
""" Computes anomalies by removing relevant average to data
Parameters
----------
ds : xr.Dataset
Dataset from whoch to compute the anomalies
mean : string
Which mean to remove to the data. Options are {"monthly", "weekly"}
Returns
-------
anomalies : xr.Dataset
Demeaned dataset
"""
assert mean in ["monthly", "weekly"], "Parameter mean should be either 'monthly' or 'weekly'"
if mean is "monthly":
anomalies = ds.groupby('time.month') - ds.groupby('time.month').mean()
else:
anomalies = ds.groupby('time.week') - ds.groupby('time.week').mean()
return anomalies
# Metrics for healpix iterative predictions
def compute_rmse_healpix(pred, obs, dims=('node', 'time')):
error = pred - obs
rmse = np.sqrt(((error)**2).mean(dims))
return rmse.drop('lat').drop('lon').load()
def compute_relBIAS_map_healpix(pred, obs):
""" Compute the relative bias from two xr.DataArrays given some dimensions
Parameters
----------
pred : xr.DataArray
Forecast. Time coordinate must be validation time.
obs_mean : xr.DataArray
Mean of observations across "time" and "lead_time" dimensions
Returns
-------
relBIAS : xr.DataArray
Relative bias map
"""
error = pred - obs
rbias = error.mean(('time')).load() / obs.mean(('time')).load()
return rbias
def compute_weighted_rmse(da_fc, da_true, dims=xr.ALL_DIMS):
""" Compute the root mean squared error (RMSE) with latitude weighting from two xr.DataArrays.
Parameters
----------
da_fc : xr.DataArray
Forecast
da_true : xr.DataArray
Labels
dims (str):
Dimensions over which to compute the metric
Returns
-------
rmse : xr.DataArray
Latitude weighted root mean squared | |
<gh_stars>0
#!/usr/bin/env python
from __future__ import division
import os
import argparse
import itertools
from functools import partial
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import seaborn as sns
from dask import delayed, get, multiprocessing
from dask.diagnostics import ProgressBar
import warnings
import comptools as comp
from pyunfold import iterative_unfold
warnings.filterwarnings("ignore", category=UserWarning, module="matplotlib")
warnings.filterwarnings("ignore", category=DeprecationWarning, module="sklearn")
def get_test_counts(case, composition, num_groups, energy_midpoints,
flux_to_counts_scaling):
log_energy_midpoints = np.log10(energy_midpoints)
scale = 1.0 / num_groups
if case == 'constant':
counts = np.array([1000]*len(log_energy_midpoints))
elif case == 'simple_power_law':
comp_flux = comp.broken_power_law_flux(energy_midpoints,
gamma_before=-2.7,
# gamma_before=-3.0,
energy_break=3e12)
comp_flux = scale * comp_flux
counts = flux_to_counts_scaling * comp_flux
elif case == 'broken_power_law_0':
comp_flux = comp.broken_power_law_flux(energy_midpoints,
energy_break=10**7.0)
comp_flux = scale * comp_flux
counts = flux_to_counts_scaling * comp_flux
elif case in ['broken_power_law_1', 'broken_power_law_2']:
if composition in ['PPlus', 'He4Nucleus', 'light']:
gamma_after = -3.0 if case == 'broken_power_law_1' else -4.0
else:
gamma_after = -4.0 if case == 'broken_power_law_1' else -3.0
comp_flux = comp.broken_power_law_flux(energy_midpoints,
energy_break=10**7.0,
gamma_before=-2.7,
gamma_after=gamma_after)
comp_flux = scale * comp_flux
counts = flux_to_counts_scaling * comp_flux
elif case in ['H4a', 'H3a']:
model_flux = comp.model_flux(model=case,
energy=energy_midpoints,
num_groups=num_groups)
counts = model_flux['flux_{}'.format(composition)].values * flux_to_counts_scaling
else:
raise ValueError('Invalid case, "{}", entered'.format(case))
return counts
def calculate_ratio(flux, flux_err_stat, flux_err_sys,
true_flux, true_flux_err_stat, true_flux_err_sys):
diff = flux - true_flux
# Error bar calculation
diff_err_sys = np.sqrt(flux_err_sys**2 + true_flux_err_sys**2)
diff_err_stat = np.sqrt(flux_err_stat**2 + true_flux_err_stat**2)
frac_diff, frac_diff_sys = comp.ratio_error(num=diff,
num_err=diff_err_sys,
den=true_flux,
den_err=true_flux_err_sys)
frac_diff, frac_diff_stat = comp.ratio_error(num=diff,
num_err=diff_err_stat,
den=true_flux,
den_err=true_flux_err_stat)
return frac_diff, frac_diff_stat, frac_diff_sys
def main(config, num_groups, prior, ts_stopping, case, response, response_err, p=None):
figures_dir = os.path.join(comp.paths.figures_dir, 'unfolding', config,
'datachallenge', '{}_case'.format(case),
'{}_prior'.format(prior),
'ts_stopping_{}'.format(ts_stopping))
# Calculate desired counts distribution for test case
counts_true = pd.DataFrame(index=range(num_ebins),
columns=comp_list)
for composition in comp_list:
flux_to_counts_scaling = eff_area[composition] * livetime * solid_angle * energybins.energy_bin_widths
counts_true[composition] = get_test_counts(case,
composition,
num_groups,
energybins.energy_midpoints,
flux_to_counts_scaling)
counts_true['total'] = counts_true.sum(axis=1)
# Plot true flux and H4a flux (as a visual reference)
fig, axarr = plt.subplots(nrows=1, ncols=num_groups + 1,
sharex=True, sharey=True, figsize=(15, 5))
for idx, composition in enumerate(comp_list + ['total']):
ax = axarr[idx]
model_flux = comp.model_flux(model='H4a',
energy=energybins.energy_midpoints,
num_groups=num_groups)
model_comp_flux = model_flux['flux_{}'.format(composition)].values
ax.plot(energybins.log_energy_midpoints,
energybins.energy_midpoints**2.7 * model_comp_flux,
color=color_dict[composition],
ls='-.',
lw=2,
marker='None',
label='H4a')
comp_flux, _ = counts_to_flux(counts_true[composition],
composition=composition)
ax.plot(energybins.log_energy_midpoints, comp_flux,
color=color_dict[composition],
ls='-',
lw=2,
marker='None',
label='Test case')
ax.set_yscale("log", nonposy='clip')
ax.set_xlabel('$\mathrm{\log_{10}(E/GeV)}$')
if idx == 0:
ax.set_ylabel('$\mathrm{ E^{2.7} \ J(E) \ [GeV^{1.7} m^{-2} sr^{-1} s^{-1}]}$')
ax.set_title(composition)
ax.grid(lw=1, which='both')
ax.legend()
true_flux_outfile = os.path.join(
figures_dir,
'true_flux_{}-groups_{}-case.png'.format(num_groups, case))
comp.check_output_dir(true_flux_outfile)
plt.savefig(true_flux_outfile)
# Run analysis pipeline on simulation
counts_observed = pd.DataFrame(0, index=range(num_ebins),
columns=comp_list)
counts_observed_err = pd.DataFrame(0, index=range(num_ebins),
columns=comp_list)
weights = pd.DataFrame(0, index=range(num_ebins),
columns=comp_list)
# Construct mask for energy bin
energy_bins = np.digitize(df_sim_data['MC_log_energy'],
bins=energybins.log_energy_bins) - 1
for idx_log_energy, composition in itertools.product(
range(len(energybins.log_energy_midpoints)),
comp_list):
# Filter out events that don't pass composition & energy mask
comp_mask = df_sim_data['comp_group_{}'.format(num_groups)] == composition
energy_mask = energy_bins == idx_log_energy
df_sim_bin = df_sim_data.loc[comp_mask & energy_mask, :]
# Reweight simulation events to get desired number of events
weight = counts_true[composition][idx_log_energy] / df_sim_bin.shape[0]
# weight = counts_true.loc[log_energy, composition] / df_sim_bin.shape[0]
weights.loc[idx_log_energy, composition] = weight
# Get predicted composition
y_test = df_sim_bin['comp_target_{}'.format(num_groups)].values
X_test = df_sim_bin[feature_list].values
if p is not None:
pred_target = custom_predict(y_test, p=p, num_groups=num_groups)
else:
pred_target = pipeline.predict(X_test)
pred_comp = np.array(comp.decode_composition_groups(
pred_target, num_groups=num_groups))
assert len(pred_comp) == df_sim_bin.shape[0]
for p_comp in np.unique(pred_comp):
pred_comp_mask = pred_comp == p_comp
comp_counts, _ = np.histogram(df_sim_bin.loc[pred_comp_mask, 'reco_log_energy'],
bins=energybins.log_energy_bins)
counts_observed[p_comp] += weight * comp_counts
counts_observed_err[p_comp] += [sum(weight**2 for _ in range(c)) for c in comp_counts]
# Square root the sum of squares of the weight errors
for composition in comp_list:
counts_observed_err[composition] = np.sqrt(counts_observed_err[composition])
counts_observed_err['total'] = np.sqrt(np.sum(counts_observed_err[composition]**2 for composition in comp_list))
# Calculate total counts
counts_observed['total'] = counts_observed.sum(axis=1)
# Plot weights for each composition and energy bin
fig, ax = plt.subplots()
for composition in comp_list:
weights[composition].plot(ls=':', label=composition,
color=color_dict[composition], ax=ax)
ax.set_xlabel('$\mathrm{\log_{10}(E/GeV)}$')
ax.set_ylabel('Weights')
ax.set_yscale("log", nonposy='clip')
ax.grid(lw=1)
ax.legend()
weights_outfile = os.path.join(
figures_dir, 'weights_{}-groups_{}.png'.format(num_groups, case))
comp.check_output_dir(weights_outfile)
plt.savefig(weights_outfile)
# Format observed counts, detection efficiencies, and priors for PyUnfold use
counts_pyunfold = np.empty(num_groups * len(energybins.energy_midpoints))
counts_err_pyunfold = np.empty(num_groups * len(energybins.energy_midpoints))
efficiencies = np.empty(num_groups * len(energybins.energy_midpoints))
efficiencies_err = np.empty(num_groups * len(energybins.energy_midpoints))
for idx, composition in enumerate(comp_list):
counts_pyunfold[idx::num_groups] = counts_observed[composition]
counts_err_pyunfold[idx::num_groups] = counts_observed_err[composition]
efficiencies[idx::num_groups] = df_eff['eff_median_{}'.format(composition)]
efficiencies_err[idx::num_groups] = df_eff['eff_err_low_{}'.format(composition)]
if prior == 'Jeffreys':
prior_pyunfold = 'Jeffreys'
print('Jeffreys prior')
else:
model_flux = comp.model_flux(model=prior,
energy=energybins.energy_midpoints,
num_groups=num_groups)
prior_pyunfold = np.empty(num_groups * len(energybins.energy_midpoints))
for idx, composition in enumerate(comp_list):
prior_pyunfold[idx::num_groups] = model_flux['flux_{}'.format(composition)]
# Want to ensure prior_pyunfold are probabilities (i.e. they add to 1)
prior_pyunfold = prior_pyunfold / np.sum(prior_pyunfold)
df_unfolding_iter = iterative_unfold(data=counts_pyunfold,
data_err=counts_err_pyunfold,
response=res_normalized,
response_err=res_normalized_err,
efficiencies=efficiencies,
efficiencies_err=efficiencies_err,
prior=prior_pyunfold,
ts='ks',
ts_stopping=ts_stopping,
max_iter=100,
return_iterations=True)
# print('\n{} case (prior {}): {} iterations'.format(case, prior, df_unfolding_iter.shape[0]))
output = {'prior': prior, 'ts_stopping': ts_stopping, 'case': case}
counts, counts_sys_err, counts_stat_err = comp.unfolded_counts_dist(
df_unfolding_iter,
iteration=-1,
num_groups=num_groups)
for idx, composition in enumerate(comp_list + ['total']):
# Pre-unfolding flux plot
initial_counts = counts_observed[composition].values
initial_counts_err = counts_observed_err[composition].values
# initial_counts_err = np.sqrt(initial_counts)
initial_flux, initial_flux_err_stat = counts_to_flux(
initial_counts,
initial_counts_err,
composition=composition)
initial_flux_err_sys = np.zeros_like(initial_flux)
# Unfolded flux plot
flux, flux_err_sys = unfolded_counts_to_flux(
counts[composition],
counts_sys_err[composition])
flux, flux_err_stat = unfolded_counts_to_flux(
counts[composition],
counts_stat_err[composition])
# True flux
true_counts = counts_true[composition].values
true_counts_err = np.sqrt(true_counts)
true_flux, true_flux_err_stat = counts_to_flux(
true_counts,
true_counts_err,
composition=composition)
true_flux_err_sys = np.zeros_like(true_flux)
output['initial_counts_{}'.format(composition)] = initial_counts
output['initial_counts_err_{}'.format(composition)] = initial_counts_err
output['flux_{}'.format(composition)] = flux
output['flux_err_stat_{}'.format(composition)] = flux_err_stat
output['flux_err_sys_{}'.format(composition)] = flux_err_sys
output['true_flux_{}'.format(composition)] = true_flux
output['true_flux_err_stat_{}'.format(composition)] = true_flux_err_stat
output['true_flux_err_sys_{}'.format(composition)] = true_flux_err_sys
output['initial_flux_{}'.format(composition)] = initial_flux
output['initial_flux_err_stat_{}'.format(composition)] = initial_flux_err_stat
output['initial_flux_err_sys_{}'.format(composition)] = initial_flux_err_sys
# Don't want to consume too much memory by keeping too many figures open
plt.close('all')
return output
def save_flux_plot(group, config, case, ts_stopping, num_groups):
"""Saves flux comparison plot
"""
comp_list = comp.get_comp_list(num_groups=num_groups)
energybins = comp.get_energybins(config)
# Get plotting axis
figures_dir = os.path.join(comp.paths.figures_dir, 'unfolding', config,
'datachallenge', '{}_case'.format(case),
'prior_comparisons',
'ts_stopping_{}'.format(ts_stopping))
# Make initial counts (pre-unfolding) plot
fig_counts, ax_counts = plt.subplots()
fig = plt.figure(figsize=(12, 5))
gs = gridspec.GridSpec(nrows=2, ncols=num_groups+1, hspace=0.1)
# gs = gridspec.GridSpec(nrows=2, ncols=num_groups+1, hspace=0.075)
axs_flux, axs_ratio = {}, {}
for idx, composition in enumerate(comp_list + ['total']):
if idx == 0:
axs_flux[composition] = fig.add_subplot(gs[0, idx])
else:
axs_flux[composition] = fig.add_subplot(gs[0, idx], sharey=axs_flux[comp_list[0]])
axs_ratio[composition] = fig.add_subplot(gs[1, idx], sharex=axs_flux[composition])
prior_groupby = group.groupby('prior')
marker_iter = iter('.^x*')
ls_iter = iter(['-', ':', '-.', '--'])
fontsize = 18
initial_flux_test, initial_flux_err_stat_test, initial_flux_err_sys_test = {}, {}, {}
for prior_idx, (prior, df_group) in enumerate(prior_groupby):
marker = next(marker_iter)
ls = next(ls_iter)
label = priors_labels[priors.index(prior)]
for idx, composition in enumerate(comp_list + ['total']):
ax_flux = axs_flux[composition]
ax_ratio = axs_ratio[composition]
color = sns.color_palette(comp.get_colormap(composition), len(priors)+3).as_hex()[-1*(prior_idx + 2)]
true_color = sns.color_palette(comp.get_colormap(composition), len(priors)+3).as_hex()[-1]
# True flux
true_flux = df_group['true_flux_{}'.format(composition)].values[0]
true_flux_err_stat = df_group['true_flux_err_stat_{}'.format(composition)].values[0]
true_flux_err_sys = df_group['true_flux_err_sys_{}'.format(composition)].values[0]
if prior_idx == 0:
ax_flux.errorbar(energybins.log_energy_midpoints, true_flux, yerr=true_flux_err_stat,
color=true_color, ls='None', marker='*',
label='True flux', alpha=0.8)
# Unfolded flux
flux = df_group['flux_{}'.format(composition)].values[0]
flux_err_stat = df_group['flux_err_stat_{}'.format(composition)].values[0]
flux_err_sys = df_group['flux_err_sys_{}'.format(composition)].values[0]
if not plot_initial_flux:
comp.plot_steps(energybins.log_energy_bins, flux, yerr=flux_err_sys,
ax=ax_flux, alpha=0.4, fillalpha=0.4,
color=color, ls=ls)
ax_flux.errorbar(energybins.log_energy_midpoints, flux, yerr=flux_err_stat,
color=color, ls='None', marker=marker,
label='Unfolded ({})'.format(label), alpha=0.8)
# Initial (pre-unfolding) flux
initial_flux = df_group['initial_flux_{}'.format(composition)].values[0]
initial_flux_err_stat = df_group['initial_flux_err_stat_{}'.format(composition)].values[0]
initial_flux_err_sys = df_group['initial_flux_err_sys_{}'.format(composition)].values[0]
# Sanity check that all the initial_flux (what goes into the unfolding)
# are the same for each prior.
if prior_idx == 0:
initial_flux_test[composition] = initial_flux
initial_flux_err_stat_test[composition] = initial_flux_err_stat
initial_flux_err_sys_test[composition] = initial_flux_err_sys
initial_counts = df_group['initial_counts_{}'.format(composition)].values[0]
initial_counts_err = df_group['initial_counts_err_{}'.format(composition)].values[0]
comp.plot_steps(energybins.log_energy_bins, initial_counts, yerr=initial_counts_err,
ax=ax_counts, alpha=0.8, fillalpha=0.4,
color=color_dict[composition], label=composition)
ax_counts.set_yscale("log", nonposy='clip')
ax_counts.set_ylabel('Observed counts from BDT')
# ax_counts.set_ylabel('$\mathrm{ E^{2.7} \ J(E) \ [GeV^{1.7} m^{-2} sr^{-1} s^{-1}]}$')
ax_counts.set_xlabel('$\mathrm{\log_{10}(E/GeV)}$')
ax_counts.set_xlim(6.4, 7.8)
ax_counts.grid()
ax_counts.legend()
else:
np.testing.assert_allclose(initial_flux_test[composition], initial_flux)
np.testing.assert_allclose(initial_flux_err_stat_test[composition], initial_flux_err_stat)
np.testing.assert_allclose(initial_flux_err_sys_test[composition], initial_flux_err_sys)
if plot_initial_flux:
comp.plot_steps(energybins.log_energy_bins, initial_flux, yerr=initial_flux_err_sys,
ax=ax_flux, alpha=0.4, fillalpha=0.4,
color=color, ls=ls)
ax_flux.errorbar(energybins.log_energy_midpoints, initial_flux, yerr=initial_flux_err_stat,
color=color, ls='None', marker=marker,
label='Initial ({})'.format(label), alpha=0.8)
ax_flux.set_yscale("log", nonposy='clip')
ax_flux.set_xlim(6.4, 7.8)
ax_flux.set_ylim(1e3, 1e5)
ax_flux.grid(linestyle='dotted', which="both", lw=1)
ax_flux.set_title(composition, fontsize=14)
if composition == 'total':
ax_flux.legend(fontsize=10, loc='lower left')
if idx == 0:
ax_flux.set_ylabel('$\mathrm{ E^{2.7} \ J(E)}$' +'\n' + '$\mathrm{[GeV^{1.7} m^{-2} sr^{-1} s^{-1}]}$',
fontsize=18)
else:
plt.setp(ax_flux.get_yticklabels(), visible=False)
plt.setp(ax_flux.get_xticklabels(), visible=False)
ax_flux.tick_params(axis='both', which='major', labelsize=14)
if plot_initial_flux:
frac_diff, frac_diff_stat, frac_diff_sys = calculate_ratio(
initial_flux, initial_flux_err_stat, initial_flux_err_sys,
true_flux, true_flux_err_stat, true_flux_err_sys)
else:
frac_diff, frac_diff_stat, frac_diff_sys = calculate_ratio(
flux, flux_err_stat, flux_err_sys,
true_flux, true_flux_err_stat, true_flux_err_sys)
comp.plot_steps(energybins.log_energy_bins, frac_diff, yerr=frac_diff_sys,
ax=ax_ratio, alpha=0.4, fillalpha=0.4,
color=color, ls=ls)
ax_ratio.errorbar(energybins.log_energy_midpoints, frac_diff, yerr=frac_diff_stat,
color=color, ls='None', marker=marker,
label='Unfolded ({})'.format(label), alpha=0.8)
ax_ratio.axhline(0, ls='-.', lw=1, marker='None', color='k')
ax_ratio.grid(linestyle='dotted', which="both", lw=1)
ax_ratio.set_yticks(np.arange(-1, 1.5, 0.5))
# ax_ratio.set_yticks(np.arange(-1, 1.5, 0.25))
ax_ratio.set_ylim(-1, 1)
if idx == 0:
ax_ratio.set_ylabel('$\mathrm{(J - J_{true}) / J_{true}}$',
fontsize=18)
else:
plt.setp(ax_ratio.get_yticklabels(), visible=False)
ax_ratio.set_xlabel('$\mathrm{\log_{10}(E/GeV)}$', fontsize=18)
ax_ratio.tick_params(axis='both', which='major', labelsize=14)
plt.tight_layout()
flux_outfile = os.path.join(figures_dir,
'flux_ratio_{}-groups_{}-case.png'.format(num_groups, case))
comp.check_output_dir(flux_outfile)
plt.savefig(flux_outfile)
counts_outfile = os.path.join(figures_dir,
'counts_{}-groups_{}-case.png'.format(num_groups, case))
comp.check_output_dir(counts_outfile)
fig_counts.savefig(counts_outfile)
# Don't want to consume too much | |
<reponame>bordplate/Ghostwriter<gh_stars>0
#!/usr/bin/python3
# -*- coding: utf-8 -*-
"""This module contains the tools required for generating Microsoft Office
documents for reporting. The Reportwriter class accepts data and produces a
docx, xlsx, pptx, and json using the provided data.
"""
import re
import io
import os
import json
from PIL import Image
from PIL import ImageOps
from xlsxwriter.workbook import Workbook
from docx import Document
from docx.oxml import parse_xml
from docx.oxml.shared import OxmlElement, qn
from docx.oxml.ns import nsdecls
from docx.shared import RGBColor, Inches, Pt
from docx.enum.style import WD_STYLE_TYPE
from docx.enum.text import WD_ALIGN_PARAGRAPH
import pptx
from pptx import Presentation
from pptx.enum.text import PP_ALIGN
from pptx.enum.text import MSO_ANCHOR
from django.conf import settings
from django.core.serializers.json import DjangoJSONEncoder
class Reportwriter():
"""Class for generating documents for the provided findings."""
# Color codes used for finding severity
# Blue
informational_color = '8eaadb'
informational_color_hex = [0x83, 0xaa, 0xdb]
# Green
low_color = 'a8d08d'
low_color_hex = [0xa8, 0xd0, 0x8d]
# Orange
medium_color = 'f4b083'
medium_color_hex = [0xf4, 0xb0, 0x83]
# Red
high_color = 'ff7e79'
high_color_hex = [0xff, 0x7e, 0x79]
# Purple
critical_color = '7030a0'
critical_color_hex = [0x70, 0x30, 0xa0]
# Picture border color - this one needs the # in front
border_color = '#2d2b6b'
border_color_hex = [0x45, 0x43, 0x107]
# Extensions allowed for evidence
image_extensions = ['png', 'jpeg', 'jpg']
text_extensions = ['txt', 'ps1', 'py', 'md', 'log']
def __init__(self, report_queryset, output_path, evidence_path,
template_loc=None):
"""Everything that must be initialized is setup here."""
self.output_path = output_path
self.template_loc = template_loc
self.evidence_path = evidence_path
self.report_queryset = report_queryset
def generate_json(self):
"""Export report as a JSON dictionary."""
project_name = str(self.report_queryset.project)
# Client data
report_dict = {}
report_dict['client'] = {}
report_dict['client']['id'] = self.report_queryset.project.client.id
report_dict['client']['full_name'] = \
self.report_queryset.project.client.name
report_dict['client']['short_name'] = \
self.report_queryset.project.client.short_name
report_dict['client']['codename'] = \
self.report_queryset.project.client.codename
# Client points of contact data
report_dict['client']['poc'] = {}
for poc in self.report_queryset.project.client.clientcontact_set.all():
report_dict['client']['poc'][poc.id] = {}
report_dict['client']['poc'][poc.id]['id'] = poc.id
report_dict['client']['poc'][poc.id]['name'] = poc.name
report_dict['client']['poc'][poc.id]['job_title'] = poc.job_title
report_dict['client']['poc'][poc.id]['email'] = poc.email
report_dict['client']['poc'][poc.id]['phone'] = poc.phone
report_dict['client']['poc'][poc.id]['note'] = poc.note
# Project data
report_dict['project'] = {}
report_dict['project']['id'] = self.report_queryset.project.id
report_dict['project']['name'] = project_name
report_dict['project']['start_date'] = \
self.report_queryset.project.start_date
report_dict['project']['end_date'] = \
self.report_queryset.project.end_date
report_dict['project']['codename'] = \
self.report_queryset.project.codename
report_dict['project']['project_type'] = \
self.report_queryset.project.project_type.project_type
report_dict['project']['note'] = self.report_queryset.project.note
# Finding data
report_dict['findings'] = {}
for finding in self.report_queryset.reportfindinglink_set.all():
report_dict['findings'][finding.title] = {}
report_dict['findings'][finding.title]['id'] = finding.id
report_dict['findings'][finding.title]['title'] = finding.title
report_dict['findings'][finding.title]['severity'] = \
finding.severity.severity
report_dict['findings'][finding.title]['affected_entities'] = \
finding.affected_entities
report_dict['findings'][finding.title]['description'] = \
finding.description
report_dict['findings'][finding.title]['impact'] = finding.impact
report_dict['findings'][finding.title]['recommendation'] = \
finding.mitigation
report_dict['findings'][finding.title]['replication_steps'] = \
finding.replication_steps
report_dict['findings'][finding.title][
'host_detection_techniques'] = \
finding.host_detection_techniques
report_dict['findings'][finding.title][
'network_detection_techniques'] = \
finding.network_detection_techniques
report_dict['findings'][finding.title]['references'] = \
finding.references
# Get any evidence
report_dict['findings'][finding.title]['evidence'] = {}
for evidence_file in finding.evidence_set.all():
evidence_name = evidence_file.friendly_name
report_dict['findings'][finding.title][
'evidence'][evidence_name] = {}
report_dict['findings'][finding.title][
'evidence'][evidence_name]['id'] = evidence_file.id
report_dict['findings'][finding.title][
'evidence'][evidence_name]['friendly_name'] = \
evidence_file.friendly_name
report_dict['findings'][finding.title][
'evidence'][evidence_name]['uploaded_by'] = \
evidence_file.uploaded_by.username
report_dict['findings'][finding.title][
'evidence'][evidence_name]['upload_date'] = \
evidence_file.upload_date
report_dict['findings'][finding.title][
'evidence'][evidence_name]['description'] = \
evidence_file.description
report_dict['findings'][finding.title][
'evidence'][evidence_name]['caption'] = \
evidence_file.caption
report_dict['findings'][finding.title][
'evidence'][evidence_name]['url'] = \
evidence_file.document.url
report_dict['findings'][finding.title][
'evidence'][evidence_name]['file_path'] = \
str(evidence_file.document)
# Infrastructure data
report_dict['infrastructure'] = {}
report_dict['infrastructure']['domains'] = {}
report_dict['infrastructure']['servers'] = {}
report_dict['infrastructure']['servers']['static'] = {}
report_dict['infrastructure']['servers']['cloud'] = {}
report_dict['infrastructure']['domains_and_servers'] = {}
for domain in self.report_queryset.project.history_set.all():
report_dict['infrastructure']['domains'][domain.domain.id] = {}
report_dict['infrastructure']['domains'][domain.domain.id][
'id'] = domain.domain.id
report_dict['infrastructure']['domains'][domain.domain.id][
'name'] = domain.domain.name
report_dict['infrastructure']['domains'][domain.domain.id][
'activity'] = domain.activity_type.activity
report_dict['infrastructure']['domains'][domain.domain.id][
'operator'] = domain.operator.username
report_dict['infrastructure']['domains'][domain.domain.id][
'start_date'] = domain.start_date
report_dict['infrastructure']['domains'][domain.domain.id][
'end_date'] = domain.end_date
report_dict['infrastructure']['domains'][domain.domain.id][
'note'] = domain.note
for server in self.report_queryset.project.serverhistory_set.all():
report_dict['infrastructure']['servers']['static'][
server.server.id] = {}
report_dict['infrastructure']['servers']['static'][
server.server.id]['id'] = server.server.id
report_dict['infrastructure']['servers']['static'][
server.server.id]['ip_address'] = server.server.ip_address
report_dict['infrastructure']['servers']['static'][
server.server.id]['activity'] = server.activity_type.activity
report_dict['infrastructure']['servers']['static'][
server.server.id]['role'] = server.server_role.server_role
report_dict['infrastructure']['servers']['static'][
server.server.id]['operator'] = server.operator.username
report_dict['infrastructure']['servers']['static'][
server.server.id]['start_date'] = server.start_date
report_dict['infrastructure']['servers']['static'][
server.server.id]['end_date'] = server.end_date
report_dict['infrastructure']['servers']['static'][
server.server.id]['note'] = server.note
for server in self.report_queryset.project.transientserver_set.all():
report_dict['infrastructure']['servers']['cloud'][server.id] = {}
report_dict['infrastructure']['servers']['cloud'][server.id][
'id'] = server.id
report_dict['infrastructure']['servers']['cloud'][server.id][
'ip_address'] = server.ip_address
report_dict['infrastructure']['servers']['cloud'][server.id][
'activity'] = server.activity_type.activity
report_dict['infrastructure']['servers']['cloud'][server.id][
'role'] = server.server_role.server_role
report_dict['infrastructure']['servers']['cloud'][server.id][
'operator'] = server.operator.username
report_dict['infrastructure']['servers']['cloud'][server.id][
'note'] = server.note
# Hold all domain/server associations in a temporary dictionary
temp = {}
for connection in self.report_queryset.project.domainserverconnection_set.all():
# Handle one-to-many relationships by combining everything into
# a domain and list of servers
if connection.subdomain is not "*":
domain_name = connection.subdomain + "." + connection.domain.domain.name
else:
domain_name = connection.domain.domain.name
report_dict['infrastructure']['domains_and_servers'][connection.id] = {}
report_dict['infrastructure']['domains_and_servers'][
connection.id]['domain'] = domain_name
if connection.static_server:
server = connection.static_server.server.ip_address
else:
server = connection.transient_server.ip_address
if domain_name in temp:
server_list = [server]
for val in temp[domain_name]:
server_list.append(val)
# Remove any duplicates from server_list
server = list(set(server_list))
# Now add the temporary dictionary's data to the report JSON
report_dict['infrastructure']['domains_and_servers'][
connection.id]['servers'] = server
if connection.endpoint:
report_dict['infrastructure']['domains_and_servers'][
connection.id]['cdn_endpoint'] = connection.endpoint
else:
report_dict['infrastructure']['domains_and_servers'][
connection.id]['cdn_endpoint'] = "None"
# Operator assignments
report_dict['team'] = {}
for operator in self.report_queryset.project.projectassignment_set.all():
report_dict['team'][operator.operator.id] = {}
report_dict['team'][operator.operator.id][
'id'] = operator.operator.id
report_dict['team'][operator.operator.id][
'name'] = operator.operator.name
report_dict['team'][operator.operator.id][
'project_role'] = operator.role.project_role
report_dict['team'][operator.operator.id][
'email'] = operator.operator.email
report_dict['team'][operator.operator.id][
'start_date'] = operator.start_date
report_dict['team'][operator.operator.id][
'end_date'] = operator.end_date
report_dict['team'][operator.operator.id][
'note'] = operator.note
return json.dumps(report_dict, indent=2, cls=DjangoJSONEncoder)
def create_newline(self):
"""Create a blank line to act as a separator between document elements.
A paragraph must be added and then a run in order to use an
`add_break()`. This creates the appropriate <w:r> in the docx
document's XML.
"""
p = self.spenny_doc.add_paragraph()
run = p.add_run()
run.add_break()
def make_figure(self, paragraph):
"""Make the specified paragraph an auto-incrementing Figure in the
Word document.
Code from: https://github.com/python-openxml/python-docx/issues/359
"""
run = run = paragraph.add_run()
r = run._r
fldChar = OxmlElement('w:fldChar')
fldChar.set(qn('w:fldCharType'), 'begin')
r.append(fldChar)
instrText = OxmlElement('w:instrText')
instrText.text = ' SEQ Figure \\* ARABIC'
r.append(instrText)
fldChar = OxmlElement('w:fldChar')
fldChar.set(qn('w:fldCharType'), 'end')
r.append(fldChar)
def list_number(self, par, prev=None, level=None, num=True):
"""Makes the specified paragraph a list item with a specific level and
optional restart.
An attempt will be made to retrieve an abstract numbering style that
corresponds to the style of the paragraph. If that is not possible,
the default numbering or bullet style will be used based on the
``num`` parameter.
Parameters
----------
par : docx.paragraph.Paragraph
The paragraph to turn into a list item.
prev : docx.paragraph.Paragraph or None
The previous paragraph in the list. If specified, the numbering
and styles will be taken as a continuation of this paragraph.
If omitted, a new numbering scheme will be started.
level : int or None
The level of the paragraph within the outline. If ``prev`` is
set, defaults to the same level as in ``prev``. Otherwise,
defaults to zero.
num : bool
If ``prev`` is :py:obj:`None` and the style of the paragraph
does not correspond to an existing numbering style, this will
determine wether or not the list will be numbered or bulleted.
The result is not guaranteed, but is fairly safe for most Word
templates.
Code from:
https://github.com/python-openxml/python-docx/issues/25#issuecomment-400787031
"""
xpath_options = {
True: {'single': 'count(w:lvl)=1 and ', 'level': 0},
False: {'single': '', 'level': level},
}
def style_xpath(prefer_single=True):
"""
The style comes from the outer-scope variable ``par.style.name``.
"""
style = par.style.style_id
return (
'w:abstractNum['
'{single}w:lvl[@w:ilvl="{level}"]/w:pStyle[@w:val="{style}"]'
']/@w:abstractNumId'
).format(style=style, **xpath_options[prefer_single])
def type_xpath(prefer_single=True):
"""
The type is from the outer-scope variable ``num``.
"""
type = 'decimal' if num else 'bullet'
return (
'w:abstractNum['
'{single}w:lvl[@w:ilvl="{level}"]/w:numFmt[@w:val="{type}"]'
']/@w:abstractNumId'
).format(type=type, **xpath_options[prefer_single])
def get_abstract_id():
"""Select as follows:
1. Match single-level by style (get min ID)
2. Match exact style and level (get min ID)
3. Match single-level decimal/bullet types (get min ID)
4. Match decimal/bullet in requested level (get min ID)
3. 0
"""
for fn in (style_xpath, type_xpath):
for prefer_single in (True, False):
xpath = fn(prefer_single)
ids = numbering.xpath(xpath)
if ids:
return min(int(x) for x in ids)
return 0
if (prev is None or
prev._p.pPr is None or
prev._p.pPr.numPr is None or
prev._p.pPr.numPr.numId is None):
if level is None:
level = 0
numbering = self.spenny_doc.part.numbering_part.\
numbering_definitions._numbering
# Compute the abstract ID first by style, then by num
abstract = get_abstract_id()
# Set the concrete numbering based on the abstract numbering ID
num = numbering.add_num(abstract)
# Make sure to override the abstract continuation property
num.add_lvlOverride(ilvl=level).add_startOverride(1)
# Extract the newly-allocated concrete numbering ID
num = num.numId
else:
if level is None:
level = prev._p.pPr.numPr.ilvl.val
# Get the previous concrete numbering ID
num = prev._p.pPr.numPr.numId.val
par._p.get_or_add_pPr().get_or_add_numPr().\
get_or_add_numId().val = num
par._p.get_or_add_pPr().get_or_add_numPr().\
get_or_add_ilvl().val = level
def process_text(self, text, finding, report_json):
"""Process the provided text from the specified finding to parse
keywords for evidence placement and formatting.
"""
numbered_list = False
bulleted_list = False
code_block = False
inline_code = False
italic_text = False
bold_text = False
p = None
prev_p = None
regex = r'\{\{\.(.*?)\}\}'
for line in text.split('\n'):
line = line.strip()
| |
<reponame>edgardmota/vent
import datetime
import docker
import json
import math
import multiprocessing
import os
import pkg_resources
import platform
import re
import requests
from subprocess import check_output, Popen, PIPE
from vent.api.templates import Template
from vent.helpers.paths import PathDirs
from vent.helpers.logs import Logger
logger = Logger(__name__)
def Version():
""" Get Vent version """
version = ''
try:
version = pkg_resources.require("vent")[0].version
if not version.startswith('v'):
version = 'v' + version
except Exception as e: # pragma: no cover
version = "Error: " + str(e)
return version
def System():
""" Get system operating system """
return platform.system()
def Docker():
""" Get Docker setup information """
docker_info = {'server': {}, 'env': '', 'type': '', 'os': ''}
# get docker server version
try:
d_client = docker.from_env()
docker_info['server'] = d_client.version()
except Exception as e: # pragma: no cover
logger.error("Can't get docker info " + str(e))
# get operating system
system = System()
docker_info['os'] = system
# check if native or using docker-machine
if 'DOCKER_MACHINE_NAME' in os.environ:
# using docker-machine
docker_info['env'] = os.environ['DOCKER_MACHINE_NAME']
docker_info['type'] = 'docker-machine'
elif 'DOCKER_HOST' in os.environ:
# not native
docker_info['env'] = os.environ['DOCKER_HOST']
docker_info['type'] = 'remote'
else:
# using "local" server
docker_info['type'] = 'native'
return docker_info
def Containers(vent=True, running=True):
"""
Get containers that are created, by default limit to vent containers that
are running
"""
containers = []
try:
d_client = docker.from_env()
if vent:
c = d_client.containers.list(all=not running,
filters={'label': 'vent'})
else:
c = d_client.containers.list(all=not running)
for container in c:
containers.append((container.name, container.status))
except Exception as e: # pragma: no cover
logger.error("Docker problem " + str(e))
return containers
def Cpu():
""" Get number of available CPUs """
cpu = "Unknown"
try:
cpu = str(multiprocessing.cpu_count())
except Exception as e: # pragma: no cover
logger.error("Can't access CPU count' " + str(e))
return cpu
def Gpu(pull=False):
""" Check for support of GPUs, and return what's available """
gpu = (False, "")
try:
image = 'nvidia/cuda:8.0-runtime'
image_name, tag = image.split(":")
d_client = docker.from_env()
nvidia_image = d_client.images.list(name=image)
if pull and len(nvidia_image) == 0:
try:
d_client.images.pull(image_name, tag=tag)
nvidia_image = d_client.images.list(name=image)
except Exception as e: # pragma: no cover
logger.error("Something with the GPU went wrong " + str(e))
if len(nvidia_image) > 0:
cmd = 'nvidia-docker run --rm ' + image + ' nvidia-smi -L'
proc = Popen([cmd],
stdout=PIPE,
stderr=PIPE,
shell=True,
close_fds=True)
gpus = proc.stdout.read()
err = proc.stderr.read()
if gpus:
gpu_str = ""
for line in gpus.strip().split("\n"):
gpu_str += line.split(" (UUID: ")[0] + ", "
gpu = (True, gpu_str[:-2])
else:
if err:
gpu = (False, "Unknown", str(err))
else:
gpu = (False, "None")
else:
gpu = (False, "None")
except Exception as e: # pragma: no cover
gpu = (False, "Unknown", str(e))
return gpu
def GpuUsage(**kargs):
""" Get the current GPU usage of available GPUs """
usage = (False, None)
gpu_status = {'vent_usage': {'dedicated': [], 'mem_mb': {}}}
path_dirs = PathDirs(**kargs)
path_dirs.host_config()
template = Template(template=path_dirs.cfg_file)
# get running jobs using gpus
try:
d_client = docker.from_env()
c = d_client.containers.list(all=False,
filters={'label': 'vent-plugin'})
for container in c:
if ('vent.gpu' in container.attrs['Config']['Labels'] and
container.attrs['Config']['Labels']['vent.gpu'] == 'yes'):
device = container.attrs['Config']['Labels']['vent.gpu.device']
if ('vent.gpu.dedicated' in container.attrs['Config']['Labels'] and
container.attrs['Config']['Labels']['vent.gpu.dedicated'] == 'yes'):
gpu_status['vent_usage']['dedicated'].append(device)
elif 'vent.gpu.mem_mb' in container.attrs['Config']['Labels']:
if device not in gpu_status['vent_usage']['mem_mb']:
gpu_status['vent_usage']['mem_mb'][device] = 0
gpu_status['vent_usage']['mem_mb'][device] += int(container.attrs['Config']['Labels']['vent.gpu.mem_mb'])
except Exception as e: # pragma: no cover
logger.error("Could not get running jobs " + str(e))
port = '3476'
# default docker gateway
host = '172.17.0.1'
result = template.option('nvidia-docker-plugin', 'port')
if result[0]:
port = result[1]
result = template.option('nvidia-docker-plugin', 'host')
if result[0]:
host = result[1]
else:
try:
# now just requires ip, ifconfig
route = check_output(('ip', 'route')).split('\n')
default = ''
# grab the default network device.
for device in route:
if 'default' in device:
default = device.split()[4]
break
# grab the IP address for the default device
ip_addr = check_output(('ifconfig', default))
ip_addr = ip_addr.split('\n')[1].split()[1]
host = ip_addr
except Exception as e: # pragma: no cover
logger.error("Something with the ip addresses"
"went wrong " + str(e))
# have to get the info separately to determine how much memory is availabe
nd_url = 'http://' + host + ':' + port + '/v1.0/gpu/info/json'
try:
r = requests.get(nd_url)
if r.status_code == 200:
status = r.json()
for i, device in enumerate(status['Devices']):
gm = int(round(math.log(int(device['Memory']['Global']), 2)))
gpu_status[i] = {'global_memory': 2**gm,
'cores': device['Cores']}
else:
usage = (False, "Unable to get GPU usage request error code: " +
str(r.status_code))
except Exception as e: # pragma: no cover
usage = (False, "Error: " + str(e))
# get actual status of each gpu
nd_url = 'http://' + host + ':' + port + '/v1.0/gpu/status/json'
try:
r = requests.get(nd_url)
if r.status_code == 200:
status = r.json()
for i, device in enumerate(status['Devices']):
if i not in gpu_status:
gpu_status[i] = {}
gpu_status[i]['utilization'] = device['Utilization']
gpu_status[i]['memory'] = device['Memory']
gpu_status[i]['processes'] = device['Processes']
usage = (True, gpu_status)
else:
usage = (False, "Unable to get GPU usage request error code: " +
str(r.status_code))
except Exception as e: # pragma: no cover
usage = (False, "Error: " + str(e))
return usage
def Images(vent=True):
""" Get images that are build, by default limit to vent images """
images = []
# TODO needs to also check images in the manifest that couldn't have the
# label added
try:
d_client = docker.from_env()
if vent:
i = d_client.images.list(filters={'label': 'vent'})
else:
i = d_client.images.list()
for image in i:
images.append((image.tags[0], image.short_id))
except Exception as e: # pragma: no cover
logger.error("Something with the Images went wrong " + str(e))
return images
def Jobs():
"""
Get the number of jobs that are running and finished, and the number of
total tools running and finished for those jobs
"""
jobs = [0, 0, 0, 0]
# get running jobs
try:
d_client = docker.from_env()
c = d_client.containers.list(all=False,
filters={'label': 'vent-plugin'})
files = []
for container in c:
jobs[1] += 1
if 'file' in container.attrs['Config']['Labels']:
if container.attrs['Config']['Labels']['file'] not in files:
files.append(container.attrs['Config']['Labels']['file'])
jobs[0] = len(files)
except Exception as e: # pragma: no cover
logger.error("Could not get running jobs " + str(e))
# get finished jobs
try:
d_client = docker.from_env()
c = d_client.containers.list(all=True,
filters={'label': 'vent-plugin',
'status': 'exited'})
file_names = []
tool_names = []
finished_jobs = []
path_dirs = PathDirs()
manifest = os.path.join(path_dirs.meta_dir, "status.json")
if os.path.exists(manifest):
file_status = 'a'
else:
file_status = 'w'
# get a list of past jobs' file names if status.json exists
if file_status == 'a':
with open(manifest, 'r') as infile:
for line in infile:
finished_jobs.append(json.loads(line))
# get a list of file names so we can check against each container
file_names = [d['FileName'] for d in finished_jobs]
# multiple tools can run on 1 file. Use a tuple to status check
tool_names = [(d['FileName'], d['VentPlugin'])
for d in finished_jobs]
for container in c:
jobs[3] += 1
if 'file' in container.attrs['Config']['Labels']:
# make sure the file name and the tool tup exists because
# multiple tools can run on 1 file.
if (container.attrs['Config']['Labels']['file'],
container.attrs['Config']['Labels']['vent.name']) not in \
tool_names:
# TODO figure out a nicer way of getting desired values
# from containers.attrs.
new_file = {}
new_file['FileName'] = \
container.attrs['Config']['Labels']['file']
new_file['VentPlugin'] = \
container.attrs['Config']['Labels']['vent.name']
new_file['StartedAt'] = \
container.attrs['State']['StartedAt']
new_file['FinishedAt'] = \
container.attrs['State']['FinishedAt']
new_file['ID'] = \
container.attrs['Id'][:12]
# create/append a json file with all wanted information
with open(manifest, file_status) as outfile:
json.dump(new_file, outfile)
outfile.write("\n")
# delete any containers with 'vent-plugin' in the groups
if 'vent-plugin' in container.attrs['Config']['Labels']:
container.remove()
# add extra one to account for file that just finished if the file was
# just created since file_names is processed near the beginning
if file_status == 'w' and len(file_names) == 1:
jobs[2] = len(set(file_names)) + 1
else:
jobs[2] = len(set(file_names))
jobs[3] = jobs[3] - jobs[1]
except Exception as e: # pragma: no cover
logger.error("Could not get finished jobs " + str(e))
return tuple(jobs)
def Tools(**kargs):
""" Get tools that exist in the manifest """
path_dirs = PathDirs(**kargs)
manifest = os.path.join(path_dirs.meta_dir, "plugin_manifest.cfg")
template = Template(template=manifest)
tools = template.sections()
return tools[1]
def Services(core, vent=True, external=False, **kargs):
"""
Get services that have exposed ports, expects param core to be True or
False based on which type of services to return, by default limit to vent
containers and processes not running externally, if not limited by vent
containers, then core is ignored.
"""
services = | |
== 3 and self.dim_L == 6
self.T_min = self.T_initial
self.L_min = self.L_initial
self.S_min = self.S_initial
self.x = self.pack(self.T_min, self.L_min, self.S_min)
self.n = self.x.size()
self.minimizer = lbfgs.run(
target_evaluator = self,
termination_params = lbfgs.termination_parameters(
max_iterations = max_iterations,
max_calls = int(max_iterations*1.5)),
exception_handling_params =
lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = True)
)
self.compute_functional_and_gradients()
del self.x
def pack(self, T, L, S):
v = []
if (self.refine_T): v += list(flex.double([T]))
if (self.refine_L): v += list(L)
if (self.refine_S): v += list(S)
return flex.double(tuple(v))
def unpack_x(self):
i = 0
if (self.refine_T):
self.T_min = tuple(self.x)[i:self.dim_T]
i = self.dim_T
if (self.refine_L):
self.L_min = tuple(self.x)[i:i+self.dim_L]
i += self.dim_L
if (self.refine_S):
self.S_min = tuple(self.x)[i:i+self.dim_S]
def compute_functional_and_gradients(self):
self.unpack_x()
manager = tls_from_uiso_target_and_grads(self.T_min[0],
self.L_min,
self.S_min,
self.origin,
self.sites,
self.uiso)
self.f = manager.target()
self.g = self.pack(manager.grad_T(), manager.grad_L(), manager.grad_S())
return self.f, self.g
#######
class tls_xray_target_minimizer(object):
def __init__(self,
fmodel,
tlsos_initial,
refine_T,
refine_L,
refine_S,
selections,
selections_1d,
max_iterations,
run_finite_differences_test = False,
correct_adp = True):
adopt_init_args(self, locals())
fmodel.xray_structure.scatterers().flags_set_grads(state=False)
xray.set_scatterer_grad_flags(scatterers = fmodel.xray_structure.scatterers(),
u_aniso = True)
if(self.run_finite_differences_test): self.correct_adp = False
self.fmodel_copy = self.fmodel.deep_copy()
self.target_functor = self.fmodel_copy.target_functor()
self.run_finite_differences_test_counter = 0
self.T_initial = []
self.L_initial = []
self.S_initial = []
self.origins = []
for tlso_ in tlsos_initial:
self.T_initial.append(tlso_.t)
self.L_initial.append(tlso_.l)
self.S_initial.append(tlso_.s)
self.origins.append(tlso_.origin)
self.counter = 0
self.n_groups = len(self.T_initial)
self.dim_T = len(self.T_initial[0])
self.dim_L = len(self.L_initial[0])
self.dim_S = len(self.S_initial[0])
self.T_min = self.T_initial
self.L_min = self.L_initial
self.S_min = self.S_initial
self.x = self.pack(self.T_min, self.L_min, self.S_min)
self.minimizer = lbfgs.run(
target_evaluator = self,
core_params = lbfgs.core_parameters(maxfev = 10),
termination_params = lbfgs.termination_parameters(
min_iterations = max_iterations,
max_calls = int(max_iterations*1.5)),
exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = True))
self.compute_functional_and_gradients()
del self.x
self.tlsos_result = generate_tlsos(
selections = self.selections,
xray_structure = self.fmodel.xray_structure,
T = self.T_min,
L = self.L_min,
S = self.S_min)
def pack(self, T, L, S):
v = []
for Ti,Li,Si in zip(T,L,S):
if (self.refine_T): v += list(Ti)
if (self.refine_L): v += list(Li)
if (self.refine_S): v += list(Si)
return flex.double(tuple(v))
def unpack_x(self):
i = 0
T_min = []
L_min = []
S_min = []
for j in xrange(self.n_groups):
if (self.refine_T):
self.T_min[j] = tuple(self.x)[i:i+self.dim_T]
i += self.dim_T
if (self.refine_L):
self.L_min[j] = tuple(self.x)[i:i+self.dim_L]
i += self.dim_L
if (self.refine_S):
self.S_min[j] = tuple(self.x)[i:i+self.dim_S]
i += self.dim_S
def compute_functional_and_gradients(self):
self.counter += 1
self.unpack_x()
tlsos = generate_tlsos(selections = self.selections,
xray_structure = self.fmodel_copy.xray_structure,
T = self.T_min,
L = self.L_min,
S = self.S_min)
update_xray_structure_with_tls(
xray_structure = self.fmodel_copy.xray_structure,
selections = self.selections,
selections_1d = self.selections_1d,
tlsos = tlsos,
correct_adp = self.correct_adp)
self.fmodel_copy.update_xray_structure(update_f_calc=True)
t_r = self.target_functor(compute_gradients=True)
self.f = t_r.target_work()
grad_manager = tls_xray_grads(
target_result=t_r,
selections=self.selections,
tlsos=tlsos)
self.g = self.pack(grad_manager.grad_T,
grad_manager.grad_L,
grad_manager.grad_S)
if(self.run_finite_differences_test and
self.run_finite_differences_test_counter < 2):
tolerance = 1.e-3
self.run_finite_differences_test_counter += 1
GT,GL,GS = finite_differences_grads_of_xray_target_wrt_tls(
target_functor=self.target_functor,
T=self.T_min,
L=self.L_min,
S=self.S_min,
origins=self.origins,
selections=self.selections,
delta=0.00001)
format = "%10.6f %10.6f %10.6f %10.6f %10.6f %10.6f"
formats="%10.6f %10.6f %10.6f %10.6f %10.6f %10.6f %10.6f %10.6f %10.6f"
for m1,m2 in zip(grad_manager.grad_T, GT):
if(0):
print "T1=" + format % (m1[0],m1[1],m1[2],m1[3],m1[4],m1[5])
print "T2=" + format % (m2[0],m2[1],m2[2],m2[3],m2[4],m2[5])
assert approx_equal(m1,m2,tolerance)
for m1,m2 in zip(grad_manager.grad_L, GL):
if(0):
print "L1=" + format % (m1[0],m1[1],m1[2],m1[3],m1[4],m1[5])
print "L2=" + format % (m2[0],m2[1],m2[2],m2[3],m2[4],m2[5])
assert approx_equal(m1,m2,tolerance)
for m1,m2 in zip(grad_manager.grad_S, GS):
if(0):
print "S1=" + formats %\
(m1[0],m1[1],m1[2],m1[3],m1[4],m1[5],m1[6],m1[7],m1[8])
print "S2=" + formats %\
(m2[0],m2[1],m2[2],m2[3],m2[4],m2[5],m2[6],m2[7],m2[8])
assert approx_equal(m1,m2,tolerance)
return self.f, self.g
class tls_xray_grads(object):
def __init__(self, target_result, selections, tlsos):
self.grad_T = []
self.grad_L = []
self.grad_S = []
d_target_d_uaniso = target_result.gradients_wrt_atomic_parameters(
u_aniso=True)
for sel, tlso in zip(selections, tlsos):
d_target_d_tls_manager = d_target_d_tls(
sites=target_result.manager.xray_structure.sites_cart().select(sel),
origin = tlso.origin,
d_target_d_uaniso = d_target_d_uaniso.select(sel),
scale_l_and_s = True,# False will brake f.d. test
use_trace_s_zero_constraint = True)
self.grad_T.append(list(d_target_d_tls_manager.grad_T()))
self.grad_L.append(list(d_target_d_tls_manager.grad_L()))
self.grad_S.append(list(d_target_d_tls_manager.grad_S()))
def update_xray_structure_with_tls(xray_structure,
selections,
tlsos,
selections_1d = None,
correct_adp = True):
global time_update_xray_structure_with_tls
timer = user_plus_sys_time()
u_cart_from_tls_ = u_cart_from_tls(sites_cart = xray_structure.sites_cart(),
selections = selections,
tlsos = tlsos)
xray_structure.set_u_cart(u_cart=u_cart_from_tls_, selection = selections_1d)
if(correct_adp): xray_structure.tidy_us(u_min = 1.e-6)
time_update_xray_structure_with_tls += timer.elapsed()
def split_u(xray_structure, tls_selections, offset):
global time_split_u
timer = user_plus_sys_time()
uc = xray_structure.unit_cell()
u_iso = xray_structure.scatterers().extract_u_iso()
u_eq_1 = xray_structure.extract_u_iso_or_u_equiv()
for tls_selection in tls_selections:
u_iso_sel = u_iso.select(tls_selection)
u_iso_min = flex.min(u_iso_sel)
if(offset):
offset_ = adptbx.b_as_u(5.0)
else: offset_ = 0.0
if u_iso_min >= offset_:
u_iso_min = u_iso_min - offset_
t = adptbx.u_iso_as_u_star(uc, u_iso_min)
for i_seq in tls_selection:
sc = xray_structure.scatterers()[i_seq]
assert sc.u_iso == u_iso[i_seq]
u_iso_new = sc.u_iso - u_iso_min
assert u_iso_new >= 0.0
sc.u_iso = u_iso_new
assert sc.flags.use_u_aniso()
assert sc.flags.use_u_iso()
if(sc.u_star == (-1.0,-1.0,-1.0,-1.0,-1.0,-1.0)):
sc.u_star = t
else:
x = flex.double(sc.u_star)
y = flex.double(t)
z = list(x + y)
sc.u_star = z
u_iso = xray_structure.scatterers().extract_u_iso().select(
xray_structure.use_u_iso())
assert (u_iso < 0.0).count(True) == 0
u_eq_2 = xray_structure.extract_u_iso_or_u_equiv()
assert approx_equal(u_eq_1, u_eq_2)
time_split_u += timer.elapsed()
def tls_from_u_cart(xray_structure,
tlsos_initial,
tls_selections,
number_of_macro_cycles = 100,
max_iterations = 100):
global time_tls_from_u_cart
timer = user_plus_sys_time()
uc = xray_structure.unit_cell()
xray_structure.tidy_us(u_min = 1.e-6)
ueq = xray_structure.extract_u_iso_or_u_equiv()
assert (ueq < 0.0).count(True) == 0
u_cart = xray_structure.scatterers().extract_u_cart(uc)
for tls_selection in tls_selections:
u_cart_selected = u_cart.select(tls_selection)
assert adptbx.is_positive_definite(u_cart_selected,1.e-6).count(False)==0
xray_structure.tidy_us(u_min = 1.e-6)
t = []
l = []
s = []
lim_l = 10.0
for tls_selection, tlso in zip(tls_selections, tlsos_initial):
t.append( tlso.t )
#if(abs(tlso.t[0]) < eps and abs(tlso.t[1]) < eps and abs(tlso.t[2]) < eps and
# abs(tlso.t[3]) < eps and abs(tlso.t[4]) < eps and abs(tlso.t[5]) < eps):
# t.append( t_from_u_cart(u_cart.select(tls_selection), 1.e-6) )
#else:
# t.append( tlso.t )
#l.append( [0,0,0,0,0,0] )
if abs(tlso.l[0])>lim_l: l1 = tlso.l[0]/5.
else: l1 = tlso.l[0]
if abs(tlso.l[1])>lim_l: l2 = tlso.l[1]/5.
else: l2 = tlso.l[1]
if abs(tlso.l[2])>lim_l: l3 = tlso.l[2]/5.
else: l3 = tlso.l[2]
if abs(tlso.l[3])>lim_l: l4 = tlso.l[3]/5.
else: l4 = tlso.l[3]
if abs(tlso.l[4])>lim_l: l5 = tlso.l[4]/5.
else: l5 = tlso.l[4]
if abs(tlso.l[5])>lim_l: l6 = tlso.l[5]/5.
else: l6 = tlso.l[5]
l.append( [l1,l2,l3,l4,l5,l6] )
s.append( tlso.s )
tlsos = generate_tlsos(selections = tls_selections,
xray_structure = xray_structure,
T = t, L = l, S = s)
#for rt,rl,rs in [[0,1,1],[1,0,0]]*3:
for rt,rl,rs in [[0,1,1],[1,0,0],[1,1,1]]:
tlsos_ = tls_from_uanisos(xray_structure = xray_structure,
selections = tls_selections,
tlsos_initial = tlsos,
number_of_macro_cycles = number_of_macro_cycles,
max_iterations = max_iterations,
refine_T = rt,
refine_L = rl,
refine_S = rs,
verbose = -1,
out = None)
tlsos = tlsos_
t = []
l = []
s = []
for tlso in tlsos:
t.append( tlso.t )
if abs(tlso.l[0])>lim_l: l1 = lim_l/5.
else: l1 = tlso.l[0]
if abs(tlso.l[1])>lim_l: l2 = lim_l/5.
else: l2 = tlso.l[1]
if abs(tlso.l[2])>lim_l: l3 = lim_l/5.
else: l3 = tlso.l[2]
if abs(tlso.l[3])>lim_l: l4 = lim_l/5.
else: l4 = tlso.l[3]
if abs(tlso.l[4])>lim_l: l5 = lim_l/5.
else: l5 = tlso.l[4]
if abs(tlso.l[5])>lim_l: l6 = lim_l/5.
else: l6 = tlso.l[5]
l.append( [l1,l2,l3,l4,l5,l6] )
s.append( tlso.s )
tlsos = generate_tlsos(selections = tls_selections,
xray_structure = xray_structure,
T = t, L = l, S = s)
time_tls_from_u_cart += timer.elapsed()
return tlsos
class tls_refinement(object):
def __init__(self,
fmodel,
model,
selections,
selections_1d,
refine_T,
refine_L,
refine_S,
number_of_macro_cycles,
max_number_of_iterations,
start_tls_value = None,
run_finite_differences_test = False,
eps = 1.e-6,
out = None,
macro_cycle = None,
verbose = True):
global time_tls_total
timer = user_plus_sys_time()
if(out is None): out = sys.stdout
prefix = "TLS refinement:"
fmodel.info().show_targets(text = prefix+" start model", out = out)
fmodel.xray_structure.show_u_statistics(text = prefix+" start model",
out = out)
xrs = fmodel.xray_structure
xrs.tidy_us(u_min = 1.e-6)
if(start_tls_value is not None):
try:
crash_or_not = abs(start_tls_value + 0)
tlsos = generate_tlsos(value = start_tls_value,
selections = selections,
xray_structure = xrs)
except Exception:
tlsos = start_tls_value
else:
tlsos = tls_from_u_cart(xray_structure = xrs,
tlsos_initial = model.tls_groups.tlsos,
tls_selections = selections,
number_of_macro_cycles = 100,
max_iterations = 100)
if (verbose) :
show_tls(tlsos = tlsos, text = prefix+" start parameters",out = out)
for macro_cycle in range(1, number_of_macro_cycles+1):
print >> out
prefix = "TLS refinement: after macrocycle "+str(macro_cycle)
minimized = tls_xray_target_minimizer(
fmodel = fmodel,
tlsos_initial = tlsos,
refine_T = refine_T,
refine_L = refine_L,
refine_S = refine_S,
selections = selections,
selections_1d = selections_1d,
max_iterations = max_number_of_iterations,
run_finite_differences_test = run_finite_differences_test)
xrs = minimized.fmodel_copy.xray_structure
xrs.show_u_statistics(text = prefix, out = out)
if(verbose):
show_tls(tlsos = minimized.tlsos_result, text = prefix, out = out)
fmodel.update_xray_structure(xray_structure = xrs,
update_f_calc = True)
fmodel.info().show_targets(text = prefix, out = out)
if(xrs.is_positive_definite_u().count(False) > 0):
xrs.tidy_us(u_min = 1.e-6)
xrs.show_u_statistics(
text = prefix+": after making positive definite",
out = out)
fmodel.update_xray_structure(xray_structure = xrs,
update_f_calc = True)
fmodel.info().show_targets(text=prefix+": after making positive definite",
out = out)
tlsos = make_tlso_compatible_with_u_positive_definite(
tlsos = minimized.tlsos_result,
xray_structure = xrs.deep_copy_scatterers(),
selections = selections,
max_iterations = 10,
number_of_u_nonpositive_definite = 0,
eps = eps,
refine_T = refine_T,
refine_L = refine_L,
refine_S = refine_S,
out = | |
<reponame>chunmk/modeldb
# -*- coding: utf-8 -*-
from __future__ import print_function
import ast
import copy
import glob
import os
import pathlib2
import pprint
import shutil
import sys
import tempfile
import time
import warnings
import zipfile
import requests
from .entity import _ModelDBEntity, _MODEL_ARTIFACTS_ATTR_KEY
from .deployable_entity import _DeployableEntity
from .._protos.public.common import CommonService_pb2 as _CommonCommonService
from .._protos.public.modeldb import CommonService_pb2 as _CommonService
from .._protos.public.modeldb import ExperimentRunService_pb2 as _ExperimentRunService
from ..external import six
from ..external.six.moves import cPickle as pickle # pylint: disable=import-error, no-name-in-module
from .._internal_utils import (
_artifact_utils,
_pip_requirements_utils,
_request_utils,
_utils,
importer,
)
from .._dataset_versioning import (
dataset as _dataset,
dataset_version as _dataset_version,
)
from .. import _repository
from .._repository import commit as commit_module
from .. import data_types
from .. import deployment
from .. import utils
from ..environment import _Environment, Python
class ExperimentRun(_DeployableEntity):
"""
Object representing a machine learning Experiment Run.
This class provides read/write functionality for Experiment Run metadata.
There should not be a need to instantiate this class directly; please use
:meth:`Client.set_experiment_run() <verta.client.Client.set_experiment_run>`.
Attributes
----------
id : str
ID of this Experiment Run.
name : str
Name of this Experiment Run.
has_environment : bool
Whether there is an environment associated with this Experiment Run.
"""
def __init__(self, conn, conf, msg):
super(ExperimentRun, self).__init__(conn, conf,
_ExperimentRunService, "experiment-run", msg)
def __repr__(self):
self._refresh_cache()
run_msg = self._msg
return '\n'.join((
"name: {}".format(run_msg.name),
"url: {}://{}/{}/projects/{}/exp-runs/{}".format(
self._conn.scheme, self._conn.socket, self.workspace, run_msg.project_id, self.id),
"date created: {}".format(
_utils.timestamp_to_str(int(run_msg.date_created))),
"date updated: {}".format(
_utils.timestamp_to_str(int(run_msg.date_updated))),
"description: {}".format(run_msg.description),
"tags: {}".format(run_msg.tags),
"attributes: {}".format(
_utils.unravel_key_values(run_msg.attributes)),
"id: {}".format(run_msg.id),
"experiment id: {}".format(run_msg.experiment_id),
"project id: {}".format(run_msg.project_id),
"hyperparameters: {}".format(
_utils.unravel_key_values(run_msg.hyperparameters)),
"observations: {}".format(
_utils.unravel_observations(run_msg.observations)),
"metrics: {}".format(_utils.unravel_key_values(run_msg.metrics)),
"artifact keys: {}".format(
_utils.unravel_artifacts(run_msg.artifacts)),
))
def _update_cache(self):
self._hyperparameters = _utils.unravel_key_values(
self._msg.hyperparameters)
self._metrics = _utils.unravel_key_values(self._msg.metrics)
@property
def workspace(self):
self._refresh_cache()
proj_id = self._msg.project_id
response = _utils.make_request(
"GET",
"{}://{}/api/v1/modeldb/project/getProjectById".format(
self._conn.scheme, self._conn.socket),
self._conn, params={'id': proj_id},
)
_utils.raise_for_http_error(response)
project_json = _utils.body_to_json(response)['project']
if 'workspace_id' not in project_json:
# workspace is OSS default
return self._conn._OSS_DEFAULT_WORKSPACE
else:
return self._conn.get_workspace_name_from_legacy_id(project_json['workspace_id'])
@property
def name(self):
self._refresh_cache()
return self._msg.name
@property
def has_environment(self):
self._refresh_cache()
return self._msg.environment.HasField("python") or self._msg.environment.HasField("docker")
@classmethod
def _generate_default_name(cls):
return "Run {}".format(_utils.generate_default_name())
@classmethod
def _get_proto_by_id(cls, conn, id):
Message = _ExperimentRunService.GetExperimentRunById
msg = Message(id=id)
response = conn.make_proto_request("GET",
"/api/v1/modeldb/experiment-run/getExperimentRunById",
params=msg)
return conn.maybe_proto_response(response, Message.Response).experiment_run
@classmethod
def _get_proto_by_name(cls, conn, name, expt_id):
Message = _ExperimentRunService.GetExperimentRunByName
msg = Message(experiment_id=expt_id, name=name)
response = conn.make_proto_request("GET",
"/api/v1/modeldb/experiment-run/getExperimentRunByName",
params=msg)
return conn.maybe_proto_response(response, Message.Response).experiment_run
@classmethod
def _create_proto_internal(cls, conn, ctx, name, desc=None, tags=None, attrs=None, date_created=None):
Message = _ExperimentRunService.CreateExperimentRun
msg = Message(project_id=ctx.proj.id, experiment_id=ctx.expt.id, name=name,
description=desc, tags=tags, attributes=attrs,
date_created=date_created, date_updated=date_created)
response = conn.make_proto_request("POST",
"/api/v1/modeldb/experiment-run/createExperimentRun",
body=msg)
expt_run = conn.must_proto_response(
response, Message.Response).experiment_run
print("created new ExperimentRun: {}".format(expt_run.name))
return expt_run
def _log_artifact(self, key, artifact, artifact_type, extension=None, method=None, overwrite=False):
"""
Logs an artifact to this Experiment Run.
Parameters
----------
key : str
Name of the artifact.
artifact : str or file-like or object
Artifact or some representation thereof.
- If str, then it will be interpreted as a filesystem path, its contents read as bytes,
and uploaded as an artifact.
- If file-like, then the contents will be read as bytes and uploaded as an artifact.
- Otherwise, the object will be serialized and uploaded as an artifact.
artifact_type : int
Variant of `_CommonCommonService.ArtifactTypeEnum`.
extension : str, optional
Filename extension associated with the artifact.
method : str, optional
Serialization method used to produce the bytestream, if `artifact` was already serialized by verta.
overwrite : bool, default False
Whether to allow overwriting an existing artifact with key `key`.
"""
if isinstance(artifact, six.string_types):
os.path.expanduser(artifact)
artifact = open(artifact, 'rb')
if hasattr(artifact, 'read') and method is not None: # already a verta-produced stream
artifact_stream = artifact
else:
artifact_stream, method = _artifact_utils.ensure_bytestream(
artifact)
if extension is None:
extension = _artifact_utils.ext_from_method(method)
# calculate checksum
artifact_hash = _artifact_utils.calc_sha256(artifact_stream)
artifact_stream.seek(0)
# determine basename
# The key might already contain the file extension, thanks to our hard-coded deployment
# keys e.g. "model.pkl" and "model_api.json".
if extension is None:
basename = key
elif key.endswith(os.extsep + extension):
basename = key
else:
basename = key + os.extsep + extension
# build upload path from checksum and basename
artifact_path = os.path.join(artifact_hash, basename)
# TODO: incorporate into config
VERTA_ARTIFACT_DIR = os.environ.get('VERTA_ARTIFACT_DIR', "")
VERTA_ARTIFACT_DIR = os.path.expanduser(VERTA_ARTIFACT_DIR)
if VERTA_ARTIFACT_DIR:
print("set artifact directory from environment:")
print(" " + VERTA_ARTIFACT_DIR)
artifact_path = os.path.join(VERTA_ARTIFACT_DIR, artifact_path)
pathlib2.Path(artifact_path).parent.mkdir(
parents=True, exist_ok=True)
# log key to ModelDB
Message = _ExperimentRunService.LogArtifact
artifact_msg = _CommonCommonService.Artifact(key=key,
path=artifact_path,
path_only=True if VERTA_ARTIFACT_DIR else False,
artifact_type=artifact_type,
filename_extension=extension)
msg = Message(id=self.id, artifact=artifact_msg)
data = _utils.proto_to_json(msg)
if overwrite:
response = _utils.make_request("DELETE",
"{}://{}/api/v1/modeldb/experiment-run/deleteArtifact".format(
self._conn.scheme, self._conn.socket),
self._conn, json={'id': self.id, 'key': key})
_utils.raise_for_http_error(response)
response = _utils.make_request("POST",
"{}://{}/api/v1/modeldb/experiment-run/logArtifact".format(
self._conn.scheme, self._conn.socket),
self._conn, json=data)
if not response.ok:
if response.status_code == 409:
raise ValueError("artifact with key {} already exists;"
" consider setting overwrite=True".format(key))
else:
_utils.raise_for_http_error(response)
if VERTA_ARTIFACT_DIR:
print("logging artifact")
with open(artifact_path, 'wb') as f:
shutil.copyfileobj(artifact_stream, f)
print("log complete; file written to {}".format(artifact_path))
else:
self._upload_artifact(key, artifact_stream)
self._clear_cache()
def _upload_artifact(self, key, artifact_stream, part_size=_artifact_utils._64MB):
"""
Uploads `artifact_stream` to ModelDB artifact store.
Parameters
----------
key : str
artifact_stream : file-like
part_size : int, default 64 MB
If using multipart upload, number of bytes to upload per part.
"""
# TODO: add to Client config
env_part_size = os.environ.get('VERTA_ARTIFACT_PART_SIZE', "")
try:
part_size = int(float(env_part_size))
except ValueError: # not an int
pass
else:
print("set artifact part size {} from environment".format(part_size))
artifact_stream.seek(0)
if self._conf.debug:
print("[DEBUG] uploading {} bytes ({})".format(
_artifact_utils.get_stream_length(artifact_stream), key))
artifact_stream.seek(0)
# check if multipart upload ok
url_for_artifact = self._get_url_for_artifact(key, "PUT", part_num=1)
if url_for_artifact.multipart_upload_ok:
# TODO: parallelize this
file_parts = iter(lambda: artifact_stream.read(part_size), b'')
for part_num, file_part in enumerate(file_parts, start=1):
print("uploading part {}".format(part_num), end='\r')
# get presigned URL
url = self._get_url_for_artifact(
key, "PUT", part_num=part_num).url
# wrap file part into bytestream to avoid OverflowError
# Passing a bytestring >2 GB (num bytes > max val of int32) directly to
# ``requests`` will overwhelm CPython's SSL lib when it tries to sign the
# payload. But passing a buffered bytestream instead of the raw bytestring
# indicates to ``requests`` that it should perform a streaming upload via
# HTTP/1.1 chunked transfer encoding and avoid this issue.
# https://github.com/psf/requests/issues/2717
part_stream = six.BytesIO(file_part)
# upload part
response = _utils.make_request(
"PUT", url, self._conn, data=part_stream)
_utils.raise_for_http_error(response)
# commit part
url = "{}://{}/api/v1/modeldb/experiment-run/commitArtifactPart".format(
self._conn.scheme,
self._conn.socket,
)
msg = _CommonService.CommitArtifactPart(id=self.id, key=key)
msg.artifact_part.part_number = part_num
msg.artifact_part.etag = response.headers['ETag']
data = _utils.proto_to_json(msg)
# TODO: increase retries
response = _utils.make_request(
"POST", url, self._conn, json=data)
_utils.raise_for_http_error(response)
print()
# complete upload
url = "{}://{}/api/v1/modeldb/experiment-run/commitMultipartArtifact".format(
self._conn.scheme,
self._conn.socket,
)
msg = _CommonService.CommitMultipartArtifact(id=self.id, key=key)
data = _utils.proto_to_json(msg)
response = _utils.make_request("POST", url, self._conn, json=data)
_utils.raise_for_http_error(response)
else:
# upload full artifact
if url_for_artifact.fields:
# if fields were returned by backend, make a POST request and supply them as form fields
response = _utils.make_request(
"POST", url_for_artifact.url, self._conn,
# requests uses the `files` parameter for sending multipart/form-data POSTs.
# https://stackoverflow.com/a/12385661/8651995
# the file contents must be the final form field
# https://docs.aws.amazon.com/AmazonS3/latest/dev/HTTPPOSTForms.html#HTTPPOSTFormFields
files=list(url_for_artifact.fields.items()) + \
[('file', artifact_stream)],
)
else:
response = _utils.make_request(
"PUT", url_for_artifact.url, self._conn, data=artifact_stream)
_utils.raise_for_http_error(response)
print("upload complete ({})".format(key))
def _log_artifact_path(self, key, artifact_path, artifact_type, overwrite=False):
"""
Logs the filesystem path of an artifact to this Experiment Run.
Parameters
----------
key : str
Name of the artifact.
artifact_path : str
Filesystem path of the artifact.
artifact_type : int
Variant of `_CommonCommonService.ArtifactTypeEnum`.
overwrite : bool, default False
Whether to allow overwriting an existing artifact with key `key`.
"""
# log key-path to ModelDB
Message = _ExperimentRunService.LogArtifact
artifact_msg = _CommonCommonService.Artifact(key=key,
path=artifact_path,
path_only=True,
artifact_type=artifact_type)
msg = Message(id=self.id, artifact=artifact_msg)
data = _utils.proto_to_json(msg)
if overwrite:
response = _utils.make_request("DELETE",
"{}://{}/api/v1/modeldb/experiment-run/deleteArtifact".format(
self._conn.scheme, self._conn.socket),
self._conn, json={'id': self.id, 'key': key})
_utils.raise_for_http_error(response)
response = _utils.make_request("POST",
"{}://{}/api/v1/modeldb/experiment-run/logArtifact".format(
self._conn.scheme, self._conn.socket),
self._conn, json=data)
if not response.ok:
if response.status_code == 409:
raise ValueError("artifact with key {} already exists;"
" consider setting overwrite=True".format(key))
else:
_utils.raise_for_http_error(response)
self._clear_cache()
def _get_artifact(self, key):
"""
Gets the artifact with name `key` from this Experiment Run.
If the artifact was originally logged as just a filesystem path, that path will be returned.
Otherwise, bytes representing the artifact object will be returned.
Parameters
----------
key : str
Name of the artifact.
Returns
-------
str or bytes
Filesystem path or bytes representing the artifact.
bool
True if the artifact was only logged as its filesystem path.
"""
# get key-path from ModelDB
Message = _CommonService.GetArtifacts
msg = Message(id=self.id, key=key)
data = _utils.proto_to_json(msg)
response = _utils.make_request("GET",
"{}://{}/api/v1/modeldb/experiment-run/getArtifacts".format(
self._conn.scheme, self._conn.socket),
self._conn, params=data)
_utils.raise_for_http_error(response)
response_msg = | |
<gh_stars>0
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
"""Metrics computation."""
import sys
import logging
from collections import Counter
from functools import reduce
from operator import add
from pprint import pformat
from typing import List
import torch
import wandb
logging.basicConfig(
format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
level=logging.INFO,
stream=sys.stdout,
)
logger = logging.getLogger(__name__)
LBR = "["
RBR = "]"
IN = "IN:"
SL = "SL:"
class Tree:
"""TOP format tree object."""
def __init__(self, entity, subtrees: List = None):
"""Makes a tree node with value entity and subtrees.
if subtrees is None, .subtrees attribute will be empty list
Args:
entity: intent/slot value, e.g. IN:INTENT
subtrees: list of Tree objects
"""
self.entity = entity
self.subtrees = subtrees
if subtrees is None:
self.subtrees = []
# for per-class metrics
self._counts = Counter([entity])
self._len = 1
if len(self.subtrees) > 0:
self._len += sum(map(len, self.subtrees))
self._counts += reduce(add, (s._counts for s in self.subtrees))
# for __repr__ and __eq__
self._dict_repr = {self.entity: [s._dict_repr for s in self.subtrees]}
def __repr__(self):
return pformat(self._dict_repr)
def __eq__(self, other):
if isinstance(other, dict):
return self._dict_repr == other
if isinstance(other, Tree):
return self._dict_repr == other._dict_repr
raise ValueError(type(other))
def __len__(self):
return self._len
def get_size(self, classes=None):
"""Gets the number of nodes with node.entity in classes.
Args:
classes: optional, a iterable of classes to consider when computing the size
Returns:
if classes argument is not specified, returns the total number of nodes
(same as __len__)
if classes argument is specified, returns only the count of nodes corresponding to classes
"""
if classes is None:
return self.__len__()
_size = sum(self._counts.get(c, 0) for c in classes)
return _size
@property
def counts(self):
return self._counts
@classmethod
def from_tokens(cls, tokens, return_index=False, inside_slot=False):
"""Builds a parsing tree for labeled bracketing score computation.
The tree is build until the last ] symbol, everything after it is ignored
Args:
tokens: list of tokens
return_index: used in recursion to provide token index
Returns:
Tree object, if return_index == False
tuple (Tree, index), if return_index == True
Raises:
ValueError, if tokens do not represent a valid tree
"""
# every tree should start with
# [ ENTITY_TYPE: ENTITY
if len(tokens) < 3 or tokens[0] != LBR:
raise ValueError(f"Tree starts with {tokens[:4]}")
entity_type = tokens[1]
# ignore invalid subtrees
if entity_type not in [IN, SL]:
raise ValueError(f"Tree starts with {tokens[:4]}")
entity = entity_type + tokens[2] # e.g. IN:INTENT
subtrees = []
slot_value_tokens = []
safety = 1000
i = 3
inside_slot = inside_slot or entity_type == SL
while i < len(tokens):
if safety <= 0:
raise RuntimeError(
"The sequence is too long (>1000 tokens) or "
"there is a bug in the tree building function."
)
safety -= 1
token = tokens[i]
# ignore non-slot values
# e.g. ignore "go stuff in" [IN:STUFF Do stuff]
if not inside_slot and token not in [LBR, RBR]:
i += 1
continue
# LBR starts a new subtree
if token == LBR:
subtree, j = cls.from_tokens(
tokens[i:], return_index=True, inside_slot=inside_slot
)
if slot_value_tokens:
subtrees.append(Tree(" ".join(slot_value_tokens)))
slot_value_tokens = []
subtrees.append(subtree)
i += j
continue
# RBR ends the tree, merge slot values into a single leaf if any
# e.g. "stuff value" becomes a single leaf in [IN:GET_STUFF [SL:STUF_VALUE stuff value]]
if token == RBR:
if slot_value_tokens:
subtrees.append(Tree(" ".join(slot_value_tokens)))
slot_value_tokens = []
i += 1
break
# if the token is not a special symbol and inside SL: bracket (probably, nested)
slot_value_tokens.append(token)
i += 1
tree = Tree(entity, subtrees)
if return_index:
return tree, i
return tree
def to_tokens(self):
if not self.subtrees:
return self.entity
return f"[{self.entity} {self.subtrees_to_tokens()}]"
def subtrees_to_tokens(self):
return " ".join([s.to_tokens() for s in self.subtrees])
# Main function
def get_metrics(
pred_tokens,
true_tokens,
monitor_classes,
prefix,
schema_tokenizer,
do_each=False,
verbose=False,
compute_macro=False,
):
"""Computes exact_match and tree-based metrics
Apply prefix to all keys.
The main purpuse of this function is to unify evaluation in PointerModule and cli_utils.evaluate_model()
Args:
pred_tokens: List[List[str]]
true_tokens: List[List[str]]
monitor_classes: List[str]
prefix: str, will be appended to all return dict keys
schema_tokenizer: TopSchemaTokenizer
do_each: bool, if False compute tree path metrics only for monitor_classes[0] and overall
if True compute tree path metrics for all monitor_classes and overall
compute_macro: adds macro-averaged metrics to the return dictionary
Returns:
dictionary with keys
{prefix}_{score_name}
{prefix}_new_classes_{score_name}
cls/{prefix}_{monitor_classes[i]}_{score_name}; if do_each=False then only i == 0, else for each class
for each score_name - key from get_tree_path_scores output dictionary
"""
if verbose:
logger.info(f"Getting metrics for classes {monitor_classes}")
exact_match = sum(int(str(p) == str(l)) for p, l in zip(pred_tokens, true_tokens))
exact_match /= len(true_tokens)
tree_metrics = get_tree_path_metrics(
pred_tokens,
true_tokens,
monitor_classes,
prefix,
do_each,
verbose=verbose,
compute_macro=compute_macro,
)
pred_strs = [schema_tokenizer.detokenize(p) for p in pred_tokens]
true_strs = [schema_tokenizer.detokenize(p) for p in true_tokens]
exact_match_str = sum(int(p == t) for p, t in zip(pred_strs, true_strs)) / len(true_strs)
log_dict = {
f"{prefix}_exact_match": exact_match,
f"{prefix}_exact_match_str": exact_match_str,
**tree_metrics,
}
return log_dict
# Tree path scores
def get_tree_path_metrics(
pred_tokens, true_tokens, monitor_classes, prefix, do_each=False, verbose=False, compute_macro=False,
):
"""Gets metrics for all classes, for monitor classes and for monitor_classes[0].
Apply prefix to all keys.
Args:
pred_tokens: List[List[str]]
true_tokens: List[List[str]]
monitor_classes: List[str]
prefix: str, will be appended to all return dict keys
do_each: bool, if False compute tree path metrics only for monitor_classes[0] and overall
if True compute tree path metrics for all monitor_classes and overall
compute_macro: adds macro-averaged metrics to the return dictionary
Returns:
dictionary with keys
{prefix}_{score_name}
{prefix}_new_classes_{score_name}
cls/{prefix}_{monitor_classes[i]}_{score_name}, if do_each=False then i is only == 0
for each score_name - key from get_tree_path_scores output dictionary
"""
if verbose:
logger.info("Computing tree path scores.")
tree_path_scores = get_tree_path_scores(
pred_tokens=pred_tokens, true_tokens=true_tokens, verbose=verbose
)
tree_path_scores = {f"{prefix}_{k}": v for k, v in tree_path_scores.items()}
if verbose:
logger.info(
"Finished computing tree path scores overall. Starting to compute per-class scores."
)
if monitor_classes is not None:
if verbose:
logger.info(f"Computing scores for classes {monitor_classes}")
_new_classes_scores = get_tree_path_scores(
pred_tokens=pred_tokens, true_tokens=true_tokens, classes=monitor_classes
)
_new_classes_scores = {
f"{prefix}_new_classes_{k}": v for k, v in _new_classes_scores.items()
}
tree_path_scores.update(_new_classes_scores)
sum_p, sum_r, sum_f1 = 0, 0, 0
for i, class_ in enumerate(monitor_classes):
if verbose:
logger.info(f"Computing scores for the class {class_}")
if i > 0 and not do_each:
break
_class_score = get_tree_path_scores(
pred_tokens=pred_tokens, true_tokens=true_tokens, classes=[class_]
)
_class_score_prefixed = {f"cls/{prefix}_{class_}_{k}": v for k, v in _class_score.items()}
tree_path_scores.update(_class_score_prefixed)
sum_p += _class_score["tree_path_precision"]
sum_r += _class_score["tree_path_recall"]
sum_f1 += _class_score["tree_path_f1"]
if compute_macro:
p = sum_p / len(monitor_classes)
r = sum_r / len(monitor_classes)
f1 = sum_f1 / len(monitor_classes)
tree_path_scores[f"{prefix}_precision_macro"] = p
tree_path_scores[f"{prefix}_recall_macro"] = r
tree_path_scores[f"{prefix}_f1_macro"] = f1
return tree_path_scores
def get_tree_path_scores(pred_tokens, true_tokens, classes=None, verbose=False):
"""
Args:
pred_tokens: list of lists of tokens
true_tokens: list of lists of tokens
Returns:
dictionary with keys
predicted_paths
expected_paths
tree_path_precision
tree_path_recall
tree_path_f1
"""
if verbose:
logger.info("Computing tree path scores")
pred_paths_lst, true_paths_lst = [], []
for pred, true in zip(pred_tokens, true_tokens):
if verbose:
logger.info(f"(get_tree_path_scores) Predicted: {pred}")
logger.info(f"(get_tree_path_scores) Expected: {true}")
try:
pred_paths = _get_paths_with_values(Tree.from_tokens(pred))
except ValueError:
pred_paths = dict()
# we need to build true tree even if pred tree is not valid to compute correct n_expected
true_paths = _get_paths_with_values(Tree.from_tokens(true))
pred_paths_lst.append(pred_paths)
true_paths_lst.append(true_paths)
true_positives = 0
n_predicted = 0
n_expected = 0
for pred_paths, true_paths in zip(pred_paths_lst, true_paths_lst):
if classes is None:
n_expected += len(true_paths)
n_predicted += len(pred_paths)
else:
n_expected += len([p for p in true_paths.keys() if any(class_in_path(c, p) for c in classes)])
n_predicted += len([p for p in pred_paths.keys() if any(class_in_path(c, p) for c in classes)])
true_positives += _get_tree_path_matches(pred_paths, true_paths, classes)
precision = 0
if n_predicted > 0:
precision = true_positives / n_predicted
recall = 0
if n_expected > 0:
recall = true_positives / n_expected
f1 = 0
if precision + recall > 0:
f1 = 2 * precision * recall / (precision + recall)
return {
"tree_path_precision": precision,
"tree_path_recall": recall,
"tree_path_f1": f1,
}
def _get_paths_with_values(tree, max_depth=10) -> dict:
"""Goes over the | |
# ecm_7_008 R0(C0R1(Q0R2))(C1R3)
# def RaCRaQRbbaCRb(w, R0, C0, R1, Q0_pair, R2, C1, R3 ):
R0, C0, R1 = para_list[:3]
Q0_pair = para_list[3:5]
R2, C1, R3 = para_list[5:7]
z_list = [RaCRaQRbbaCRb(i, R0, C0, R1, Q0_pair, R2, C1, R3) for i in w]
elif serial == 9:
# ecm_7_009 R0(C0R1)(C1R2)(C2R3)
# def RaCRbaCRbaCRb(w, R0, C0, R1, C1, R2, C2, R3):
R0, C0, R1, C1, R2, C2, R3 = para_list
z_list = [RaCRbaCRbaCRb(i, R0, C0, R1, C1, R2, C2, R3) for i in w]
elif serial == 10:
# ecm_7_010 R0(C0R1)(Q0R2)(C1R3)
# def RaCRbaQRbaCRb(w, R0, C0, R1, Q0_pair, R2, C1, R3):
R0, C0, R1 = para_list[:3]
Q0_pair = para_list[3:5]
R2, C1, R3 = para_list[5:]
z_list = [RaCRbaQRbaCRb(i, R0, C0, R1, Q0_pair, R2, C1, R3) for i in w]
elif serial == 11:
# ecm_7_011 R0(Q0R1(C0R2)(O0R3))
# def RaQRaCRbaORbb(w, R0, Q0_pair, R1, C0, R2, O0, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1 = para_list[3]
C0, R2, O0, R3 = para_list[4:]
z_list = [RaQRaCRbaORbb(i, R0, Q0_pair, R1, C0, R2, O0, R3) for i in w]
elif serial == 12:
# ecm_7_012 R0(Q0R1(C0R2)(L0R3))
# def RaQRaCRbaLRbb(w, R0, Q0_pair, R1, C0, R2, L0, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1, C0, R2, L0, R3 = para_list[3:]
z_list = [RaQRaCRbaLRbb(i, R0, Q0_pair, R1, C0, R2, L0, R3) for i in w]
elif serial == 13:
# ecm_7_013 R0(Q0R1)(Q1R2)(C0R3)
# def RaQRbaQRbaCRb(w, R0, Q0_pair, R1, Q1_pair, R2, C0, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1 = para_list[3]
Q1_pair = para_list[4:6]
R2, C0, R3 = para_list[6:]
z_list = [RaQRbaQRbaCRb(i, R0, Q0_pair, R1, Q1_pair, R2, C0, R3) for i in w]
elif serial == 14:
# ecm_7_014 R0(Q0R1(L0R2)(L1R3))
# def RaQRaLRbaLRbb(w, R0, Q0_pair, R1, L0, R2, L1, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1, L0, R2, L1, R3 = para_list[3:]
z_list = [RaQRaLRbaLRbb(i, R0, Q0_pair, R1, L0, R2, L1, R3) for i in w]
elif serial == 15:
# ecm_7_015 R0(Q0R1(Q1R2)(C0R3))
# def RaQRaQRbaCRbb(w, R0, Q0_pair, R1, Q1_pair, R2, C0, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1 = para_list[3]
Q1_pair = para_list[4:6]
R2, C0, R3 = para_list[6:]
z_list = [RaQRaQRbaCRbb(i, R0, Q0_pair, R1, Q1_pair, R2, C0, R3) for i in w]
elif serial == 16:
# ecm_7_016 R0(Q0R1(Q1R2)(O0R3))
# def RaQRaQRbaORbb(w, R0, Q0_pair, R1, Q1_pair, R2, O0, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1 = para_list[3]
Q1_pair = para_list[4:6]
R2, O0, R3 = para_list[6:]
z_list = [RaQRaQRbaORbb(i, R0, Q0_pair, R1, Q1_pair, R2, O0, R3) for i in w]
elif serial == 17:
# ecm_7_017 R0(Q0R1(C0R2)(C1R3))
# def RaQRaCRbaCRbb(w, R0, Q0_pair, R1, C0, R2, C1, R3):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1, C0, R2, C1, R3 = para_list[3:]
z_list = [RaQRaCRbaCRbb(i, R0, Q0_pair, R1, C0, R2, C1, R3) for i in w]
elif serial == 18:
# 7_018 R(CR(RW))(QR)
# DPFC: ECM-11 R0(C0R1(R2W0))(Q0R3)
# def RaCRaRWbbaQRb(w, R0, C0, R1, R2, W0, Q0_pair, R3):
R0, C0, R1, R2, W0 = para_list[:5]
Q0_pair = para_list[5:7]
R3 = para_list[7]
z_list = [RaCRaRWbbaQRb(i, R0, C0, R1, R2, W0, Q0_pair, R3) for i in w]
elif element_num == 8:
if serial == 1:
# ecm_8_001 (C0R0(C1R1)(C2R2)(C3R3))
# def aCRaCRbaCRbaCRbb(w, C0, R0, C1, R1, C2, R2, C3, R3):
C0, R0, C1, R1, C2, R2, C3, R3 = para_list
z_list = [aCRaCRbaCRbaCRbb(i, C0, R0, C1, R1, C2, R2, C3, R3) for i in w]
elif serial == 2:
# ecm_8_002 (C0R0(L0R1)(L1R2)(L2R3))
# def aCRaLRbaLRbaLRbb(w, C0, R0, L0, R1, L1, R2, L2, R3):
C0, R0, L0, R1, L1, R2, L2, R3 = para_list
z_list = [aCRaLRbaLRbaLRbb(i, C0, R0, L0, R1, L1, R2, L2, R3) for i in w]
elif serial == 3:
# ecm_8_003 L0R0(C0(R1(Q0R2)))(C1R3)
# def LRaCaRaQRbbbaCRb(w, L0, R0, C0, R1, Q0_pair, R2, C1, R3):
L0, R0, C0, R1 = para_list[:4]
Q0_pair = para_list[4:6]
R2, C1, R3 = para_list[6:]
z_list = [LRaCaRaQRbbbaCRb(i, L0, R0, C0, R1, Q0_pair, R2, C1, R3) for i in w]
elif serial == 4:
# ecm_8_004 L0R0(C0R1(Q0R2)(R3W0))
# def LRaCRaQRbaRWbb(w, L0, R0, C0, R1, Q0_pair, R2, R3, W0):
L0, R0, C0, R1 = para_list[:4]
Q0_pair = para_list[4:6]
R2, R3, W0 = para_list[6:]
z_list = [LRaCRaQRbaRWbb(i, L0, R0, C0, R1, Q0_pair, R2, R3, W0) for i in w]
elif serial == 5:
# ecm_8_005 L0R0(C0R1(Q0R2))(C1R3)
# def LRaCRaQRbbaCRb(w, L0, R0, C0, R1, Q0_pair, R2, C1, R3):
L0, R0, C0, R1 = para_list[:4]
Q0_pair = para_list[4:6]
R2, C1, R3 = para_list[6:]
z_list = [LRaCRaQRbbaCRb(i, L0, R0, C0, R1, Q0_pair, R2, C1, R3) for i in w]
elif serial == 6:
# ecm_8_006 L0R0(Q0(R1(L1R2)(C0R3)))
# def LRaQaRaLRbaCRbbb(w, L0, R0, Q0_pair, R1, L1, R2, C0, R3):
L0, R0 = para_list[:2]
Q0_pair = para_list[2:4]
R1, L1, R2, C0, R3 = para_list[4:]
z_list = [LRaQaRaLRbaCRbbb(i, L0, R0, Q0_pair, R1, L1, R2, C0, R3) for i in w]
elif serial == 7:
# ecm_8_007 LR(QR(LR)(CR)) --> L0R0(Q0R1(L1R2)(C0R3))
# def LRaQRaLRbaCRbb(w, L0, R0, Q0_pair, R1, L1, R2, C0, R3):
L0, R0 = para_list[:2]
Q0_pair = para_list[2:4]
R1, L1, R2, C0, R3 = para_list[4:]
z_list = [LRaQRaLRbaCRbb(i, L0, R0, Q0_pair, R1, L1, R2, C0, R3) for i in w]
elif serial == 8:
# ecm_8_008 R0(C0(R1(Q0(R2(C1(R3W0))))))
# def RaCaRaQaRaCaRWbbbbbb(w, R0, C0, R1, Q0_pair, R2, C1, R3, W0):
R0, C0, R1 = para_list[:3]
Q0_pair = para_list[3:5]
R2, C1, R3, W0 = para_list[5:]
z_list = [RaCaRaQaRaCaRWbbbbbb(i, R0, C0, R1, Q0_pair, R2, C1, R3, W0) for i in w]
elif serial == 9:
# ecm_8_009 R(C(R(Q(RW))))(CR) --> R0(C0(R1(Q0(R2W0))))(C1R3)
# def RaCaRaQaRWbbbbaCRb(w, R0, C0, R1, Q0_pair, R2, W0, C1, R3):
R0, C0, R1 = para_list[:3]
Q0_pair = para_list[3:5]
R2, W0, C1, R3 = para_list[5:]
z_list = [RaCaRaQaRWbbbbaCRb(i, R0, C0, R1, Q0_pair, R2, W0, C1, R3) for i in w]
elif serial == 10:
# ecm_8_010 L0R0(C0(R1(Q0(R2(C1R3)))))
# def LRaCaRaQaRaCRbbbbb(w, L0, R0, C0, R1, Q0_pair, R2, C1, R3):
L0, R0, C0, R1 = para_list[:4]
Q0_pair = para_list[4:6]
R2, C1, R3 = para_list[6:]
z_list = [LRaCaRaQaRaCRbbbbb(i, L0, R0, C0, R1, Q0_pair, R2, C1, R3) for i in w]
elif serial == 11:
# ecm_8_011 R0(Q0(R1(Q1R2)(Q2(R3W0))))
# def RaQaRaQRbaQaRWbbbb(w, R0, Q0_pair, R1, Q1_pair, R2, Q2_pair, R3, W0):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1 = para_list[3]
Q1_pair = para_list[4:6]
R2 = para_list[6]
Q2_pair = para_list[7:9]
R3, W0 = para_list[9:]
z_list = [RaQaRaQRbaQaRWbbbb(i, R0, Q0_pair, R1, Q1_pair, R2, Q2_pair, R3, W0) for i in w]
elif element_num == 9:
if serial == 1:
# ecm_9_001 R0(Q0R1(O0R2)(L0R3)(L1R4))
# def RaQRaORbaLRbaLRbb(w, R0, Q0_pair, R1, O0, R2, L0, R3, L1, R4):
R0 = para_list[0]
Q0_pair = para_list[1:3]
R1, O0, R2, L0, R3, L1, R4 = para_list[3:]
z_list = [RaQRaORbaLRbaLRbb(i, R0, Q0_pair, R1, O0, R2, L0, R3, L1, R4) for i in w]
elif serial == 2:
# ecm_9_002 L0R0(C0(R1(Q0(R2(C1(R3W0))))))
# def LRaCaRaQaRaCaRWbbbbbb(w, L0, R0, C0, R1, Q0_pair, R2, C1, R3, W0):
L0, R0, C0, R1 = para_list[:4]
Q0_pair = para_list[4:6]
R2, C1, R3, W0 = para_list[6:]
z_list = [LRaCaRaQaRaCaRWbbbbbb(i, L0, R0, C0, R1, Q0_pair, R2, C1, R3, W0) for i in w]
elif serial == 3:
# ecm_9_003 R0(C0(R1(Q0(R2(L0R3)(C1R4)))))
# def RaCaRaQaRaLRbaCRbbbbb(w, R0, C0, R1, Q0_pair, R2, L0, R3, C1, R4):
R0, C0, R1 = para_list[:3]
Q0_pair = para_list[3:5]
R2, L0, R3, C1, R4 = para_list[5:]
z_list = [RaCaRaQaRaLRbaCRbbbbb(i, R0, C0, R1, Q0_pair, R2, L0, R3, C1, R4) for i in w]
elif serial == 4:
# ecm_9_004 R0(C0R1(L0R2)(L1R3)(O0R4))
# def RaCRaLRbaLRbaORbb(w, R0, C0, R1, L0, R2, L1, R3, O0, R4):
R0, C0, R1, L0, R2, L1, R3, O0, R4 = para_list
z_list = [RaCRaLRbaLRbaORbb(i, R0, C0, R1, L0, R2, L1, R3, O0, R4) for i in w]
elif serial == 5:
# ecm_9_005 R0(C0R1(O0R2)(L0R3)(L1R4))
# def RaCRaORbaLRbaLRbb(w, R0, C0, R1, O0, R2, L0, R3, L1, R4):
R0, C0, R1, O0, R2, L0, R3, L1, R4 = para_list
z_list = [RaCRaORbaLRbaLRbb(i, R0, C0, R1, O0, R2, L0, R3, L1, R4) for i in w]
elif serial == 6:
# ecm_9_006 R0(C0R1(Q0R2)(L0R3)(C1R4))
# def RaCRaQRbaLRbaCRbb(w, R0, C0, R1, Q0_pair, | |
field name ends with ``__ext`` doesn't part of
Resource StructureDefinition, instead used to enable Extensibility feature
for FHIR Primitive Data Types.
Links this graph makes rules about.
"""
resource_type = Field("GraphDefinitionLink", const=True)
description: fhirtypes.String = Field(
None,
alias="description",
title="Why this link is specified",
description=(
"Information about why this link is of interest in this graph "
"definition."
),
# if property is element of this resource.
element_property=True,
)
description__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_description", title="Extension field for ``description``."
)
max: fhirtypes.String = Field(
None,
alias="max",
title="Maximum occurrences for this link",
description=None,
# if property is element of this resource.
element_property=True,
)
max__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_max", title="Extension field for ``max``."
)
min: fhirtypes.Integer = Field(
None,
alias="min",
title="Minimum occurrences for this link",
description=None,
# if property is element of this resource.
element_property=True,
)
min__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_min", title="Extension field for ``min``."
)
path: fhirtypes.String = Field(
None,
alias="path",
title="Path in the resource that contains the link",
description=None,
# if property is element of this resource.
element_property=True,
element_required=True,
)
path__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_path", title="Extension field for ``path``."
)
sliceName: fhirtypes.String = Field(
None,
alias="sliceName",
title="Which slice (if profiled)",
description=None,
# if property is element of this resource.
element_property=True,
)
sliceName__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_sliceName", title="Extension field for ``sliceName``."
)
target: typing.List[fhirtypes.GraphDefinitionLinkTargetType] = Field(
...,
alias="target",
title="Potential target for the link",
description=None,
# if property is element of this resource.
element_property=True,
)
@classmethod
def elements_sequence(cls):
"""returning all elements names from
``GraphDefinitionLink`` according specification,
with preserving original sequence order.
"""
return [
"id",
"extension",
"modifierExtension",
"path",
"sliceName",
"min",
"max",
"description",
"target",
]
@root_validator(pre=True, allow_reuse=True)
def validate_required_primitive_elements_2107(
cls, values: typing.Dict[str, typing.Any]
) -> typing.Dict[str, typing.Any]:
"""https://www.hl7.org/fhir/extensibility.html#Special-Case
In some cases, implementers might find that they do not have appropriate data for
an element with minimum cardinality = 1. In this case, the element must be present,
but unless the resource or a profile on it has made the actual value of the primitive
data type mandatory, it is possible to provide an extension that explains why
the primitive value is not present.
"""
required_fields = [("path", "path__ext")]
_missing = object()
def _fallback():
return ""
errors: typing.List["ErrorWrapper"] = []
for name, ext in required_fields:
field = cls.__fields__[name]
ext_field = cls.__fields__[ext]
value = values.get(field.alias, _missing)
if value not in (_missing, None):
continue
ext_value = values.get(ext_field.alias, _missing)
missing_ext = True
if ext_value not in (_missing, None):
if isinstance(ext_value, dict):
missing_ext = len(ext_value.get("extension", [])) == 0
elif (
getattr(ext_value.__class__, "get_resource_type", _fallback)()
== "FHIRPrimitiveExtension"
):
if ext_value.extension and len(ext_value.extension) > 0:
missing_ext = False
else:
validate_pass = True
for validator in ext_field.type_.__get_validators__():
try:
ext_value = validator(v=ext_value)
except ValidationError as exc:
errors.append(ErrorWrapper(exc, loc=ext_field.alias))
validate_pass = False
if not validate_pass:
continue
if ext_value.extension and len(ext_value.extension) > 0:
missing_ext = False
if missing_ext:
if value is _missing:
errors.append(ErrorWrapper(MissingError(), loc=field.alias))
else:
errors.append(
ErrorWrapper(NoneIsNotAllowedError(), loc=field.alias)
)
if len(errors) > 0:
raise ValidationError(errors, cls) # type: ignore
return values
class GraphDefinitionLinkTarget(backboneelement.BackboneElement):
"""Disclaimer: Any field name ends with ``__ext`` doesn't part of
Resource StructureDefinition, instead used to enable Extensibility feature
for FHIR Primitive Data Types.
Potential target for the link.
"""
resource_type = Field("GraphDefinitionLinkTarget", const=True)
compartment: typing.List[
fhirtypes.GraphDefinitionLinkTargetCompartmentType
] = Field(
None,
alias="compartment",
title="Compartment Consistency Rules",
description=None,
# if property is element of this resource.
element_property=True,
)
link: typing.List[fhirtypes.GraphDefinitionLinkType] = Field(
None,
alias="link",
title="Additional links from target resource",
description=None,
# if property is element of this resource.
element_property=True,
)
profile: fhirtypes.Uri = Field(
None,
alias="profile",
title="Profile for the target resource",
description=None,
# if property is element of this resource.
element_property=True,
)
profile__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_profile", title="Extension field for ``profile``."
)
type: fhirtypes.Code = Field(
None,
alias="type",
title="Type of resource this link refers to",
description=None,
# if property is element of this resource.
element_property=True,
element_required=True,
)
type__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_type", title="Extension field for ``type``."
)
@classmethod
def elements_sequence(cls):
"""returning all elements names from
``GraphDefinitionLinkTarget`` according specification,
with preserving original sequence order.
"""
return [
"id",
"extension",
"modifierExtension",
"type",
"profile",
"compartment",
"link",
]
@root_validator(pre=True, allow_reuse=True)
def validate_required_primitive_elements_2731(
cls, values: typing.Dict[str, typing.Any]
) -> typing.Dict[str, typing.Any]:
"""https://www.hl7.org/fhir/extensibility.html#Special-Case
In some cases, implementers might find that they do not have appropriate data for
an element with minimum cardinality = 1. In this case, the element must be present,
but unless the resource or a profile on it has made the actual value of the primitive
data type mandatory, it is possible to provide an extension that explains why
the primitive value is not present.
"""
required_fields = [("type", "type__ext")]
_missing = object()
def _fallback():
return ""
errors: typing.List["ErrorWrapper"] = []
for name, ext in required_fields:
field = cls.__fields__[name]
ext_field = cls.__fields__[ext]
value = values.get(field.alias, _missing)
if value not in (_missing, None):
continue
ext_value = values.get(ext_field.alias, _missing)
missing_ext = True
if ext_value not in (_missing, None):
if isinstance(ext_value, dict):
missing_ext = len(ext_value.get("extension", [])) == 0
elif (
getattr(ext_value.__class__, "get_resource_type", _fallback)()
== "FHIRPrimitiveExtension"
):
if ext_value.extension and len(ext_value.extension) > 0:
missing_ext = False
else:
validate_pass = True
for validator in ext_field.type_.__get_validators__():
try:
ext_value = validator(v=ext_value)
except ValidationError as exc:
errors.append(ErrorWrapper(exc, loc=ext_field.alias))
validate_pass = False
if not validate_pass:
continue
if ext_value.extension and len(ext_value.extension) > 0:
missing_ext = False
if missing_ext:
if value is _missing:
errors.append(ErrorWrapper(MissingError(), loc=field.alias))
else:
errors.append(
ErrorWrapper(NoneIsNotAllowedError(), loc=field.alias)
)
if len(errors) > 0:
raise ValidationError(errors, cls) # type: ignore
return values
class GraphDefinitionLinkTargetCompartment(backboneelement.BackboneElement):
"""Disclaimer: Any field name ends with ``__ext`` doesn't part of
Resource StructureDefinition, instead used to enable Extensibility feature
for FHIR Primitive Data Types.
Compartment Consistency Rules.
"""
resource_type = Field("GraphDefinitionLinkTargetCompartment", const=True)
code: fhirtypes.Code = Field(
None,
alias="code",
title="Identifies the compartment",
description=None,
# if property is element of this resource.
element_property=True,
element_required=True,
)
code__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_code", title="Extension field for ``code``."
)
description: fhirtypes.String = Field(
None,
alias="description",
title="Documentation for FHIRPath expression",
description=None,
# if property is element of this resource.
element_property=True,
)
description__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_description", title="Extension field for ``description``."
)
expression: fhirtypes.String = Field(
None,
alias="expression",
title="Custom rule, as a FHIRPath expression",
description=None,
# if property is element of this resource.
element_property=True,
)
expression__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_expression", title="Extension field for ``expression``."
)
rule: fhirtypes.Code = Field(
None,
alias="rule",
title="identical | matching | different | custom",
description="identical | matching | different | no-rule | custom.",
# if property is element of this resource.
element_property=True,
element_required=True,
# note: Enum values can be used in validation,
# but use in your own responsibilities, read official FHIR documentation.
enum_values=["identical", "matching", "different", "custom"],
)
rule__ext: fhirtypes.FHIRPrimitiveExtensionType = Field(
None, alias="_rule", title="Extension field for ``rule``."
)
@classmethod
def elements_sequence(cls):
"""returning all elements names from
``GraphDefinitionLinkTargetCompartment`` according specification,
with preserving original sequence order.
"""
return [
"id",
"extension",
"modifierExtension",
"code",
"rule",
"expression",
"description",
]
@root_validator(pre=True, allow_reuse=True)
def validate_required_primitive_elements_3893(
cls, values: typing.Dict[str, typing.Any]
) -> typing.Dict[str, typing.Any]:
"""https://www.hl7.org/fhir/extensibility.html#Special-Case
In some cases, implementers might find that they do not have appropriate data for
an element with minimum cardinality = 1. In this case, the element must be present,
but unless the resource or a profile on it has made the actual value of the primitive
data type mandatory, it is possible to provide an extension that explains why
the primitive value is not present.
"""
required_fields = [("code", "code__ext"), ("rule", "rule__ext")]
_missing = object()
def _fallback():
return ""
errors: typing.List["ErrorWrapper"] = []
for name, ext in required_fields:
field = cls.__fields__[name]
ext_field = cls.__fields__[ext]
value = values.get(field.alias, _missing)
if value not in (_missing, None):
continue
ext_value = values.get(ext_field.alias, _missing)
missing_ext = True
if ext_value not in (_missing, None):
if isinstance(ext_value, dict):
missing_ext = len(ext_value.get("extension", [])) == 0
elif (
getattr(ext_value.__class__, "get_resource_type", _fallback)()
== "FHIRPrimitiveExtension"
):
if ext_value.extension and len(ext_value.extension) > 0:
missing_ext = False
else:
validate_pass = True
for validator in ext_field.type_.__get_validators__():
try:
ext_value = validator(v=ext_value)
except ValidationError as exc:
errors.append(ErrorWrapper(exc, loc=ext_field.alias))
validate_pass = False
if not validate_pass:
continue
if ext_value.extension and len(ext_value.extension) > 0:
| |
<reponame>GaffaSnobb/kshell-utilities
import sys, time, warnings
from typing import Union, Tuple, Optional
from fractions import Fraction
from itertools import chain
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import chi2
from scipy.optimize import curve_fit
from .parameters import flags
def create_spin_parity_list(
spins: np.ndarray,
parities: np.ndarray
) -> list:
"""
Pair up input spins and parities in a list of lists.
Parameters
----------
spins : np.ndarray
Array of spins for each energy level.
parities : np.ndarray
Array of corresponding parities for each energy level.
Returns
-------
spins_parities : list
A nested list of spins and parities [[spin, parity], ...] sorted
with respect to the spin. N is the number of unique spins in
'spins'.
Examples
--------
Example list:
``` python
[[1, +1], [3, +1], [5, +1], [7, +1], [9, +1], [11, +1], [13, +1]]
```
"""
spin_parity_list = []
for i in range(len(spins)):
if (tmp := [int(spins[i]), int(parities[i])]) in spin_parity_list:
continue
spin_parity_list.append(tmp)
return spin_parity_list
def div0(numerator, denominator):
"""
Suppress ZeroDivisionError, set x/0 to 0, and set inf, -inf and nan
to 0. Author <NAME>.
Examples
--------
>>> div0([1, 1, 1], [1, 2, 0])
array([1. , 0.5, 0. ])
"""
with np.errstate(divide='ignore', invalid='ignore'):
res = np.true_divide(numerator, denominator)
res[~np.isfinite(res)] = 0 # -inf inf NaN
return res
def gamma_strength_function_average(
levels: np.ndarray,
transitions: np.ndarray,
bin_width: Union[float, int],
Ex_min: Union[float, int],
Ex_max: Union[float, int],
multipole_type: str,
prefactor_E1: Union[None, float] = None,
prefactor_M1: Union[None, float] = None,
prefactor_E2: Union[None, float] = None,
initial_or_final: str = "initial",
partial_or_total: str = "partial",
include_only_nonzero_in_average: bool = True,
include_n_levels: Union[None, int] = None,
filter_spins: Union[None, list] = None,
filter_parities: str = "both",
return_n_transitions: bool = False,
# plot: bool = False,
# save_plot: bool = False
) -> Tuple[np.ndarray, np.ndarray, Optional[np.ndarray]]:
"""
Calculate the gamma strength function averaged over total angular
momenta, parities, and initial excitation energies.
Author: <NAME>.
Modified by: GaffaSnobb.
TODO: Figure out the pre-factors.
TODO: Use numpy.logical_or to filter levels and transitions to avoid
TODO: Make res.transitions_BXL.ji, res.transitions_BXL.pii, etc.
class attributes (properties).
using many if statements in the loops.
Parameters
----------
levels : np.ndarray
Array containing energy, spin, and parity for each excited
state. [[E, 2*spin, parity, idx], ...]. idx counts how many
times a state of that given spin and parity has occurred. The
first 0+ state will have an idx of 1, the second 0+ will have an
idx of 2, etc.
transitions : np.ndarray
Array containing transition data for the specified
multipolarity.
OLD:
Mx8 array containing [2*spin_final, parity_initial, Ex_final,
2*spin_initial, parity_initial, Ex_initial, E_gamma, B(.., i->f)]
OLD NEW:
[2*spin_initial, parity_initial, Ex_initial, 2*spin_final,
parity_final, Ex_final, E_gamma, B(.., i->f), B(.., f<-i)]
NEW:
[2*spin_initial, parity_initial, idx_initial, Ex_initial,
2*spin_final, parity_final, idx_final, Ex_final, E_gamma,
B(.., i->f), B(.., f<-i)]
bin_width : Union[float, int]
The width of the energy bins. A bin width of 0.2 contains 20
states of uniform spacing of 0.01.
Ex_min : Union[float, int]
Lower limit for initial level excitation energy, usually in MeV.
Ex_max : Union[float, int]
Upper limit for initial level excitation energy, usually in MeV.
multipole_type : str
Choose whether to calculate for 'E1', 'M1' or 'E2'. NOTE:
Currently only M1 and E1 is implemented.
prefactor_E1 : Union[None, float]
E1 pre-factor from the definition of the GSF. Defaults to a
standard value if None.
prefactor_M1 : Union[None, float]
M1 pre-factor from the definition of the GSF. Defaults to a
standard value if None.
prefactor_E2 : Union[None, float]
E2 pre-factor from the definition of the GSF. Defaults to a
standard value if None.
initial_or_final : str
Choose whether to use the energy of the initial or final state
for the transition calculations. NOTE: This may be removed in
a future release since the correct alternative is to use the
initial energy.
partial_or_total : str
Choose whether to use the partial level density
rho(E_i, J_i, pi_i) or the total level density rho(E_i) for
calculating the gamma strength function. Note that the partial
level density, the default value, is probably the correct
alternative. Using the total level density will introduce an
arbitrary scaling depending on how many (J, pi) combinations
were included in the calculations.
This argument is included for easy comparison between the two
densities. See the appendix of PhysRevC.98.064321 for details.
include_only_nonzero_in_average : bool
If True (default) only non-zero values are included in the final
averaging of the gamma strength function. The correct
alternative is to use only the non-zero values, so setting this
parameter to False should be done with care.
include_n_levels : Union[None, int]
The number of states per spin to include. Example:
include_n_levels = 100 will include only the 100 lowest laying
states for each spin.
filter_spins : Union[None, list]
Which spins to include in the GSF. If None, all spins are
included. TODO: Make int valid input too.
filter_parities : str
Which parities to include in the GSF. 'both', '+', '-' are
allowed.
return_n_transitions : bool
Count the number of transitions, as a function of gamma energy,
involved in the GSF calculation and return this number as a
third return value. For calculating Porter-Thomas fluctuations
in the GSF by
r(E_gamma) = sqrt(2/n(E_gamma))
where n is the number of transitions for each gamma energy, used
to calculate the GSF. The value n is called n_transitions_array
in the code. See for example DOI: 10.1103/PhysRevC.98.054303 for
details.
plot : bool
Toogle plotting on / off.
save_plot : bool
Toogle saving of plot (as .png with dpi=300) on / off.
Variables
---------
Ex : np.ndarray
The excitation energy of all levels.
Ex_initial : np.ndarray
The excitation energy of the initial state of a transition.
spins : np.ndarray
The spins of all levels.
parities : np.ndarray
The parities of all levels.
Returns
-------
bins : np.ndarray
The bins corresponding to gSF_ExJpiavg (x values for plot).
gSF_ExJpiavg : np.ndarray
The gamma strength function.
"""
skip_counter = { # Debug.
"Transit: Energy range": 0,
"Transit: Number of levels": 0,
"Transit: Parity": 0,
"Level density: Energy range": 0,
"Level density: Number of levels": 0,
"Level density: Parity": 0
}
total_gsf_time = time.perf_counter()
allowed_filter_parities = ["+", "-", "both"]
if filter_parities not in allowed_filter_parities:
msg = f"filter_parities must be {allowed_filter_parities}"
raise TypeError(msg)
if filter_parities == "both":
filter_parities = [-1, +1]
elif filter_parities == "-":
filter_parities = [-1]
elif filter_parities == "+":
filter_parities = [+1]
if include_n_levels is None:
include_n_levels = np.inf # Include all states.
if (Ex_min < 0) or (Ex_max < 0):
msg = "Ex_min and Ex_max cannot be negative!"
raise ValueError(msg)
if Ex_max < Ex_min:
msg = "Ex_max cannot be smaller than Ex_min!"
raise ValueError(msg)
prefactors = { # Factor from the def. of the GSF.
"M1": 11.5473e-9, # [1/(mu_N**2*MeV**2)].
# "E1": 1.047e-6,
"E1": 3.4888977e-7
}
if prefactor_E1 is not None:
"""
Override the E1 prefactor.
"""
prefactors["E1"] = prefactor_E1
if prefactor_M1 is not None:
"""
Override the M1 prefactor.
"""
prefactors["M1"] = prefactor_M1
if prefactor_E2 is not None:
"""
Override the E2 prefactor.
"""
prefactors["E2"] = prefactor_E2
prefactor = prefactors[multipole_type]
# Extract data to a more readable form:
n_transitions = len(transitions[:, 0])
n_levels = len(levels[:, 0])
E_ground_state = levels[0, 0] # Read out the absolute ground state energy so we can get relative energies later.
try:
Ex, spins, parities, level_counter = np.copy(levels[:, 0]), levels[:, 1], levels[:, 2], levels[:, 3]
except IndexError as err:
msg = f"{err.__str__()}\n"
msg += "Error probably due to old tmp files. Use loadtxt parameter"
msg += " load_and_save_to_file = 'overwrite' to re-read data from the"
msg += " summary file and generate new tmp files."
raise Exception(msg) from err
if initial_or_final == "initial":
Ex_initial_or_final = np.copy(transitions[:, 3]) # To avoid altering the raw data.
spin_initial_or_final_idx = 0
parity_initial_or_final_idx = 1
elif initial_or_final == "final":
Ex_initial_or_final = np.copy(transitions[:, 7]) # To avoid altering the raw data.
spin_initial_or_final_idx = 4
parity_initial_or_final_idx = 5
msg = "Using final states for the energy limits is not correct"
msg += " and should only be | |
# Copyright 2016, 2017, 2018 IBM Corp.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Implementation of hypervisor interface for Zvm
"""
#
# IMPORTS
#
from tempfile import NamedTemporaryFile
from tessia.baselib.common.logger import get_logger
from tessia.baselib.common.params_validators.utils import validate_params
from tessia.baselib.guests.cms.cms import GuestCms, ERROR_REGEX
from tessia.baselib.hypervisors.base import HypervisorBase
#
# CONSTANTS AND DEFINITIONS
#
#
# CODE
#
class HypervisorZvm(HypervisorBase):
"""
This class implements the driver to support the ZVM hypervisor type
"""
# the identifier for this hypervisor class
HYP_ID = 'zvm'
# names of files uploaded to zvm during netboot process
NETBOOT_CMDLINE_FILE = 'PARMFILE PARM T'
NETBOOT_KERNEL_FILE = 'KERNEL IMG T'
NETBOOT_INITRD_FILE = 'INITRD IMG T'
@validate_params
def __init__(self, system_name, host_name, user, passwd, parameters):
"""
Constructor
Args:
system_name (string): string containing the hypervisor name
host_name (string): hostname or ip address of system
user (string): user to login to system
passwd (string): <PASSWORD> system
parameters (dict): a dictionary containing values specific to each
hypervisor type
Raises:
None
"""
# make sure here and noipl are set for the connection
if not parameters:
parameters = {}
parameters['here'] = True
parameters['noipl'] = True
user = user.upper()
super().__init__(system_name, host_name, user,
passwd, parameters)
self._logger = get_logger(__name__)
self._logger.debug(
"create HypervisorZvm: name='%s' host_name='%s' user='%s' "
"parameters='%s'",
self.name,
self.host_name,
self.user,
str(self.parameters)
)
# use the cms class as the connection to the zVM guest
self._cms = GuestCms(user, host_name, user, passwd, parameters)
# __init__()
def _netboot(self, params):
"""
Upload the netboot files to the zVM and perform ipl of the guest via
the reader device.
Args:
params (dict): netboot parameters, see json schema for details
Raises:
RuntimeError: if any zVM command fails
"""
_, re_match = self._cms.run(
r'i cms\naccess (noprof', wait_for=['Ready;'])
if not re_match:
raise RuntimeError('Failed to initialize CMS')
# make sure terminal waits before clearing the screen to prevent
# missing content
self._cms.run('term more 50 10', use_cp=True)
# prepare a vdisk where we can upload the files to
vdisk_dev = 'ffff'
exists_msg = '(?i) {} ON '.format(vdisk_dev)
_, re_match = self._cms.run(
"q v {}".format(vdisk_dev),
wait_for=[ERROR_REGEX, exists_msg], timeout=10)
if not re_match:
raise RuntimeError(
'Query device {} returned unexpected output'.format(vdisk_dev))
# no error message detected: device exists and must be detached
if re_match.re.pattern == exists_msg:
detached_msg = '(?i){} detached'.format(vdisk_dev)
_, re_match = self._cms.run(
'detach {}'.format(vdisk_dev),
wait_for=[ERROR_REGEX, detached_msg], timeout=5)
if not re_match:
raise RuntimeError(
'Detach {} returned unexpected output'.format(vdisk_dev))
if re_match.re.pattern == ERROR_REGEX:
raise RuntimeError('Detach {} failed with: {}'.format(
vdisk_dev, re_match.group()))
# create the vdisk with approx. 100 MB size
defined_msg = '(?i){} defined'.format(vdisk_dev)
_, re_match = self._cms.run(
'define vfb-512 as ffff blk 200000',
wait_for=[ERROR_REGEX, defined_msg], timeout=5)
if not re_match:
raise RuntimeError('Define vdisk returned unexpected output')
if re_match.re.pattern == ERROR_REGEX:
raise RuntimeError('Define vdisk failed with: {}'.format(
re_match.group()))
# format VDISK as file mode t
_, re_match = self._cms.run(
# confirm operation by typing '1' and set disk label as 'tmpdsk'
r'format ffff t\n1\ntmpdsk', wait_for=r'(?i)Ready;',
timeout=10)
if not re_match:
raise RuntimeError('Format vdisk returned unexpected output')
# upload the kernel file
self._cms.push_file(params['kernel_uri'], self.NETBOOT_KERNEL_FILE)
# initrd file specified: upload it
if params.get('initrd_uri'):
self._cms.push_file(params['initrd_uri'], self.NETBOOT_INITRD_FILE)
# create a temp file to hold the kernel args and upload it
with NamedTemporaryFile(mode='w') as file_fd:
file_fd.write(params['cmdline'])
file_fd.flush()
self._cms.push_file('file://{}'.format(file_fd.name),
self.NETBOOT_CMDLINE_FILE)
# commands to prepare the reader device and punch the files to it
cmds = [
'spool punch * rdr',
'close reader',
'purge reader all',
'punch {} (noh'.format(self.NETBOOT_KERNEL_FILE),
'punch {} (noh'.format(self.NETBOOT_CMDLINE_FILE),
]
if params.get('initrd_uri'):
cmds.append('punch {} (noh'.format(self.NETBOOT_INITRD_FILE))
cmds.append('change reader all keep')
# reset puncher to defaults
cmds.append('spool pun off')
# execute all commands, abort in case of error
wait_prompts = [r'Ready;', r'Ready\(\d+\);']
for cmd in cmds:
_, re_match = self._cms.run(
cmd, wait_for=wait_prompts, timeout=300)
if not re_match:
raise RuntimeError(
"Command '{}' returned unexpected output".format(cmd))
if re_match.re.pattern == wait_prompts[1]:
raise RuntimeError("Command '{}' failed with: {}".format(
cmd, re_match.group()))
# IPL the reader
_, re_match = self._cms.run(
'ipl 00c clear',
wait_for=['Kernel command line: '], timeout=600)
if not re_match:
raise RuntimeError('Failed to IPL downloaded kernel')
# _netboot()
@staticmethod
def _split_chars(string, size):
"""
Split a string in sub-strings separated by space in chunks
determined by 'size'.
Args:
string (str): string to split
size (int): size of each sub-string
Returns:
str: resulting string containing sub-strings
"""
index = 0
result = []
while index < len(string):
result.append(string[index:index+size])
index += size
return ' '.join(result)
# _split_chars()
def login(self, timeout=60):
"""
Execute the login to the hypervisor system using the credentials
provided.
Args:
timeout (int): how many seconds to wait for connection
Raises:
None
"""
self._logger.debug(
"performing LOGIN HypervisorZvm: name='%s' host_name='%s' "
"user='%s' parameters='%s'",
self.name,
self.host_name,
self.user,
str(self.parameters)
)
# login to the zVM guest
self._cms.login()
# login()
def logoff(self):
"""
Close an active connection to the hypervisor system
Args:
None
Raises:
RuntimeError: In case of fail during logoff
"""
self._logger.debug("performing LOGOFF HypervisorZvm")
# disconnect from zVM guest, keep the guest running
self._cms.logoff()
# logoff()
def set_boot_device(self, guest_name, boot_device):
"""
Set boot device for next load
For ZVM it is a no-op
Args:
guest_name (str): guest to operate on
boot_device (dict): boot device config
"""
self._logger.debug(
"performing SET_BOOT_DEVICE HypervisorZvm: name='%s', guest='%s' "
"boot_device='%s'",
self.name,
guest_name,
str(boot_device)
)
@validate_params
def start(self, guest_name, cpu, memory, parameters):
"""
Attach the given resources and IPL the guest using the method and
device specified.
Args:
guest_name (str): Name of the guest as known by hypervisor
cpu (int): Number of CPUs to assign
memory (int): Amount of memory to assign in megabytes
parameters (dict): additional parameters, see json schema for
details
Raises:
RuntimeError: if any zVM command fails
ValueError: - if boot method is 'disk' but no boot dev was defined
- if guest name is different from the username provided
for login
"""
# guest to ipl is different from username: cannot continue
if guest_name.upper() != self.user:
msg = ('On z/VM the guest name provided must be the same as the '
'username specified for login')
raise ValueError(msg)
boot_dev = None
if parameters['boot_method'] == 'disk':
try:
boot_dev = [vol for vol in parameters['storage_volumes']
if vol.get('boot_device')][0]
except IndexError:
raise ValueError("Boot method 'disk' requires a boot device")
elif parameters['boot_method'] == 'network':
if not 'netboot' in parameters:
raise ValueError(
"Boot method 'network' requires netboot parameters")
# put guest in a clean state
self._cms.stop()
self._cms.login()
if cpu != 0:
# clear possible attached cpus
reset_msg = r'(?i)storage cleared - system reset'
_, re_match = self._cms.run("detach cpu all",
wait_for=[reset_msg, ERROR_REGEX],
use_cp=True, timeout=10)
# command timed out waiting for a valid output: abort as we don't
# know the new guest state
if not re_match:
raise RuntimeError('Detach CPU(s) returned unexpected output')
# HCPCPU1456E is ok because base cpu cannot be detached,
# but with unknown error cannot continue
if (re_match.re.pattern != reset_msg and
not re_match.group().startswith('HCPCPU1456E')):
raise RuntimeError(
'Detach CPU(s) failed with: {}'.format(re_match.group()))
if memory != 0:
# attach defined memory
stor_msg = r'STORAGE = \d+'
_, re_match = self._cms.run("define storage {}M".format(memory),
wait_for=[stor_msg, ERROR_REGEX],
use_cp=True, timeout=10)
if not re_match:
raise RuntimeError(
'Define storage (memory) returned unexpected output')
if re_match.re.pattern != stor_msg:
raise RuntimeError('Define storage (memory) failed with: {}'
.format(re_match.group()))
# attach additional cpus and devices
self._cms.hotplug(
cpu=cpu-1,
vols=parameters['storage_volumes'],
extensions={'ifaces': parameters['ifaces']})
# boot method 'cms': enter ipl command
if parameters['boot_method'] == 'cms':
_, re_match = self._cms.run(
r'i cms\naccess (noprof', wait_for=['Ready;'])
if not re_match:
raise RuntimeError('Failed to IPL CMS')
# make sure terminal waits before clearing the screen to prevent
# missing content
self._cms.run('term more 50 10', use_cp=True)
return
# boot method 'network' - presence of netboot parameters was already
# checked
if parameters['boot_method'] == 'network':
self._netboot(parameters['netboot'])
# boot device defined: perform 'disk' based ipl
elif boot_dev:
if boot_dev['type'] != 'fcp':
devno = boot_dev['devno']
# fcp device: set | |
<gh_stars>0
#!/usr/bin/env python3
# coding: utf-8
"""
4oBe4e Console Client
Usage:
console_client.py <server_address> <player_name> [--logger=<level>]
console_client.py (-h | --help)
console_client.py --version
Options:
-h --help Show this screen
--version Show version
--logger=<level> Log level [default: warning]
"""
import logging
from time import sleep
from typing import Any, Dict, List, Set, Tuple
from docopt import docopt # type: ignore
from colorama import Back, Fore, Style # type: ignore
import requests
from const import HOME_ZONE, END_PROGRESS, LAST_ON_PATH, PLAYER_COLOURS
from util import progress_to_position
# Players' board attributes
players: List[Dict[str, Any]] = [
{
"colour": PLAYER_COLOURS[0],
"home": [[5, [2, 3]], [6, [2, 3]]],
"target": [[7, [6, 7]], [8, [6, 7]]],
"finish": [[9, [*range(3, 8)]], None],
},
{
"colour": PLAYER_COLOURS[1],
"home": [[2, [12, 13]], [3, [12, 13]]],
"target": [[6, [10, 11]], [7, [10, 11]]],
"finish": [[3, [9]], [4, [9]], [5, [9]], [6, [9]], [7, [9]]],
},
{
"colour": PLAYER_COLOURS[2],
"home": [[12, [15, 16]], [13, [15, 16]]],
"target": [[10, [11, 12]], [11, [11, 12]]],
"finish": [[9, [*range(11, 16)]], None],
},
{
"colour": PLAYER_COLOURS[3],
"home": [[15, [5, 6]], [16, [5, 6]]],
"target": [[11, [7, 8]], [12, [7, 8]]],
"finish": [[11, [9]], [12, [9]], [13, [9]], [14, [9]], [15, [9]]],
},
]
def _colour(name: str = "WHITE") -> str:
return eval(f"Fore.{name}")
def draw_board() -> List[List[Any]]:
"""Draw an ASCII board with the current pieces."""
ROWS = 19
COLS = 19
HOME_SHAPE = "[ ]"
TARGET_SHAPE = "{ }"
FOOTPATH_SHAPE = "( )"
FINISH_SHAPE = " + "
# Init board
board = [[Style.RESET_ALL + " "] * COLS for row in range(ROWS)]
# Fill board frame
for i in range(len(board)):
board[i][:: len(board[i]) - 1] = [Fore.MAGENTA + " . ", Fore.MAGENTA + " . "]
for i in 0, -1:
board[i][:] = (Fore.CYAN + " . ") * len(board[i])
# Fill player areas
for p in players:
for h in p["home"]:
for c in h[1]:
board[h[0]][c] = _colour(p["colour"]) + HOME_SHAPE
for t in p["target"]:
for c in t[1]:
board[t[0]][c] = _colour(p["colour"]) + TARGET_SHAPE
for f in p["finish"]:
if f:
for c in f[1]:
board[f[0]][c] = _colour(p["colour"]) + FINISH_SHAPE
# Fill footpath
footpath: List[List[List[int]]] = [
[[2, 16], [8, 9, 10]],
[[3, 4, 14, 15], [8, 10]],
[[5, 13], [5, 6, 7, 8, 10, 11, 12, 13]],
[[6, 7, 11, 12], [5, 13]],
[[8, 10], [2, 3, 4, 5, 13, 14, 15, 16]],
[[9], [2, 16]],
]
for fp in footpath:
for r in fp[0]:
for c in fp[1]:
board[r][c] = Fore.WHITE + FOOTPATH_SHAPE
# Fill Trophies
board[9][9] = ">|<"
board[-1][-1] = Style.RESET_ALL + "🏳️🌈"
return board
def redraw(pieces: List[Dict]) -> None:
"""The screen update function. Do not modify this for now."""
board = draw_board()
draw_pieces_on_board(board, pieces)
print()
for row in board:
print("".join(row))
def _cant_overlap(piece_number: int, player_number: int, piece_progress=0) -> bool:
"""Even though this is piece-related logic, it has to do only with visualisation.
Thus in view, rather than object logic"""
return not (HOME_ZONE < piece_progress < END_PROGRESS)
def draw_pieces_on_board(board: List[List[Any]], pieces: List[Dict]) -> List[List[Any]]:
"""It is not part of a job of this method to resolve game logic,
such as collision of pieces of different players on the path"""
for piece in pieces:
(x, y) = put_piece_on_board(piece["number"], piece["player"], piece["progress"])
player_progress = [
p["progress"] for p in pieces if p["player"] == piece["player"]
]
count = player_progress.count(piece["progress"])
val = (
str(piece["number"])
if _cant_overlap(piece["number"], piece["player"], piece["progress"])
or count == 1
else str(count)
)
board[x][y] = f"{_colour(players[piece['player']]['colour'])}.{val}."
return board
def put_piece_on_board(
piece_number: int, player_number: int, piece_progress=0
) -> Tuple[int, int]:
"""Currently player is in [1..4], piece is in [0..3]. Do we need to change this?
TODO: Refactor to implement startegy pattern
"""
coords = (0, 0)
progress = piece_progress
if progress == 0:
coords = __coord_in_home(piece_number, player_number, piece_progress)
elif 0 < progress <= LAST_ON_PATH:
coords = __coord_on_path(piece_number, player_number, piece_progress)
elif LAST_ON_PATH < progress < END_PROGRESS:
coords = __coord_on_finish(piece_number, player_number, piece_progress)
elif progress == END_PROGRESS:
coords = __coord_in_target(piece_number, player_number, piece_progress)
else:
raise NotImplementedError()
return coords
def get_state(session: requests.sessions.Session, server_address: str) -> Dict:
req = session.get(f"{server_address}/state")
return req.json()
def get_players(session: requests.sessions.Session, server_address: str) -> Dict:
req = session.get(f"{server_address}/players")
return req.json()
def join_player(
session: requests.sessions.Session, server_address: str, player_name: str
) -> Tuple:
req = session.get(f"{server_address}/join/{player_name}")
res = req.json()
return (res["player_num"], res["player_token"])
def roll_dice(session: requests.sessions.Session, server_address: str) -> Dict:
req = session.get(f"{server_address}/play/roll")
return req.json()
def move_piece(
session: requests.sessions.Session,
server_address: str,
piece_number: int,
dice: int,
) -> Dict:
req = session.get(f"{server_address}/play/move/{piece_number}/{dice}")
return req.json()
def put_piece(
session: requests.sessions.Session,
server_address: str,
piece_number: int,
dice: int,
) -> Dict:
req = session.get(f"{server_address}/play/out/{piece_number}/{dice}")
return req.json()
def __coord_in_home(
piece_number: int, player_number: int, piece_progress=0
) -> Tuple[int, int]:
"""Draw in home positions: each piece has its location. Progress is always same, thus irrelevant
>>> __coord_in_home(0, 0)
(5, 2)
>>> __coord_in_home(1, 1)
(2, 13)
>>> __coord_in_home(2, 2)
(13, 15)
>>> __coord_in_home(3, 3)
(16, 6)
"""
assert piece_progress == 0
zones = [(5, 2), (2, 12), (12, 15), (15, 5)]
shift = [(0, 0), (0, 1), (1, 0), (1, 1)]
return (
zones[player_number][0] + shift[piece_number][0],
zones[player_number][1] + shift[piece_number][1],
)
def __coord_on_path(
piece_number: int, player_number: int, piece_progress=0
) -> Tuple[int, int]:
"""Draws on path: if two or more pieces on same cell, instead of number,
draws a placeholder, which does not need to show piece number
Logic split this in 4 different cases, determined by player offset.
Parameter piece does't influence logic.
Player Progress to Position conversion:
P0 1..56: (pos)
P1 1..42: (p_num * shift + pos)
43..56: (p_num * shift + pos) % end_progress
P2 1..28: (p_num * shift + pos)
29..56: (p_num * shift + pos) % end_progress
P3 1..14: (p_num * shift + pos)
15..56: (p_num * shift + pos) % end_progress
Test player 1:
>>> __coord_on_path(player_number=0, piece_number=1, piece_progress=1)
(8, 2)
Test player 2:
>>> __coord_on_path(player_number=1, piece_number=1, piece_progress=1)
(2, 10)
Test player 3:
>>> __coord_on_path(player_number=2, piece_number=1, piece_progress=1)
(10, 16)
Test player 4:
>>> __coord_on_path(player_number=3, piece_number=1, piece_progress=1)
(16, 8)
Test path wrap:
>>> __coord_on_path(player_number=3, piece_number=1, piece_progress=56)
(16, 9)
Test overlap:
>>> __coord_on_path(player_number=1, piece_number=1, piece_progress=17)
(10, 14)
"""
assert 1 <= piece_progress <= LAST_ON_PATH and 0 <= player_number <= 3
POSITION_TO_ROWCOL: Tuple[Tuple[int, int], ...] = (
(0, 0),
(8, 2),
(8, 3),
(8, 4),
(8, 5),
(7, 5),
(6, 5),
(5, 5),
(5, 6),
(5, 7),
(5, 8),
(4, 8),
(3, 8),
(2, 8),
(2, 9),
(2, 10),
(3, 10),
(4, 10),
(5, 10),
(5, 11),
(5, 12),
(5, 13),
(6, 13),
(7, 13),
(8, 13),
(8, 14),
(8, 15),
(8, 16),
(9, 16),
(10, 16),
(10, 15),
(10, 14),
(10, 13),
(11, 13),
(12, 13),
(13, 13),
(13, 12),
(13, 11),
(13, 10),
(14, 10),
(15, 10),
(16, 10),
(16, 9),
(16, 8),
(15, 8),
(14, 8),
(13, 8),
(13, 7),
(13, 6),
(13, 5),
(12, 5),
(11, 5),
(10, 5),
(10, 4),
(10, 3),
(10, 2),
(9, 2),
)
return POSITION_TO_ROWCOL[progress_to_position(player_number, piece_progress)]
def __coord_on_finish(
piece_number: int, player_number: int, piece_progress=0
) -> Tuple[int, int]:
"""Piece number is irrelevant
>>> __coord_on_finish(1, 0, 57)
(9, 3)
>>> __coord_on_finish(1, 0, 61)
(9, 7)
>>> __coord_on_finish(1, 1, 57)
(3, 9)
>>> __coord_on_finish(1, 2, 58)
(9, 14)
>>> __coord_on_finish(1, 3, 59)
(13, 9)
>>> __coord_on_finish(1, 3, 61)
(11, 9)
"""
pos = piece_progress - LAST_ON_PATH
assert 0 < pos < 6
player = player_number
(x, y) = (0, 0)
if player in [0, 2]:
x = 9
y = pos + 2 if player == 0 else 15 - (pos - 1)
elif player in [1, 3]:
x = pos + 2 if player == 1 else 15 - (pos - 1)
y = 9
else:
raise NotImplementedError()
return (x, y)
def __coord_in_target(
piece_number: int, player_number: int, piece_progress=0
) -> Tuple[int, int]:
"""Draw in target positions: each piece has its location.
Progress is always same, thus irrelevant
>>> __coord_in_target(0, 0, 62)
(7, 6)
>>> __coord_in_target(1, 1, 62)
(6, 11)
>>> __coord_in_target(2, 2, 62)
(11, 11)
>>> __coord_in_target(3, 3, 62)
(12, 8)
"""
assert piece_progress == 62
zones = [(7, 6), (6, 10), (10, 11), (11, 7)]
shift = [(0, 0), (0, 1), (1, 0), (1, 1)]
return (
zones[player_number][0] + shift[piece_number][0],
zones[player_number][1] + shift[piece_number][1],
)
def main():
"""Main loop."""
# Parse args
args = | |
values into sets in case these are already templates.
values1 = set(lel1.attrib[key].split(cls.VALUES_SEPARATOR)) if key in lel1.attrib else set()
values2 = set(lel2.attrib[key].split(cls.VALUES_SEPARATOR)) if key in lel2.attrib else set()
if values1 != values2:
if not overwrite or key in unstable_attributes_in_lel1 or key in unstable_attributes_in_lel2:
# If we're not overwriting, or we are overwriting but this attribute is already unstable,
# we should combine the values and mark it unstable.
el_result.attrib[key] = cls.VALUES_SEPARATOR.join(sorted(values1 | values2))
unstable_attributes.add(key)
else:
# We are overwriting and this is not an unstable attribute in lel2, so just overwrite from lel2.
el_result.attrib[key] = cls.VALUES_SEPARATOR.join(values2)
else:
# The values are the same, just copy from one or the other.
el_result.attrib[key] = lel2.attrib[key]
# Now put the special attributes back.
cls._set_unstable_attributes_for_element(el_result, unstable_attributes)
if "unstable_element" in lel1.attrib or "unstable_element" in lel2.attrib:
el_result.attrib["unstable_element"] = "true"
if "unstable_text" in lel1.attrib or "unstable_text" in lel2.attrib:
el_result.attrib["unstable_text"] = "true"
@classmethod
def _helper_combine_text(cls, lel1, lel2, el_result, overwrite=False):
"""Combines text from lel1 and lel2.
Args:
lel1, lel2: elements from two different lxml trees / templates
el_result: the element that is serving as the combination result of lel1 and lel2
overwrite: If true, any incompatibilities will be resolved by taking from lel2. If false,
incompatibilities will be resolved by marking the text as unstable.
"""
unstable_text_in_lel1 = "unstable_text" in lel1.attrib
unstable_text_in_lel2 = "unstable_text" in lel2.attrib
values1 = set(lel1.text.split(cls.VALUES_SEPARATOR)) \
if lel1.text is not None and lel1.text.strip() != '' else set()
values2 = set(lel2.text.split(cls.VALUES_SEPARATOR)) \
if lel2.text is not None and lel2.text.strip() != '' else set()
if values1 != values2:
if not overwrite or unstable_text_in_lel1 or unstable_text_in_lel2:
# If we're not overwriting, or we are overwriting but the text is already unstable in either element,
# we should combine the values and mark it unstable.
el_result.text = cls.VALUES_SEPARATOR.join(sorted(values1 | values2))
el_result.attrib["unstable_text"] = "true"
else:
# We are overwriting and this is not unstable, so just overwrite from lel2.
el_result.text = lel2.text
else:
# The values are the same, just copy from one or the other.
el_result.text = lel2.text
@classmethod
def _helper_combine_children(cls, lel1, lel2, el_result, overwrite=False):
"""Combines children from lel1 and lel2.
Args:
lel1, lel2: elements from two different lxml trees / templates
el_result: the element that is serving as the combination result of lel1 and lel2
overwrite: If true, any incompatibilities will be resolved by taking from lel2. If false,
incompatibilities will be resolved by marking the text as unstable.
Returns:
Nothing
"""
# Ideally there should be a one-to-one correspondence between children. We step one by one through each
# child list recursively trying to match the children.
# Watch out!: cnn.com orders some children randomly! For instance, batBeacon and kxhead will appear in both
# versions of the page but in different positions. These will be marked "unstable_element" in the template.
# When we fail to match two children at the same index and one of them is unstable, we can advance one
# anyway, adding it to the result and to a "unmatched children" list.
# If we have unmatched children, we try to "catch up" by matching to them first before going on with the
# other children.
# TODO: Sometimes a child in one tree matches multiple children in the other tree and it's hard to know
# which ones actually correspond. We can improve the child matching if our match functions return a score.
def match_el_to_list_and_remove(el, els_list):
# If el matches an item in els_list, removes that item from the list and returns the
# matching element and the result of running the match function.
if len(els_list) > 0:
lel1_unstable = "unstable_element" in el.attrib \
or "unstable_text" in el.attrib \
or "unstable_attributes" in el.attrib
child_result = None
# Go backwards so we'll match the most recently added child first.
subindex = len(els_list)-1
while subindex >= 0:
cur_el = els_list[subindex]
# One of the elements must be marked unstable.
lel2_unstable = "unstable_element" in cur_el.attrib \
or "unstable_text" in cur_el.attrib \
or "unstable_attributes" in cur_el.attrib
if lel1_unstable or lel2_unstable:
child_result = cls._get_merged_tree(cur_el, el, overwrite)
if child_result is not None:
break
subindex -= 1
if child_result is not None:
# The element matched an item from the list. Remove that item from the list.
match = els_list[subindex]
del els_list[subindex]
return match, child_result
return None, None
# Go through the children one by one trying to match them to one another.
index1 = index2 = prev_index1 = prev_index2 = 0
unmatched_children1 = list()
unmatched_children2 = list()
while index1 < len(lel1) and index2 < len(lel2):
# First try to match the child in lel1 to the child in the corresponding position in lel2.
child_result = cls._get_merged_tree(lel1[index1], lel2[index2], overwrite)
if child_result is not None:
# This element in lel2 matches the element in lel1. Definitely add it.
el_result.append(child_result)
if "unstable_element" in lel1[index1].attrib or "unstable_element" in lel2[index2].attrib:
child_result.attrib["unstable_element"] = "true"
prev_index1 = index1
prev_index2 = index2
index1 += 1
index2 += 1
continue
# That didn't work, so let's try matching the elements to any unmatched children.
# If one of the children finds a match, advance that child index
# and restart the loop with the new children.
# Check against prev_index to make sure this index has advanced. Otherwise no need
# to do this again.
if index2 > prev_index2:
skipped_match, child_result = match_el_to_list_and_remove(lel2[index2], unmatched_children1)
if child_result is not None:
# Replace the child with the new result.
el_result.insert(el_result.index(skipped_match), child_result)
el_result.remove(skipped_match)
prev_index1 = index1
prev_index2 = index2
index2 += 1
continue
if index1 > prev_index1:
# If we've advanced within lel1, check the new child against all skipped children from lel2.
skipped_match, child_result = match_el_to_list_and_remove(lel1[index1], unmatched_children2)
if child_result is not None:
# Replace the child with the new result.
el_result.insert(el_result.index(skipped_match), child_result)
el_result.remove(skipped_match)
prev_index1 = index1
prev_index2 = index2
index1 += 1
continue
# The children didn't match each other or any as-of-yet unmatched elements.
prev_index1 = index1
prev_index2 = index2
# Let's add the child to the result and also to a "unmatched_children" list.
# - If we are NOT overwriting, mark it unstable and add it to the result.
# - If we are overwriting, do not mark it unstable unless it was already marked unstable.
# An unmatched child may end up matching a child from the other element down the line, in which case
# it will be combined with that child in the final result.
# If we are overwriting, when we're all done, any remaining unmatched children from lel1 that are
# not marked unstable will be removed.
# If one index is lagging behind, skip that one to catch up.
if index1 < index2:
cchild = deepcopy(lel1[index1])
if not overwrite:
cchild.attrib["unstable_element"] = "true"
unmatched_children1.append(cchild)
el_result.append(cchild)
index1 += 1
elif index1 > index2:
cchild = deepcopy(lel2[index2])
if not overwrite:
cchild.attrib["unstable_element"] = "true"
unmatched_children2.append(cchild)
el_result.append(cchild)
index2 += 1
# If there are more children in one list than the other, skip the child in the bigger list.
elif len(lel1) < len(lel2):
cchild = deepcopy(lel2[index2])
if not overwrite:
cchild.attrib["unstable_element"] = "true"
unmatched_children2.append(cchild)
el_result.append(cchild)
index2 += 1
else:
cchild = deepcopy(lel1[index1])
if not overwrite:
cchild.attrib["unstable_element"] = "true"
unmatched_children1.append(cchild)
el_result.append(cchild)
index1 += 1
# We've exhausted one or the other of the element lists.
# Check the remaining children against unmatched children from the other tree.
while index1 < len(lel1):
# Does the lel1 child correspond with an unmatched child from lel2?
skipped_match, child_result = match_el_to_list_and_remove(lel1[index1], unmatched_children2)
if child_result is not None:
# Replace the child with the new result.
el_result.insert(el_result.index(skipped_match), child_result)
el_result.remove(skipped_match)
elif not overwrite or "unstable_element" in lel1[index1].attrib:
# As long as we're not overwriting we can add it and mark it unstable.
cchild = deepcopy(lel1[index1])
cchild.attrib["unstable_element"] = "true"
el_result.append(cchild)
else:
# The child from lel1 couldn't be added. Keep checking the other children.
pass
index1 += 1
while index2 < len(lel2):
# Does the lel2 | |
<filename>routeTracker/UI.py
import tkinter as tk
import ctypes
import time
import math
import pickle
import winsound
from tkinter.filedialog import askopenfilename, askdirectory
from tkinter import messagebox
import os
import pyperclip
import webbrowser
import traceback
import datetime
import sys
if getattr(sys, 'frozen', False): # Running as compiled
running_dir = sys._MEIPASS + "/files/" # Same path name than pyinstaller option
else:
running_dir = "./" # Path name when run with Python interpreter
ICON = running_dir + "carrier.ico"
class POINT(ctypes.Structure):
_fields_ = [("x", ctypes.c_ulong), ("y", ctypes.c_ulong)]
def mousePosition():
pt = POINT()
ctypes.windll.user32.GetCursorPos(ctypes.byref(pt))
return int(pt.x), int(pt.y)
class UserInterface():
def __init__(self, reader, debug=False):
user32 = ctypes.windll.user32
width, height = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1)
dataTemplate = {'window position': [width / 2 - 250, height / 4],
'route positions': {},
'showType': 'show',
'topmost': 1,
'alarm': True,
'logLocation': '',
'shipCargo': 0,
'carrierCargo': 0,
'more': False,
'jumpStart': '00:00',
'jumpEnd': '23:59'
}
self.exiting = False
self.debug = debug
# self.logReader=reader
self.maxCountdown = 60 * 21
self.logCheck = 5
self.logReader = reader
self.scroll = 0
self.dragOffset = [0, 0]
self.scrolling = False
self.stopLocations = []
self.pristineRings = []
self.countdown = self.maxCountdown
self.countdownStart = time.time()
self.logStart = 0
self.currentFileDataKeys = {}
self.currentFileData = [['unknown']]
self.system = None
self.nextSystem = 'unknown'
self.currentFile = None
self.position = 0
self.dragging = False
self.draggingPos = [width / 2 - 250, height / 4]
self.hovering = False
self.scrollTop = [0, 0]
self.scrollBottom = [0, 0]
try:
with open("trackerData.txt", "rb") as f:
self.data = pickle.load(f)
except FileNotFoundError:
self.data = dataTemplate
with open("trackerData.txt", "wb") as f:
pickle.dump(self.data, f)
added = False
dataKeys = list(self.data.keys())
for i in list(dataTemplate.keys()):
if i not in dataKeys:
self.data[i] = dataTemplate[i]
added = True
if added:
with open("trackerData.txt", "wb") as f:
pickle.dump(self.data, f)
if "current file" in list(self.data.keys()):
self.currentFile = self.data["current file"]
self.openFile(dialogue=False)
if self.data['logLocation'] != '':
self.logReader.folderLocation = self.data['logLocation']
self.createWindow()
def mainLoop(self):
timeLoop = time.time()
while True:
time.sleep(0.01)
try:
pyperclip.paste()
if self.exiting:
self.saveData()
self.window.destroy()
self.root.destroy()
try:
self.settingsWindow.destroy()
except AttributeError:
pass
except tk._tkinter.TclError:
pass
break
# self.menu.update()
currentTime = time.time()
if currentTime - self.logStart > self.logCheck and self.currentFileData != None:
self.logStart = currentTime
self.logReader.updateLog()
# print(self.logReader.oldSystem,self.logReader.currentSystem)
if self.logReader.oldSystem != self.logReader.currentSystem:
# print("Jumped to "+self.logReader.currentSystem)
self.nextSystem = 'unknown'
for i in range(self.position, len(self.currentFileData) - 1):
##print(i)
##print(ui.currentFileData[i])
if self.currentFileData[i][self.currentFileDataKeys['System Name']] == self.logReader.currentSystem:
# print('copied ' + self.nextSystem + ' to clipboard')
if self.currentFileData[i + 1][self.currentFileDataKeys['System Name']] == \
self.currentFileData[i][self.currentFileDataKeys['System Name']]:
self.position = i + 1
# print('double')
else:
self.position = i
self.nextSystem = self.currentFileData[self.position + 1][
self.currentFileDataKeys['System Name']]
pyperclip.copy(self.nextSystem)
self.data['route positions'][self.currentFile] = self.position
self.saveData()
# try:
self.clear()
"""
except Exception as e:
#print(e)"""
break
# try:
self.root.update()
x, y = mousePosition()
if self.hovering:
self.clear()
self.hovering = False
if self.dragging:
self.data['window position'] = [x - self.dragOffset[0], y - self.dragOffset[1]]
self.clear()
elif self.scrolling and self.scrollLength < len(self.currentFileData):
proportion = (y - self.barCentre - self.scrollTop[1]) / self.scrollHeight
self.scroll = round(proportion * len(self.currentFileData) - self.position)
self.limitScroll()
self.clear()
elif currentTime - timeLoop > 1:
self.clear()
timeLoop = currentTime
"""
if self.data['topmost'] == 0:
if not self.window.focus_displayof():
if topSet != 0:
self.window.attributes('-topmost', 0)
topSet=0
elif topSet != 1:
self.window.attributes('-topmost', 1)
topSet=1
##print(topSet)
"""
"""
except Exception as e:
if e == SystemExit:
break
else:
self.exiting=True
#print(e)"""
try:
self.settingsWindow.update()
except AttributeError:
pass
except tk._tkinter.TclError:
pass
except pyperclip.PyperclipWindowsException:
time.sleep(2)
def openFile(self, dialogue=True):
self.scroll = 0
if dialogue:
self.currentFile = askopenfilename()
self.data["current file"] = self.currentFile
if self.currentFile != '':
# print(self.currentFile)
# print(self.data)
if self.currentFile in list(self.data['route positions'].keys()):
self.position = self.data['route positions'][self.currentFile]
else:
self.position = 0
self.data['route positions'][self.currentFile] = self.position
self.saveData()
try:
with open(self.currentFile, 'r') as f:
self.currentFileData = f.read()
self.currentFileData = "".join(self.currentFileData.split("\""))
self.currentFileData = self.currentFileData.split("\n")
self.currentFileData = [i.split(",") for i in self.currentFileData]
##print(currentFileData)
self.currentFileDataKeys = {}
for i in range(len(self.currentFileData[0])):
self.currentFileDataKeys[self.currentFileData[0][i]] = i
del self.currentFileData[0]
if [''] in self.currentFileData:
self.currentFileData.remove([''])
self.stopLocations = []
self.pristineRings=[]
for i in range(len(self.currentFileData) - 1):
if self.currentFileData[i][self.currentFileDataKeys['System Name']] == self.currentFileData[i + 1][
self.currentFileDataKeys['System Name']]:
self.stopLocations.append(i)
if self.currentFileData[i][self.currentFileDataKeys['Pristine']] == 'Yes':
self.pristineRings.append(i)
##print(self.currentFileData[i])
##print(self.stopLocations)
except FileNotFoundError as e:
messagebox.showerror("Import Error", e)
if self.data['showType'] == 'show':
self.logReader.resetValues()
self.logStart = 0
self.createWindow()
def saveData(self, values=None):
with open("trackerData.txt", "wb") as f:
pickle.dump(self.data, f)
# overlay functions
def clear(self):
# all to change with new UI
try:
self.canvas.destroy()
except:
pass
clip = pyperclip.paste()
x, y = self.data['window position'][0], self.data['window position'][1]
self.canvas = tk.Canvas(self.window, bg="pink", bd=0, highlightthickness=0, relief='ridge')
self.canvas.pack(fill="both", expand=True)
self.canvas.create_rectangle(x, y, x + 520, y + 30, fill='black')
if self.logReader.currentSystem == clip:
self.canvas.create_text(x + 5, y + 5, text=self.logReader.currentSystem, font="Ebrima 13 bold",
fill='green', anchor='nw')
else:
self.canvas.create_text(x + 5, y + 5, text=self.logReader.currentSystem, font="Ebrima 13 bold",
fill='orange', anchor='nw')
self.canvas.create_rectangle(x + 150, y, x + 500, y + 30, fill='black')
self.canvas.create_text(x + 158, y + 5, text='>> ', font="Ebrima 13 bold", fill='orange', anchor='nw')
if self.nextSystem == clip:
self.canvas.create_text(x + 190, y + 5, text=self.nextSystem, font="Ebrima 13 bold", fill='green',
anchor='nw')
else:
self.canvas.create_text(x + 190, y + 5, text=self.nextSystem, font="Ebrima 13 bold", fill='orange',
anchor='nw')
self.canvas.create_rectangle(x + 340, y, x + 500, y + 30, fill='black')
timeSince = time.time() - self.logReader.lastJumpRequest
timeSince = self.maxCountdown - timeSince
if timeSince > 0:
if timeSince < 10 and self.data['alarm']:
winsound.Beep(3000, 100)
mins = str(round(timeSince // 60))
seconds = str(math.floor(timeSince % 60))
if len(mins) == 1:
mins = '0' + mins
if len(seconds) == 1:
seconds = '0' + seconds
text = mins + ':' + seconds
else:
text = 'Ready'
text = '| ' + text + ' |'
self.canvas.create_text(x + 350, y + 5, text=text, font="Ebrima 13 bold", fill='orange', anchor='nw')
self.canvas.create_text(x + 420, y + 5, text='☰', font="Ebrima 13 bold", fill='orange', anchor='nw')
self.canvas.create_text(x + 440, y + 5, text='📁', font="Ebrima 13 bold", fill='orange', anchor='nw')
self.canvas.create_text(x + 463, y + 5, text='⚙', font="Ebrima 13 bold", fill='orange', anchor='nw')
if self.data['topmost'] == 1:
self.canvas.create_text(x + 485, y + 5, text='⮝', font="Ebrima 13 bold", fill='orange', anchor='nw')
else:
self.canvas.create_text(x + 485, y + 5, text='⮟', font="Ebrima 13 bold", fill='orange', anchor='nw')
self.canvas.create_text(x + 500, y + 5, text='✘', font="Ebrima 13 bold", fill='orange', anchor='nw')
self.canvas.create_line(x, y, x + 520, y, fill='orange')
self.canvas.create_line(x, y + 30, x + 520, y + 30, fill='orange')
if self.data['more']:
self.createDashboard()
def createDashboard(self):
mouseX, mouseY = mousePosition()
x, y = self.data['window position'][0], self.data['window position'][1]
try:
self.canvas.create_rectangle(x, y + 35, x + 520, y + 600, fill='black', outline='orange')
# pannel backgrounds
self.canvas.create_rectangle(x + 10, y + 40, x + 510, y + 150, fill='#111111', outline='#333333')
self.canvas.create_rectangle(x + 10, y + 160, x + 510, y + 270, fill='#111111', outline='#333333')
self.canvas.create_rectangle(x + 10, y + 280, x + 510, y + 540, fill='#111111', outline='#333333')
horPos = self.position / len(self.currentFileData) * 480 + 20
self.canvas.create_line(x + 20, y + 80, x + horPos, y + 80, fill='orange', width=2, dash=10)
self.canvas.create_line(x + horPos, y + 80, x + 500, y + 80, fill='orange', width=2)
above = False
for i in [0] + self.stopLocations:
horPos = i / len(self.currentFileData) * 480 + 20
if i in self.pristineRings:
colour = '#a1c5ff'
else:
colour = 'orange'
if i in self.stopLocations:
size=3
else:
size=1
if above and (mouseX - (x + horPos)) ** 2 + (mouseY - (y + 80)) ** 2 < size ** 2:
if horPos < 250:
anchor = 'w'
else:
anchor = 'e'
self.canvas.create_line(x + horPos, y + 70, x + horPos, y + 80, fill=colour)
jumps=i - self.position
if jumps > 0:
eta = ' | ' + self.getETA(jumps=jumps)
else:
eta=''
self.canvas.create_text(x + horPos, y + 60,
text=self.currentFileData[i][self.currentFileDataKeys['System Name']] + eta,
font="Ebrima 10 bold", fill=colour, anchor=anchor)
self.canvas.create_oval(x + horPos - size*1.5, y + 80 - size*1.5, x + horPos + size*1.5, y + 80 + size*1.5, fill=colour,
outline=colour)
elif not above:
self.canvas.create_rectangle(x + horPos - 8, y + 80, x + 500, y + 120, fill='#111111',
outline='#111111')
self.canvas.create_line(x + horPos, y + 80, x + horPos, y + 90, fill='orange')
self.canvas.create_text(x + horPos, y + 95,
text=self.currentFileData[i][self.currentFileDataKeys['System Name']],
font="Ebrima 10 bold", fill='orange', anchor='w')
self.canvas.create_oval(x + horPos - size, y + 80 - size, x + horPos + 5, y + 80 + size, fill=colour, outline=colour)
above = True
horPos = 500
jumps = len(self.currentFileData) - 1 - self.position
if jumps > | |
<filename>cf_xarray/accessor.py
import functools
import inspect
import itertools
import warnings
from collections import ChainMap
from typing import (
Any,
Callable,
Dict,
Hashable,
Iterable,
List,
Mapping,
MutableMapping,
Set,
Tuple,
Union,
)
import xarray as xr
from xarray import DataArray, Dataset
from .helpers import bounds_to_vertices
from .utils import parse_cell_methods_attr
#: Classes wrapped by cf_xarray.
_WRAPPED_CLASSES = (
xr.core.resample.Resample,
xr.core.groupby.GroupBy,
xr.core.rolling.Rolling,
xr.core.rolling.Coarsen,
xr.core.weighted.Weighted,
)
#: `axis` names understood by cf_xarray
_AXIS_NAMES = ("X", "Y", "Z", "T")
#: `coordinate` types understood by cf_xarray.
_COORD_NAMES = ("longitude", "latitude", "vertical", "time")
#: Cell measures understood by cf_xarray.
_CELL_MEASURES = ("area", "volume")
# Define the criteria for coordinate matches
# Copied from metpy
# Internally we only use X, Y, Z, T
coordinate_criteria: MutableMapping[str, MutableMapping[str, Tuple]] = {
"standard_name": {
"X": ("projection_x_coordinate",),
"Y": ("projection_y_coordinate",),
"T": ("time",),
"time": ("time",),
"vertical": (
"air_pressure",
"height",
"depth",
"geopotential_height",
# computed dimensional coordinate name
"altitude",
"height_above_geopotential_datum",
"height_above_reference_ellipsoid",
"height_above_mean_sea_level",
),
"Z": (
"model_level_number",
"atmosphere_ln_pressure_coordinate",
"atmosphere_sigma_coordinate",
"atmosphere_hybrid_sigma_pressure_coordinate",
"atmosphere_hybrid_height_coordinate",
"atmosphere_sleve_coordinate",
"ocean_sigma_coordinate",
"ocean_s_coordinate",
"ocean_s_coordinate_g1",
"ocean_s_coordinate_g2",
"ocean_sigma_z_coordinate",
"ocean_double_sigma_coordinate",
),
"latitude": ("latitude",),
"longitude": ("longitude",),
},
"_CoordinateAxisType": {
"T": ("Time",),
"Z": ("GeoZ", "Height", "Pressure"),
"Y": ("GeoY",),
"latitude": ("Lat",),
"X": ("GeoX",),
"longitude": ("Lon",),
},
"axis": {"T": ("T",), "Z": ("Z",), "Y": ("Y",), "X": ("X",)},
"cartesian_axis": {"T": ("T",), "Z": ("Z",), "Y": ("Y",), "X": ("X",)},
"positive": {"vertical": ("up", "down")},
"units": {
"latitude": (
"degree_north",
"degree_N",
"degreeN",
"degrees_north",
"degrees_N",
"degreesN",
),
"longitude": (
"degree_east",
"degree_E",
"degreeE",
"degrees_east",
"degrees_E",
"degreesE",
),
},
}
# "long_name" and "standard_name" criteria are the same. For convenience.
coordinate_criteria["long_name"] = coordinate_criteria["standard_name"]
#: regular expressions for guess_coord_axis
regex = {
"time": "time[0-9]*|min|hour|day|week|month|year",
"vertical": (
"(lv_|bottom_top|sigma|h(ei)?ght|altitude|depth|isobaric|pres|"
"isotherm)[a-z_]*[0-9]*"
),
"Y": "y",
"latitude": "y?lat[a-z0-9]*",
"X": "x",
"longitude": "x?lon[a-z0-9]*",
}
regex["Z"] = regex["vertical"]
regex["T"] = regex["time"]
attrs = {
"X": {"axis": "X"},
"T": {"axis": "T", "standard_name": "time"},
"Y": {"axis": "Y"},
"Z": {"axis": "Z"},
"latitude": {"units": "degrees_north", "standard_name": "latitude"},
"longitude": {"units": "degrees_east", "standard_name": "longitude"},
}
attrs["time"] = attrs["T"]
attrs["vertical"] = attrs["Z"]
def _is_datetime_like(da: DataArray) -> bool:
import numpy as np
if np.issubdtype(da.dtype, np.datetime64) or np.issubdtype(
da.dtype, np.timedelta64
):
return True
try:
import cftime
if isinstance(da.data[0], cftime.datetime):
return True
except ImportError:
pass
return False
# Type for Mapper functions
Mapper = Callable[[Union[DataArray, Dataset], str], List[str]]
def apply_mapper(
mappers: Union[Mapper, Tuple[Mapper, ...]],
obj: Union[DataArray, Dataset],
key: str,
error: bool = True,
default: Any = None,
) -> List[Any]:
"""
Applies a mapping function; does error handling / returning defaults.
Expects the mapper function to raise an error if passed a bad key.
It should return a list in all other cases including when there are no
results for a good key.
"""
if default is None:
default = []
def _apply_single_mapper(mapper):
try:
results = mapper(obj, key)
except Exception as e:
if error:
raise e
else:
results = []
return results
if not isinstance(mappers, Iterable):
mappers = (mappers,)
# apply a sequence of mappers
# if the mapper fails, it *should* return an empty list
# if the mapper raises an error, that is processed based on `error`
results = []
for mapper in mappers:
results.append(_apply_single_mapper(mapper))
nresults = sum([bool(v) for v in results])
if nresults > 1:
raise KeyError(
f"Multiple mappers succeeded with key {key!r}.\nI was using mappers: {mappers!r}."
f"I received results: {results!r}.\nPlease open an issue."
)
if nresults == 0:
if error:
raise KeyError(
f"cf-xarray cannot interpret key {key!r}. Perhaps some needed attributes are missing."
)
else:
# none of the mappers worked. Return the default
return default
return list(itertools.chain(*results))
def _get_axis_coord_single(var: Union[DataArray, Dataset], key: str) -> List[str]:
""" Helper method for when we really want only one result per key. """
results = _get_axis_coord(var, key)
if len(results) > 1:
raise KeyError(
f"Multiple results for {key!r} found: {results!r}. I expected only one."
)
elif len(results) == 0:
raise KeyError(f"No results found for {key!r}.")
return results
def _get_axis_coord_time_accessor(
var: Union[DataArray, Dataset], key: str
) -> List[str]:
"""
Helper method for when our key name is of the nature "T.month" and we want to
isolate the "T" for coordinate mapping
Parameters
----------
var: DataArray, Dataset
DataArray belonging to the coordinate to be checked
key: str, [e.g. "T.month"]
key to check for.
Returns
-------
List[str], Variable name(s) in parent xarray object that matches axis or coordinate `key` appended by the frequency extension (e.g. ".month")
Notes
-----
Returns an empty list if there is no frequency extension specified.
"""
if "." in key:
key, ext = key.split(".", 1)
results = _get_axis_coord_single(var, key)
return [v + "." + ext for v in results]
else:
return []
def _get_axis_coord(var: Union[DataArray, Dataset], key: str) -> List[str]:
"""
Translate from axis or coord name to variable name
Parameters
----------
var: DataArray, Dataset
DataArray belonging to the coordinate to be checked
key: str, ["X", "Y", "Z", "T", "longitude", "latitude", "vertical", "time"]
key to check for.
error: bool
raise errors when key is not found or interpretable. Use False and provide default
to replicate dict.get(k, None).
default: Any
default value to return when error is False.
Returns
-------
List[str], Variable name(s) in parent xarray object that matches axis or coordinate `key`
Notes
-----
This functions checks for the following attributes in order
- `standard_name` (CF option)
- `_CoordinateAxisType` (from THREDDS)
- `axis` (CF option)
- `positive` (CF standard for non-pressure vertical coordinate)
References
----------
MetPy's parse_cf
"""
valid_keys = _COORD_NAMES + _AXIS_NAMES
if key not in valid_keys:
raise KeyError(
f"cf_xarray did not understand key {key!r}. Expected one of {valid_keys!r}"
)
search_in = set()
if "coordinates" in var.encoding:
search_in.update(var.encoding["coordinates"].split(" "))
if "coordinates" in var.attrs:
search_in.update(var.attrs["coordinates"].split(" "))
if not search_in:
search_in = set(var.coords)
# maybe only do this for key in _AXIS_NAMES?
search_in.update(var.indexes)
results: Set = set()
for coord in search_in:
for criterion, valid_values in coordinate_criteria.items():
if key in valid_values:
expected = valid_values[key]
if (
coord in var.coords
and var.coords[coord].attrs.get(criterion, None) in expected
):
results.update((coord,))
return list(results)
def _get_measure_variable(
da: DataArray, key: str, error: bool = True, default: str = None
) -> List[DataArray]:
""" tiny wrapper since xarray does not support providing str for weights."""
varnames = apply_mapper(_get_measure, da, key, error, default)
if len(varnames) > 1:
raise ValueError(f"Multiple measures found for key {key!r}: {varnames!r}.")
return [da[varnames[0]]]
def _get_measure(obj: Union[DataArray, Dataset], key: str) -> List[str]:
"""
Translate from cell measures to appropriate variable name.
This function interprets the ``cell_measures`` attribute on DataArrays.
Parameters
----------
obj: DataArray, Dataset
DataArray belonging to the coordinate to be checked
key: str
key to check for.
Returns
-------
List[str], Variable name(s) in parent xarray object that matches axis or coordinate `key`
"""
if isinstance(obj, DataArray):
obj = obj._to_temp_dataset()
results = set()
for var in obj.variables:
da = obj[var]
if "cell_measures" in da.attrs:
attr = da.attrs["cell_measures"]
measures = parse_cell_methods_attr(attr)
if key in measures:
results.update([measures[key]])
if isinstance(results, str):
return [results]
return list(results)
#: Default mappers for common keys.
_DEFAULT_KEY_MAPPERS: Mapping[str, Tuple[Mapper, ...]] = {
"dim": (_get_axis_coord,),
"dims": (_get_axis_coord,), # transpose
"dimensions": (_get_axis_coord,), # stack
"dims_dict": (_get_axis_coord,), # swap_dims, rename_dims
"shifts": (_get_axis_coord,), # shift, roll
"pad_width": (_get_axis_coord,), # shift, roll
# "names": something_with_all_valid_keys? # set_coords, reset_coords
"coords": (_get_axis_coord,), # interp
"indexers": (_get_axis_coord,), # sel, isel, reindex
# "indexes": (_get_axis_coord,), # set_index
"dims_or_levels": (_get_axis_coord,), # reset_index
"window": (_get_axis_coord,), # rolling_exp
"coord": (_get_axis_coord_single,), # differentiate, integrate
"group": (_get_axis_coord_single, _get_axis_coord_time_accessor),
"indexer": (_get_axis_coord_single,), # resample
"variables": (_get_axis_coord,), # sortby
"weights": (_get_measure_variable,), # type: ignore
}
def _get_with_standard_name(ds: Dataset, name: Union[str, List[str]]) -> List[str]:
""" returns a list of variable names with standard name == name. """
varnames = []
for vname, var in ds.variables.items():
stdname = var.attrs.get("standard_name", None)
if stdname == name:
varnames.append(str(vname))
return varnames
def _guess_bounds_dim(da):
"""
Guess bounds values given a 1D coordinate variable.
Assumes equal spacing on either side of the coordinate label.
"""
assert da.ndim == 1
dim = da.dims[0]
diff = da.diff(dim)
lower = da - diff / 2
upper = da + diff / 2
bounds = xr.concat([lower, upper], dim="bounds")
first = (bounds.isel({dim: 0}) - diff[0]).assign_coords({dim: da[dim][0]})
result = xr.concat([first, bounds], dim=dim)
return result
def _build_docstring(func):
"""
Builds a nice docstring for wrapped functions, stating what key words
can be used for arguments.
"""
# this list will need to be updated any time a new mapper is added
mapper_docstrings = {
_get_axis_coord: f"One or more of {(_AXIS_NAMES + _COORD_NAMES)!r}",
_get_axis_coord_single: f"One of {(_AXIS_NAMES + _COORD_NAMES)!r}",
# _get_measure_variable: f"One of {_CELL_MEASURES!r}",
| |
<filename>tempest/scenario/manager.py<gh_stars>0
# Copyright 2012 OpenStack Foundation
# Copyright 2013 IBM Corp.
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import logging
import os
import six
import subprocess
from ironicclient import exc as ironic_exceptions
import netaddr
from neutronclient.common import exceptions as exc
from novaclient import exceptions as nova_exceptions
from tempest.api.network import common as net_common
from tempest import clients
from tempest.common import isolated_creds
from tempest.common.utils import data_utils
from tempest.common.utils.linux import remote_client
from tempest import config
from tempest import exceptions
from tempest.openstack.common import log
import tempest.test
CONF = config.CONF
LOG = log.getLogger(__name__)
# NOTE(afazekas): Workaround for the stdout logging
LOG_nova_client = logging.getLogger('novaclient.client')
LOG_nova_client.addHandler(log.NullHandler())
LOG_cinder_client = logging.getLogger('cinderclient.client')
LOG_cinder_client.addHandler(log.NullHandler())
class OfficialClientTest(tempest.test.BaseTestCase):
"""
Official Client test base class for scenario testing.
Official Client tests are tests that have the following characteristics:
* Test basic operations of an API, typically in an order that
a regular user would perform those operations
* Test only the correct inputs and action paths -- no fuzz or
random input data is sent, only valid inputs.
* Use only the default client tool for calling an API
"""
@classmethod
def setUpClass(cls):
super(OfficialClientTest, cls).setUpClass()
cls.isolated_creds = isolated_creds.IsolatedCreds(
cls.__name__, tempest_client=False,
network_resources=cls.network_resources)
username, password, tenant_name = cls.credentials()
cls.manager = clients.OfficialClientManager(
username, password, tenant_name)
cls.compute_client = cls.manager.compute_client
cls.image_client = cls.manager.image_client
cls.baremetal_client = cls.manager.baremetal_client
cls.identity_client = cls.manager.identity_client
cls.network_client = cls.manager.network_client
cls.volume_client = cls.manager.volume_client
cls.object_storage_client = cls.manager.object_storage_client
cls.orchestration_client = cls.manager.orchestration_client
cls.data_processing_client = cls.manager.data_processing_client
cls.resource_keys = {}
cls.os_resources = []
@classmethod
def _get_credentials(cls, get_creds, prefix):
if CONF.compute.allow_tenant_isolation:
username, tenant_name, password = get_creds()
else:
username = getattr(CONF.identity, prefix + 'username')
password = getattr(CONF.identity, prefix + 'password')
tenant_name = getattr(CONF.identity, prefix + 'tenant_name')
return username, password, tenant_name
@classmethod
def credentials(cls):
return cls._get_credentials(cls.isolated_creds.get_primary_creds, '')
@classmethod
def alt_credentials(cls):
return cls._get_credentials(cls.isolated_creds.get_alt_creds, 'alt_')
@classmethod
def admin_credentials(cls):
return cls._get_credentials(cls.isolated_creds.get_admin_creds,
'admin_')
@staticmethod
def cleanup_resource(resource, test_name):
LOG.debug("Deleting %r from shared resources of %s" %
(resource, test_name))
try:
# OpenStack resources are assumed to have a delete()
# method which destroys the resource...
resource.delete()
except Exception as e:
# If the resource is already missing, mission accomplished.
# add status code as workaround for bug 1247568
if (e.__class__.__name__ == 'NotFound' or
(hasattr(e, 'status_code') and e.status_code == 404)):
return
raise
def is_deletion_complete():
# Deletion testing is only required for objects whose
# existence cannot be checked via retrieval.
if isinstance(resource, dict):
return True
try:
resource.get()
except Exception as e:
# Clients are expected to return an exception
# called 'NotFound' if retrieval fails.
if e.__class__.__name__ == 'NotFound':
return True
raise
return False
# Block until resource deletion has completed or timed-out
tempest.test.call_until_true(is_deletion_complete, 10, 1)
@classmethod
def tearDownClass(cls):
# NOTE(jaypipes): Because scenario tests are typically run in a
# specific order, and because test methods in scenario tests
# generally create resources in a particular order, we destroy
# resources in the reverse order in which resources are added to
# the scenario test class object
while cls.os_resources:
thing = cls.os_resources.pop()
cls.cleanup_resource(thing, cls.__name__)
cls.isolated_creds.clear_isolated_creds()
super(OfficialClientTest, cls).tearDownClass()
@classmethod
def set_resource(cls, key, thing):
LOG.debug("Adding %r to shared resources of %s" %
(thing, cls.__name__))
cls.resource_keys[key] = thing
cls.os_resources.append(thing)
@classmethod
def get_resource(cls, key):
return cls.resource_keys[key]
@classmethod
def remove_resource(cls, key):
thing = cls.resource_keys[key]
cls.os_resources.remove(thing)
del cls.resource_keys[key]
def status_timeout(self, things, thing_id, expected_status,
error_status='ERROR',
not_found_exception=nova_exceptions.NotFound):
"""
Given a thing and an expected status, do a loop, sleeping
for a configurable amount of time, checking for the
expected status to show. At any time, if the returned
status of the thing is ERROR, fail out.
"""
self._status_timeout(things, thing_id,
expected_status=expected_status,
error_status=error_status,
not_found_exception=not_found_exception)
def delete_timeout(self, things, thing_id,
error_status='ERROR',
not_found_exception=nova_exceptions.NotFound):
"""
Given a thing, do a loop, sleeping
for a configurable amount of time, checking for the
deleted status to show. At any time, if the returned
status of the thing is ERROR, fail out.
"""
self._status_timeout(things,
thing_id,
allow_notfound=True,
error_status=error_status,
not_found_exception=not_found_exception)
def _status_timeout(self,
things,
thing_id,
expected_status=None,
allow_notfound=False,
error_status='ERROR',
not_found_exception=nova_exceptions.NotFound):
log_status = expected_status if expected_status else ''
if allow_notfound:
log_status += ' or NotFound' if log_status != '' else 'NotFound'
def check_status():
# python-novaclient has resources available to its client
# that all implement a get() method taking an identifier
# for the singular resource to retrieve.
try:
thing = things.get(thing_id)
except not_found_exception:
if allow_notfound:
return True
else:
raise
new_status = thing.status
# Some components are reporting error status in lower case
# so case sensitive comparisons can really mess things
# up.
if new_status.lower() == error_status.lower():
message = ("%s failed to get to expected status (%s). "
"In %s state.") % (thing, expected_status,
new_status)
raise exceptions.BuildErrorException(message,
server_id=thing_id)
elif new_status == expected_status and expected_status is not None:
return True # All good.
LOG.debug("Waiting for %s to get to %s status. "
"Currently in %s status",
thing, log_status, new_status)
if not tempest.test.call_until_true(
check_status,
CONF.compute.build_timeout,
CONF.compute.build_interval):
message = ("Timed out waiting for thing %s "
"to become %s") % (thing_id, log_status)
raise exceptions.TimeoutException(message)
def _create_loginable_secgroup_rule_nova(self, client=None,
secgroup_id=None):
if client is None:
client = self.compute_client
if secgroup_id is None:
sgs = client.security_groups.list()
for sg in sgs:
if sg.name == 'default':
secgroup_id = sg.id
# These rules are intended to permit inbound ssh and icmp
# traffic from all sources, so no group_id is provided.
# Setting a group_id would only permit traffic from ports
# belonging to the same security group.
rulesets = [
{
# ssh
'ip_protocol': 'tcp',
'from_port': 22,
'to_port': 22,
'cidr': '0.0.0.0/0',
},
{
# ping
'ip_protocol': 'icmp',
'from_port': -1,
'to_port': -1,
'cidr': '0.0.0.0/0',
}
]
rules = list()
for ruleset in rulesets:
sg_rule = client.security_group_rules.create(secgroup_id,
**ruleset)
self.set_resource(sg_rule.id, sg_rule)
rules.append(sg_rule)
return rules
def create_server(self, client=None, name=None, image=None, flavor=None,
wait=True, create_kwargs={}):
if client is None:
client = self.compute_client
if name is None:
name = data_utils.rand_name('scenario-server-')
if image is None:
image = CONF.compute.image_ref
if flavor is None:
flavor = CONF.compute.flavor_ref
fixed_network_name = CONF.compute.fixed_network_name
if 'nics' not in create_kwargs and fixed_network_name:
networks = client.networks.list()
# If several networks found, set the NetID on which to connect the
# server to avoid the following error "Multiple possible networks
# found, use a Network ID to be more specific."
# See Tempest #1250866
if len(networks) > 1:
for network in networks:
if network.label == fixed_network_name:
create_kwargs['nics'] = [{'net-id': network.id}]
break
# If we didn't find the network we were looking for :
else:
msg = ("The network on which the NIC of the server must "
"be connected can not be found : "
"fixed_network_name=%s. Starting instance without "
"specifying a network.") % fixed_network_name
LOG.info(msg)
LOG.debug("Creating a server (name: %s, image: %s, flavor: %s)",
name, image, flavor)
server = client.servers.create(name, image, flavor, **create_kwargs)
self.assertEqual(server.name, name)
self.set_resource(name, server)
if wait:
self.status_timeout(client.servers, server.id, 'ACTIVE')
# The instance retrieved on creation is missing network
# details, necessitating retrieval after it becomes active to
# ensure correct details.
server = client.servers.get(server.id)
self.set_resource(name, server)
LOG.debug("Created server: %s", server)
return server
def create_volume(self, client=None, size=1, name=None,
snapshot_id=None, imageRef=None):
if client is None:
client = self.volume_client
if name is None:
name = data_utils.rand_name('scenario-volume-')
LOG.debug("Creating a volume (size: %s, name: %s)", size, name)
volume = client.volumes.create(size=size, display_name=name,
snapshot_id=snapshot_id,
imageRef=imageRef)
self.set_resource(name, volume)
self.assertEqual(name, volume.display_name)
self.status_timeout(client.volumes, volume.id, 'available')
LOG.debug("Created volume: %s", volume)
return volume
def create_server_snapshot(self, server, compute_client=None,
image_client=None, name=None):
if compute_client is None:
compute_client = self.compute_client
if image_client is None:
image_client = self.image_client
if name is None:
name = data_utils.rand_name('scenario-snapshot-')
LOG.debug("Creating a snapshot image for server: %s", server.name)
image_id = compute_client.servers.create_image(server, name)
self.addCleanup(image_client.images.delete, image_id)
self.status_timeout(image_client.images, image_id, 'active')
snapshot_image = image_client.images.get(image_id)
self.assertEqual(name, snapshot_image.name)
LOG.debug("Created snapshot image %s for server %s",
snapshot_image.name, server.name)
return snapshot_image
def create_keypair(self, client=None, name=None):
if client is None:
client = self.compute_client
if name is None:
name = data_utils.rand_name('scenario-keypair-')
keypair = client.keypairs.create(name)
self.assertEqual(keypair.name, name)
self.set_resource(name, keypair)
return keypair
| |
<reponame>seidelma/id3c<gh_stars>0
"""
Datastore abstraction for our database.
"""
import logging
import psycopg2
from functools import wraps
from psycopg2 import DataError, DatabaseError, IntegrityError, ProgrammingError, sql
from psycopg2.errors import InsufficientPrivilege
from typing import Any
from uuid import UUID
from werkzeug.exceptions import Forbidden, NotFound, Conflict
from .. import db
from ..db import find_identifier, upsert_sample
from ..db.session import DatabaseSession
from .exceptions import AuthenticationRequired, BadRequest
from .utils import export
LOG = logging.getLogger(__name__)
def catch_permission_denied(function):
"""
Decorator to catch :class:`psycopg2.ProgrammingError` exceptions with the
``INSUFFICIENT_PRIVILEGE`` error code and rethrow them as
:class:`~werkzeug.exceptions.Forbidden` exceptions instead.
"""
@wraps(function)
def decorated(*args, **kwargs):
try:
return function(*args, **kwargs)
except InsufficientPrivilege as error:
LOG.error("Forbidden: %s", error)
raise Forbidden()
return decorated
@export
def login(username: str, password: str) -> DatabaseSession:
"""
Creates a new database session authenticated as the given user.
Returns an opaque session object which other functions in this module
require.
"""
LOG.debug(f"Logging into PostgreSQL database as '{username}'")
try:
return DatabaseSession(username = username, password = password)
except DatabaseError as error:
raise AuthenticationRequired() from None
@export
@catch_permission_denied
def store_enrollment(session: DatabaseSession, document: str) -> None:
"""
Store the given enrollment JSON *document* (a **string**) in the backing
database using *session*.
Raises a :class:`BadRequestDatabaseError` exception if the given *document*
isn't valid and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
try:
cursor.execute(
"INSERT INTO receiving.enrollment (document) VALUES (%s)",
(document,))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
@export
@catch_permission_denied
def store_presence_absence(session: DatabaseSession, document: str) -> None:
"""
Store the given presence/absence *document* (a **string**) in the backing
database using *session*.
Raises a :class:`BadRequestDatabaseError` exception if the given *document*
isn't valid and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
try:
cursor.execute(
"insert into receiving.presence_absence (document) VALUES (%s)",
(document,))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
@export
@catch_permission_denied
def store_sequence_read_set(session: DatabaseSession, document: str) -> None:
"""
Store the given sequence read set *document* (a **string**) in the backing
database using *session*.
Raises a :class:`BadRequestDatabaseError` exception if the given *document*
isn't valid and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
try:
cursor.execute(
"insert into receiving.sequence_read_set (document) values (%s)",
(document,))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
@export
@catch_permission_denied
def store_consensus_genome(session: DatabaseSession, document: str) -> None:
"""
Store the given consensus genome *document* (a **string**) in the backing
database using *session*.
Raises a :class:`BadRequestDatabaseError` exception if the given *document*
isn't valid and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
try:
cursor.execute(
"insert into receiving.consensus_genome (document) values (%s)",
(document,))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
@export
@catch_permission_denied
def store_redcap_det(session: DatabaseSession, document: str) -> None:
"""
Store the given REDCap DET *document* (a **string**) in the backing
database using *session*.
Raises a :class:`BadRequestDatabaseError` exception if the given *document*
isn't valid and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
try:
cursor.execute(
"insert into receiving.redcap_det (document) values (%s)",
(document,))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
@export
@catch_permission_denied
def store_fhir(session: DatabaseSession, document: str) -> None:
"""
Store the given FHIR *document* (a **string**) in the backing
database using *session*.
Raises a :class:`BadRequestDatabaseError` exception if the given *document*
isn't valid and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
try:
cursor.execute(
"insert into receiving.fhir (document) values (%s)",
(document,))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
@export
@catch_permission_denied
def verify_barcode_use_list(session: DatabaseSession, barcode_use_list: list) -> Any:
"""
Check the given *barcode_use_list* containing objects with ``barcode`` and ``use``
keys and values to verify that each barcode exists in the backing database and that the
given use matches the stored use.
Returns a list of objects in the same order as the input, with each object including the
``barcode`` (string) and ``use`` (string) being verified, ``barcode_found`` (boolean)
indicating whether the given barcode exists, and ``use_match`` (boolean) indicating whether
the given use matches the stored use. The ``use_match`` value will be `null` if the barcode
does not exist.
"""
barcode_use_tuples = [(bu["barcode"],bu["use"]) for bu in barcode_use_list]
args_str = ','.join(['%s'] * len(barcode_use_tuples))
sql = "select q.barcode, q.use, \
case \
when identifier.barcode is not null then true else false \
end as barcode_found, \
case \
when identifier_set.use IS NULL then null \
when q.use::citext=identifier_set.use then true \
else false \
end as use_match \
from (values {}) as q (barcode, use) \
left join warehouse.identifier on q.barcode::citext = identifier.barcode \
left join warehouse.identifier_set using (identifier_set_id)".format(args_str)
result = session.fetch_all(sql, tuple(barcode_use_tuples))
return result
@export
@catch_permission_denied
def fetch_identifier(session: DatabaseSession, id: str) -> Any:
"""
Fetch the identifier *id* from the backing database using *session*.
*id* may be a full UUID or shortened barcode.
Returns a named tuple with ``uuid``, ``barcode``, ``generated``, ``set``,
and ``use`` attributes. If the identifier doesn't exist, raises a
:class:`~werkzeug.exceptions.NotFound` exception.
"""
try:
uuid = UUID(id)
id_field = "uuid"
except ValueError:
id_field = "barcode"
with session:
identifier = session.fetch_row(f"""
select uuid, barcode, generated, identifier_set.name as set, identifier_set.use
from warehouse.identifier
join warehouse.identifier_set using (identifier_set_id)
where {id_field} = %s
""", (id,))
if not identifier:
LOG.info(f"Identifier {id_field} «{id}» not found")
raise NotFound(f"Identifier {id_field} «{id}» not found")
return identifier
@export
@catch_permission_denied
def fetch_identifier_sets(session: DatabaseSession) -> Any:
"""
Fetch all identifier sets from the backing database using *session*.
Returns a list of named tuples with ``name``, ``description``, and ``use``
attributes.
"""
with session, session.cursor() as cursor:
cursor.execute("""
select name, description, use
from warehouse.identifier_set
""")
return list(cursor)
@export
@catch_permission_denied
def fetch_identifier_set(session: DatabaseSession, name: str) -> Any:
"""
Fetch the identifier set *name* from the backing database using *session*.
Returns a named tuple with ``name``, ``description``, and ``use`` attributes.
If the set doesn't exist, raises a :class:`~werkzeug.exceptions.NotFound`
exception.
"""
with session:
set = session.fetch_row("""
select name, description, use
from warehouse.identifier_set
where name = %s
""", (name,))
if not set:
LOG.info(f"Identifier set «{name}» not found")
raise NotFound(f"Identifier set «{name}» not found")
return set
@export
@catch_permission_denied
def make_identifier_set(session: DatabaseSession, name: str, **fields) -> bool:
"""
Create a new identifier set *name* in the backing database using *session*
if it doesn't already exist, or update if it does exist.
If *use* and/or *description* are provided as keyword arguments, their values
are set in the database. Becuase *use* is a required field in the target table,
if it is not provided as a keyword argument the query will attempt to retrieve
its value from an existing record.
Returns ``True`` if the set was created or updated and ``False`` if it
already existed and was not updated.
Raises a :class:`BadRequestDatabaseError` exception if the database reports a
`constraint` error and a :class:`Forbidden` exception if the database reports a
`permission denied` error.
"""
with session, session.cursor() as cursor:
if "use" in fields and "description" in fields:
try:
cursor.execute("""
insert into warehouse.identifier_set (name, use, description)
values (%s, %s, nullif(%s, ''))
on conflict (name) do update
set use = excluded.use,
description = excluded.description
where identifier_set.use <> excluded.use
or coalesce(identifier_set.description,'') <> coalesce(excluded.description,'')
""", (name, fields["use"], fields["description"]))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
elif "use" in fields:
try:
cursor.execute("""
insert into warehouse.identifier_set (name, use)
values (%s, %s)
on conflict (name) do update
set use = excluded.use
where identifier_set.use <> excluded.use
""", (name, fields["use"]))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
elif "description" in fields:
try:
cursor.execute("""
insert into warehouse.identifier_set (name, use, description)
select s.name, t.use, s.description
from (values(%s, nullif(%s,''))) s(name, description)
left join (
select name, use
FROM warehouse.identifier_set WHERE name = %s
) t using (name)
on conflict (name) do update
set use = excluded.use, description = excluded.description
where identifier_set.use <> excluded.use
or coalesce(identifier_set.description,'') <> coalesce(excluded.description,'')
""", (name, fields["description"], name))
except (DataError, IntegrityError) as error:
raise BadRequestDatabaseError(error) from None
else:
try:
cursor.execute("""
insert into warehouse.identifier_set (name, use)
select s.name, t.use
from (values(%s)) s(name)
left join (
select name, use
FROM warehouse.identifier_set WHERE name = %s
) t using (name)
on conflict (name) do update
set use = excluded.use
where identifier_set.use <> excluded.use
""", (name, name))
except (DataError, IntegrityError) as error:
raise | |
Leakage': 0.00611897,
'Renaming Unit/Int Front End RAT/Subthreshold Leakage with power gating': 0.00348781,
'Renaming Unit/Peak Dynamic': 4.56169,
'Renaming Unit/Runtime Dynamic': 0.329955,
'Renaming Unit/Subthreshold Leakage': 0.070483,
'Renaming Unit/Subthreshold Leakage with power gating': 0.0362779,
'Runtime Dynamic': 4.07746,
'Subthreshold Leakage': 6.21877,
'Subthreshold Leakage with power gating': 2.58311},
{'Area': 32.0201,
'Execution Unit/Area': 7.68434,
'Execution Unit/Complex ALUs/Area': 0.235435,
'Execution Unit/Complex ALUs/Gate Leakage': 0.0132646,
'Execution Unit/Complex ALUs/Peak Dynamic': 0.0277673,
'Execution Unit/Complex ALUs/Runtime Dynamic': 0.224498,
'Execution Unit/Complex ALUs/Subthreshold Leakage': 0.20111,
'Execution Unit/Complex ALUs/Subthreshold Leakage with power gating': 0.0754163,
'Execution Unit/Floating Point Units/Area': 4.6585,
'Execution Unit/Floating Point Units/Gate Leakage': 0.0656156,
'Execution Unit/Floating Point Units/Peak Dynamic': 0.14255,
'Execution Unit/Floating Point Units/Runtime Dynamic': 0.304033,
'Execution Unit/Floating Point Units/Subthreshold Leakage': 0.994829,
'Execution Unit/Floating Point Units/Subthreshold Leakage with power gating': 0.373061,
'Execution Unit/Gate Leakage': 0.120359,
'Execution Unit/Instruction Scheduler/Area': 1.66526,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Area': 0.275653,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Gate Leakage': 0.000977433,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Peak Dynamic': 1.04181,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Runtime Dynamic': 0.0699257,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Subthreshold Leakage': 0.0143453,
'Execution Unit/Instruction Scheduler/FP Instruction Window/Subthreshold Leakage with power gating': 0.00810519,
'Execution Unit/Instruction Scheduler/Gate Leakage': 0.00568913,
'Execution Unit/Instruction Scheduler/Instruction Window/Area': 0.805223,
'Execution Unit/Instruction Scheduler/Instruction Window/Gate Leakage': 0.00414562,
'Execution Unit/Instruction Scheduler/Instruction Window/Peak Dynamic': 1.6763,
'Execution Unit/Instruction Scheduler/Instruction Window/Runtime Dynamic': 0.112788,
'Execution Unit/Instruction Scheduler/Instruction Window/Subthreshold Leakage': 0.0625755,
'Execution Unit/Instruction Scheduler/Instruction Window/Subthreshold Leakage with power gating': 0.0355964,
'Execution Unit/Instruction Scheduler/Peak Dynamic': 3.82262,
'Execution Unit/Instruction Scheduler/ROB/Area': 0.584388,
'Execution Unit/Instruction Scheduler/ROB/Gate Leakage': 0.00056608,
'Execution Unit/Instruction Scheduler/ROB/Peak Dynamic': 1.10451,
'Execution Unit/Instruction Scheduler/ROB/Runtime Dynamic': 0.0569314,
'Execution Unit/Instruction Scheduler/ROB/Subthreshold Leakage': 0.00906853,
'Execution Unit/Instruction Scheduler/ROB/Subthreshold Leakage with power gating': 0.00364446,
'Execution Unit/Instruction Scheduler/Runtime Dynamic': 0.239645,
'Execution Unit/Instruction Scheduler/Subthreshold Leakage': 0.0859892,
'Execution Unit/Instruction Scheduler/Subthreshold Leakage with power gating': 0.047346,
'Execution Unit/Integer ALUs/Area': 0.47087,
'Execution Unit/Integer ALUs/Gate Leakage': 0.0265291,
'Execution Unit/Integer ALUs/Peak Dynamic': 0.0581209,
'Execution Unit/Integer ALUs/Runtime Dynamic': 0.101344,
'Execution Unit/Integer ALUs/Subthreshold Leakage': 0.40222,
'Execution Unit/Integer ALUs/Subthreshold Leakage with power gating': 0.150833,
'Execution Unit/Peak Dynamic': 4.19185,
'Execution Unit/Register Files/Area': 0.570804,
'Execution Unit/Register Files/Floating Point RF/Area': 0.208131,
'Execution Unit/Register Files/Floating Point RF/Gate Leakage': 0.000232788,
'Execution Unit/Register Files/Floating Point RF/Peak Dynamic': 0.0269307,
'Execution Unit/Register Files/Floating Point RF/Runtime Dynamic': 0.002933,
'Execution Unit/Register Files/Floating Point RF/Subthreshold Leakage': 0.00399698,
'Execution Unit/Register Files/Floating Point RF/Subthreshold Leakage with power gating': 0.00176968,
'Execution Unit/Register Files/Gate Leakage': 0.000622708,
'Execution Unit/Register Files/Integer RF/Area': 0.362673,
'Execution Unit/Register Files/Integer RF/Gate Leakage': 0.00038992,
'Execution Unit/Register Files/Integer RF/Peak Dynamic': 0.0319061,
'Execution Unit/Register Files/Integer RF/Runtime Dynamic': 0.0216913,
'Execution Unit/Register Files/Integer RF/Subthreshold Leakage': 0.00614175,
'Execution Unit/Register Files/Integer RF/Subthreshold Leakage with power gating': 0.00246675,
'Execution Unit/Register Files/Peak Dynamic': 0.0588368,
'Execution Unit/Register Files/Runtime Dynamic': 0.0246243,
'Execution Unit/Register Files/Subthreshold Leakage': 0.0101387,
'Execution Unit/Register Files/Subthreshold Leakage with power gating': 0.00423643,
'Execution Unit/Results Broadcast Bus/Area Overhead': 0.0390912,
'Execution Unit/Results Broadcast Bus/Gate Leakage': 0.00537402,
'Execution Unit/Results Broadcast Bus/Peak Dynamic': 0.0741606,
'Execution Unit/Results Broadcast Bus/Runtime Dynamic': 0.196406,
'Execution Unit/Results Broadcast Bus/Subthreshold Leakage': 0.081478,
'Execution Unit/Results Broadcast Bus/Subthreshold Leakage with power gating': 0.0305543,
'Execution Unit/Runtime Dynamic': 1.09055,
'Execution Unit/Subthreshold Leakage': 1.79543,
'Execution Unit/Subthreshold Leakage with power gating': 0.688821,
'Gate Leakage': 0.368936,
'Instruction Fetch Unit/Area': 5.85939,
'Instruction Fetch Unit/Branch Predictor/Area': 0.138516,
'Instruction Fetch Unit/Branch Predictor/Chooser/Area': 0.0435221,
'Instruction Fetch Unit/Branch Predictor/Chooser/Gate Leakage': 0.000278362,
'Instruction Fetch Unit/Branch Predictor/Chooser/Peak Dynamic': 0.0168831,
'Instruction Fetch Unit/Branch Predictor/Chooser/Runtime Dynamic': 0.000210663,
'Instruction Fetch Unit/Branch Predictor/Chooser/Subthreshold Leakage': 0.00759719,
'Instruction Fetch Unit/Branch Predictor/Chooser/Subthreshold Leakage with power gating': 0.0039236,
'Instruction Fetch Unit/Branch Predictor/Gate Leakage': 0.000757657,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Area': 0.0435221,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Gate Leakage': 0.000278362,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Peak Dynamic': 0.0168831,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Runtime Dynamic': 0.000210663,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Subthreshold Leakage': 0.00759719,
'Instruction Fetch Unit/Branch Predictor/Global Predictor/Subthreshold Leakage with power gating': 0.0039236,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Area': 0.0257064,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Gate Leakage': 0.000154548,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Peak Dynamic': 0.0142575,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Runtime Dynamic': 0.000183811,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Subthreshold Leakage': 0.00384344,
'Instruction Fetch Unit/Branch Predictor/L1_Local Predictor/Subthreshold Leakage with power gating': 0.00198631,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Area': 0.0151917,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Gate Leakage': 8.00196e-05,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Peak Dynamic': 0.00527447,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Runtime Dynamic': 7.1333e-05,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Subthreshold Leakage': 0.00181347,
'Instruction Fetch Unit/Branch Predictor/L2_Local Predictor/Subthreshold Leakage with power gating': 0.000957045,
'Instruction Fetch Unit/Branch Predictor/Peak Dynamic': 0.0597838,
'Instruction Fetch Unit/Branch Predictor/RAS/Area': 0.0105732,
'Instruction Fetch Unit/Branch Predictor/RAS/Gate Leakage': 4.63858e-05,
'Instruction Fetch Unit/Branch Predictor/RAS/Peak Dynamic': 0.0117602,
'Instruction Fetch Unit/Branch Predictor/RAS/Runtime Dynamic': 0.000311598,
'Instruction Fetch Unit/Branch Predictor/RAS/Subthreshold Leakage': 0.000932505,
'Instruction Fetch Unit/Branch Predictor/RAS/Subthreshold Leakage with power gating': 0.000494733,
'Instruction Fetch Unit/Branch Predictor/Runtime Dynamic': 0.000916735,
'Instruction Fetch Unit/Branch Predictor/Subthreshold Leakage': 0.0199703,
'Instruction Fetch Unit/Branch Predictor/Subthreshold Leakage with power gating': 0.0103282,
'Instruction Fetch Unit/Branch Target Buffer/Area': 0.64954,
'Instruction Fetch Unit/Branch Target Buffer/Gate Leakage': 0.00272758,
'Instruction Fetch Unit/Branch Target Buffer/Peak Dynamic': 0.177867,
'Instruction Fetch Unit/Branch Target Buffer/Runtime Dynamic': 0.00200827,
'Instruction Fetch Unit/Branch Target Buffer/Subthreshold Leakage': 0.0811682,
'Instruction Fetch Unit/Branch Target Buffer/Subthreshold Leakage with power gating': 0.0435357,
'Instruction Fetch Unit/Gate Leakage': 0.0589979,
'Instruction Fetch Unit/Instruction Buffer/Area': 0.0226323,
'Instruction Fetch Unit/Instruction Buffer/Gate Leakage': 6.83558e-05,
'Instruction Fetch Unit/Instruction Buffer/Peak Dynamic': 0.606827,
'Instruction Fetch Unit/Instruction Buffer/Runtime Dynamic': 0.0208524,
'Instruction Fetch Unit/Instruction Buffer/Subthreshold Leakage': 0.00151885,
'Instruction Fetch Unit/Instruction Buffer/Subthreshold Leakage with power gating': 0.000701682,
'Instruction Fetch Unit/Instruction Cache/Area': 3.14635,
'Instruction Fetch Unit/Instruction Cache/Gate Leakage': 0.029931,
'Instruction Fetch Unit/Instruction Cache/Peak Dynamic': 1.32639,
'Instruction Fetch Unit/Instruction Cache/Runtime Dynamic': 0.0576799,
'Instruction Fetch Unit/Instruction Cache/Subthreshold Leakage': 0.367022,
'Instruction Fetch Unit/Instruction Cache/Subthreshold Leakage with power gating': 0.180386,
'Instruction Fetch Unit/Instruction Decoder/Area': 1.85799,
'Instruction Fetch Unit/Instruction Decoder/Gate Leakage': 0.0222493,
'Instruction Fetch Unit/Instruction Decoder/Peak Dynamic': 1.37404,
'Instruction Fetch Unit/Instruction Decoder/Runtime Dynamic': 0.0708242,
'Instruction Fetch Unit/Instruction Decoder/Subthreshold Leakage': 0.442943,
'Instruction Fetch Unit/Instruction Decoder/Subthreshold Leakage with power gating': 0.166104,
'Instruction Fetch Unit/Peak Dynamic': 3.60928,
'Instruction Fetch Unit/Runtime Dynamic': 0.152282,
'Instruction Fetch Unit/Subthreshold Leakage': 0.932286,
'Instruction Fetch Unit/Subthreshold Leakage with power gating': 0.40843,
'L2/Area': 4.53318,
'L2/Gate Leakage': 0.015464,
'L2/Peak Dynamic': 0.0451777,
'L2/Runtime Dynamic': 0.0132532,
'L2/Subthreshold Leakage': 0.834142,
'L2/Subthreshold Leakage with power gating': 0.401066,
'Load Store Unit/Area': 8.80901,
'Load Store Unit/Data Cache/Area': 6.84535,
'Load Store Unit/Data Cache/Gate Leakage': 0.0279261,
'Load Store Unit/Data Cache/Peak Dynamic': 2.06334,
'Load Store Unit/Data Cache/Runtime Dynamic': 0.419427,
'Load Store Unit/Data Cache/Subthreshold Leakage': 0.527675,
'Load Store Unit/Data Cache/Subthreshold Leakage with power gating': 0.25085,
'Load Store Unit/Gate Leakage': 0.0350888,
'Load Store Unit/LoadQ/Area': 0.0836782,
'Load Store Unit/LoadQ/Gate Leakage': 0.00059896,
'Load Store Unit/LoadQ/Peak Dynamic': 0.0267302,
'Load Store Unit/LoadQ/Runtime Dynamic': 0.0267302,
'Load Store Unit/LoadQ/Subthreshold Leakage': 0.00941961,
'Load Store Unit/LoadQ/Subthreshold Leakage with power gating': 0.00536918,
'Load Store Unit/Peak Dynamic': 2.18957,
'Load Store Unit/Runtime Dynamic': 0.577981,
'Load Store Unit/StoreQ/Area': 0.322079,
'Load Store Unit/StoreQ/Gate Leakage': 0.00329971,
'Load Store Unit/StoreQ/Peak Dynamic': 0.0659122,
'Load Store Unit/StoreQ/Runtime Dynamic': 0.131824,
'Load Store Unit/StoreQ/Subthreshold Leakage': 0.0345621,
'Load Store Unit/StoreQ/Subthreshold Leakage with power gating': 0.0197004,
'Load Store Unit/Subthreshold Leakage': 0.591321,
'Load Store Unit/Subthreshold Leakage with power gating': 0.283293,
'Memory Management Unit/Area': 0.4339,
'Memory Management Unit/Dtlb/Area': 0.0879726,
'Memory Management Unit/Dtlb/Gate Leakage': 0.00088729,
'Memory Management Unit/Dtlb/Peak Dynamic': 0.0233924,
'Memory Management Unit/Dtlb/Runtime Dynamic': 0.0240613,
'Memory Management Unit/Dtlb/Subthreshold Leakage': 0.0155699,
'Memory Management Unit/Dtlb/Subthreshold Leakage with power gating': 0.00887485,
'Memory Management Unit/Gate Leakage': 0.00808595,
'Memory Management Unit/Itlb/Area': 0.301552,
'Memory Management Unit/Itlb/Gate Leakage': 0.00393464,
'Memory Management Unit/Itlb/Peak Dynamic': 0.0824701,
'Memory Management Unit/Itlb/Runtime Dynamic': 0.00948431,
'Memory Management Unit/Itlb/Subthreshold Leakage': 0.0413758,
'Memory Management Unit/Itlb/Subthreshold Leakage with power gating': 0.0235842,
'Memory Management Unit/Peak Dynamic': 0.278763,
'Memory Management Unit/Runtime Dynamic': 0.0335456,
'Memory Management Unit/Subthreshold Leakage': 0.0766103,
'Memory Management Unit/Subthreshold Leakage with power gating': 0.0398333,
'Peak Dynamic': 13.9041,
'Renaming Unit/Area': 0.303608,
'Renaming Unit/FP Front End RAT/Area': 0.131045,
'Renaming Unit/FP Front End RAT/Gate Leakage': 0.00351123,
'Renaming Unit/FP Front End RAT/Peak Dynamic': 2.51468,
'Renaming Unit/FP Front End RAT/Runtime Dynamic': 0.0708425,
'Renaming Unit/FP Front End RAT/Subthreshold Leakage': 0.0308571,
'Renaming Unit/FP Front End RAT/Subthreshold Leakage with power gating': 0.0175885,
'Renaming Unit/Free List/Area': 0.0340654,
'Renaming Unit/Free List/Gate Leakage': 2.5481e-05,
'Renaming Unit/Free List/Peak Dynamic': 0.0306032,
'Renaming Unit/Free List/Runtime Dynamic': 0.004017,
'Renaming Unit/Free List/Subthreshold Leakage': 0.000370144,
'Renaming Unit/Free List/Subthreshold Leakage with power gating': 0.000201064,
'Renaming Unit/Gate Leakage': 0.00708398,
'Renaming Unit/Int Front End RAT/Area': 0.0941223,
'Renaming Unit/Int Front End RAT/Gate Leakage': 0.000283242,
'Renaming Unit/Int Front End RAT/Peak Dynamic': 0.731965,
'Renaming Unit/Int Front End RAT/Runtime Dynamic': 0.0345831,
'Renaming Unit/Int Front End RAT/Subthreshold Leakage': | |
elif wordNext == "this" and wordNextNext == "evening":
remainder = "pm"
used = 2
daySpecified = True
elif wordNext == "at" and wordNextNext == "night":
if strHH and int(strHH) > 5:
remainder = "pm"
else:
remainder = "am"
used += 2
else:
if timeQualifier != "":
military = True
if strHH and int(strHH) <= 12 and \
(timeQualifier in timeQualifiersPM):
strHH += str(int(strHH)+12)
else:
# try to parse numbers without colons
# 5 hours, 10 minutes etc.
length = len(word)
strNum = ""
remainder = ""
for i in range(length):
if word[i].isdigit():
strNum += word[i]
else:
remainder += word[i]
if remainder == "":
remainder = wordNext.replace(".", "").lstrip().rstrip()
if (
remainder == "pm" or
wordNext == "pm" or
remainder == "p.m." or
wordNext == "p.m."):
strHH = strNum
remainder = "pm"
used = 1
elif (
remainder == "am" or
wordNext == "am" or
remainder == "a.m." or
wordNext == "a.m."):
strHH = strNum
remainder = "am"
used = 1
else:
if (
int(strNum) > 100 and
(
wordPrev == "o" or
wordPrev == "oh"
)):
# 0800 hours (pronounced oh-eight-hundred)
strHH = str(int(strNum) // 100)
strMM = str(int(strNum) % 100)
military = True
if wordNext == "hours":
used += 1
elif (
(wordNext == "hours" or wordNext == "hour" or
remainder == "hours" or remainder == "hour") and
word[0] != '0' and
(
int(strNum) < 100 or
int(strNum) > 2400
)):
# ignores military time
# "in 3 hours"
hrOffset = int(strNum)
used = 2
isTime = False
hrAbs = -1
minAbs = -1
elif wordNext == "minutes" or wordNext == "minute" or \
remainder == "minutes" or remainder == "minute":
# "in 10 minutes"
minOffset = int(strNum)
used = 2
isTime = False
hrAbs = -1
minAbs = -1
elif wordNext == "seconds" or wordNext == "second" \
or remainder == "seconds" or remainder == "second":
# in 5 seconds
secOffset = int(strNum)
used = 2
isTime = False
hrAbs = -1
minAbs = -1
elif int(strNum) > 100:
# military time, eg. "3300 hours"
strHH = str(int(strNum) // 100)
strMM = str(int(strNum) % 100)
military = True
if wordNext == "hours" or wordNext == "hour" or \
remainder == "hours" or remainder == "hour":
used += 1
elif wordNext and wordNext[0].isdigit():
# military time, e.g. "04 38 hours"
strHH = strNum
strMM = wordNext
military = True
used += 1
if (wordNextNext == "hours" or
wordNextNext == "hour" or
remainder == "hours" or remainder == "hour"):
used += 1
elif (
wordNext == "" or wordNext == "o'clock" or
(
wordNext == "in" and
(
wordNextNext == "the" or
wordNextNext == timeQualifier
)
)):
strHH = strNum
strMM = "00"
if wordNext == "o'clock":
used += 1
if wordNext == "in" or wordNextNext == "in":
used += (1 if wordNext == "in" else 2)
wordNextNextNext = words[idx + 3] \
if idx + 3 < len(words) else ""
if (wordNextNext and
(wordNextNext in timeQualifier or
wordNextNextNext in timeQualifier)):
if (wordNextNext in timeQualifiersPM or
wordNextNextNext in timeQualifiersPM):
remainder = "pm"
used += 1
if (wordNextNext in timeQualifiersAM or
wordNextNextNext in timeQualifiersAM):
remainder = "am"
used += 1
if timeQualifier != "":
used += 1 # TODO: Unsure if this is 100% accurate
military = True
else:
isTime = False
HH = int(strHH) if strHH else 0
MM = int(strMM) if strMM else 0
HH = HH + 12 if remainder == "pm" and HH < 12 else HH
HH = HH - 12 if remainder == "am" and HH >= 12 else HH
if (not military and
remainder not in ['am', 'pm', 'hours', 'minutes'] and
((not daySpecified) or dayOffset < 1)):
# ambiguous time, detect whether they mean this evening or
# the next morning based on whether it has already passed
if dateNow.hour < HH:
pass # No modification needed
elif dateNow.hour < HH + 12:
HH += 12
else:
# has passed, assume the next morning
dayOffset += 1
if timeQualifier in timeQualifiersPM and HH < 12:
HH += 12
if HH > 24 or MM > 59:
isTime = False
used = 0
if isTime:
hrAbs = HH
minAbs = MM
used += 1
if used > 0:
# removed parsed words from the sentence
for i in range(used):
if idx + i >= len(words):
break
words[idx + i] = ""
if wordPrev == "o" or wordPrev == "oh":
words[words.index(wordPrev)] = ""
if wordPrev == "early":
hrOffset = -1
words[idx - 1] = ""
idx -= 1
elif wordPrev == "late":
hrOffset = 1
words[idx - 1] = ""
idx -= 1
if idx > 0 and wordPrev in markers:
words[idx - 1] = ""
if wordPrev == "this":
daySpecified = True
if idx > 1 and wordPrevPrev in markers:
words[idx - 2] = ""
if wordPrevPrev == "this":
daySpecified = True
idx += used - 1
found = True
# check that we found a date
if not date_found:
return None
if dayOffset is False:
dayOffset = 0
# perform date manipulation
extractedDate = dateNow.replace(microsecond=0)
if datestr != "":
# date included an explicit date, e.g. "june 5" or "june 2, 2017"
try:
temp = datetime.strptime(datestr, "%B %d")
except ValueError:
# Try again, allowing the year
temp = datetime.strptime(datestr, "%B %d %Y")
extractedDate = extractedDate.replace(hour=0, minute=0, second=0)
if not hasYear:
temp = temp.replace(year=extractedDate.year,
tzinfo=extractedDate.tzinfo)
if extractedDate < temp:
extractedDate = extractedDate.replace(
year=int(currentYear),
month=int(temp.strftime("%m")),
day=int(temp.strftime("%d")),
tzinfo=extractedDate.tzinfo)
else:
extractedDate = extractedDate.replace(
year=int(currentYear) + 1,
month=int(temp.strftime("%m")),
day=int(temp.strftime("%d")),
tzinfo=extractedDate.tzinfo)
else:
extractedDate = extractedDate.replace(
year=int(temp.strftime("%Y")),
month=int(temp.strftime("%m")),
day=int(temp.strftime("%d")),
tzinfo=extractedDate.tzinfo)
else:
# ignore the current HH:MM:SS if relative using days or greater
if hrOffset == 0 and minOffset == 0 and secOffset == 0:
extractedDate = extractedDate.replace(hour=0, minute=0, second=0)
if yearOffset != 0:
extractedDate = extractedDate + relativedelta(years=yearOffset)
if monthOffset != 0:
extractedDate = extractedDate + relativedelta(months=monthOffset)
if dayOffset != 0:
extractedDate = extractedDate + relativedelta(days=dayOffset)
if hrAbs != -1 and minAbs != -1:
# If no time was supplied in the string set the time to default
# time if it's available
if hrAbs is None and minAbs is None and default_time is not None:
hrAbs, minAbs = default_time.hour, default_time.minute
else:
hrAbs = hrAbs or 0
minAbs = minAbs or 0
extractedDate = extractedDate + relativedelta(hours=hrAbs,
minutes=minAbs)
if (hrAbs != 0 or minAbs != 0) and datestr == "":
if not daySpecified and dateNow > extractedDate:
extractedDate = extractedDate + relativedelta(days=1)
if hrOffset != 0:
extractedDate = extractedDate + relativedelta(hours=hrOffset)
if minOffset != 0:
extractedDate = extractedDate + relativedelta(minutes=minOffset)
if secOffset != 0:
extractedDate = extractedDate + relativedelta(seconds=secOffset)
for idx, word in enumerate(words):
if words[idx] == "and" and \
words[idx - 1] == "" and words[idx + 1] == "":
words[idx] = ""
resultStr = " ".join(words)
resultStr = ' '.join(resultStr.split())
return [extractedDate, resultStr]
def isFractional_cnh(input_str, short_scale=True):
"""
This function takes the given text and checks if it is a fraction.
Args:
input_str (str): the string to check if fractional
short_scale (bool): use short scale if True, long scale if False
Returns:
(bool) or (float): False if not a fraction, otherwise the fraction
"""
if input_str.endswith('s', -1):
input_str = input_str[:len(input_str) - 1] # e.g. "fifths"
fracts = {"whole": 1, "half": 2, "halve": 2, "quarter": 4}
if short_scale:
for num in SHORT_ORDINAL_STRING_EN:
if num > 2:
fracts[SHORT_ORDINAL_STRING_EN[num]] = num
else:
for num in LONG_ORDINAL_STRING_EN:
if num > 2:
fracts[LONG_ORDINAL_STRING_EN[num]] = num
if input_str.lower() in fracts:
return 1.0 / fracts[input_str.lower()]
return False
def normalize_cnh(text, remove_articles):
""" English string normalization """
words = text.split() # this also removed extra spaces
normalized = ""
for word in words:
if remove_articles and word in ["the", "a", "an"]:
continue
# Expand common contractions, e.g. "isn't" -> "is not"
contraction = ["ain't", "aren't", "can't", "could've", "couldn't",
"didn't", "doesn't", "don't", "gonna", "gotta",
"hadn't", "hasn't", "haven't", "he'd", "he'll", "he's",
"how'd", "how'll", "how's", | |
<filename>src/evaluation/experiment.py
'''
Created on Nov 1, 2016
@author: <NAME>
'''
import logging
import pickle
import pandas as pd
import datetime
import configparser
import os, subprocess
import sklearn.metrics as skm
import numpy as np
import glob
#import lample_lstm_tagger.lstm_wrapper as lstm_wrapper
import evaluation.metrics as metrics
from baselines.dawid_and_skene import ds, ibccvb
from evaluation.plots import SCORE_NAMES, plot_results
from baselines.hmm import HMM_crowd
from baselines.util import crowd_data, crowdlab, instance
from baselines import ibcc, clustering, majority_voting
from bsc import bsc
from data import data_utils
from evaluation.span_level_f1 import precision, recall, f1, strict_span_metrics_2
logging.basicConfig(level=logging.DEBUG)
def calculate_sample_metrics(nclasses, agg, gt, probs, doc_starts, print_per_class_results=False):
result = -np.ones(len(SCORE_NAMES) - 3)
gt = gt.astype(int)
probs[np.isnan(probs)] = 0
probs[np.isinf(probs)] = 0
# token-level metrics
result[0] = skm.accuracy_score(gt, agg)
# the results are undefined if some classes are not present in the gold labels
prec_by_class = skm.precision_score(gt, agg, average=None, labels=range(nclasses))
rec_by_class = skm.recall_score(gt, agg, average=None, labels=range(nclasses))
f1_by_class = skm.f1_score(gt, agg, average=None, labels=range(nclasses))
if print_per_class_results:
print('Token Precision:')
print(prec_by_class)
print('Token Recall:')
print(rec_by_class)
print('Token F1:')
print(f1_by_class)
result[1] = np.mean(prec_by_class[np.unique(gt)])
result[2] = np.mean(rec_by_class[np.unique(gt)])
result[3] = np.mean(f1_by_class[np.unique(gt)])
# span-level metrics - strict
p, r, f = strict_span_metrics_2(agg, gt, doc_starts)
result[6] = p # precision(agg, gt, True, doc_starts)
result[7] = r # recall(agg, gt, True, doc_starts)
result[8] = f # f1(agg, gt, True, doc_starts)
# span-level metrics -- relaxed
result[9] = precision(agg, gt, False, doc_starts)
result[10] = recall(agg, gt, False, doc_starts)
result[11] = f1(agg, gt, False, doc_starts)
auc_score = 0
total_weights = 0
for i in range(probs.shape[1]):
if not np.any(gt == i) or np.all(gt == i) or np.any(np.isnan(probs[:, i])) or np.any(np.isinf(probs[:, i])):
print('Could not evaluate AUC for class %i -- all data points have same value.' % i)
continue
auc_i = skm.roc_auc_score(gt == i, probs[:, i])
# print 'AUC for class %i: %f' % (i, auc_i)
auc_score += auc_i * np.sum(gt == i)
total_weights += np.sum(gt == i)
if print_per_class_results:
print('AUC for class %i = %f' % (i, auc_i))
result[4] = auc_score / float(total_weights) if total_weights > 0 else 0
result[5] = skm.log_loss(gt, probs, eps=1e-100, labels=np.arange(nclasses))
return result
def calculate_scores(nclasses, postprocess, agg, gt, probs, doc_start, bootstrapping=True, print_per_class_results=False):
result = -np.ones((len(SCORE_NAMES), 1))
# exclude data points with missing ground truth
agg = agg[gt != -1]
probs = probs[gt != -1]
doc_start = doc_start[gt != -1]
gt = gt[gt != -1]
print('unique ground truth values: ')
print(np.unique(gt))
print('unique prediction values: ')
print(np.unique(agg))
if postprocess:
agg = data_utils.postprocess(agg, doc_start)
print('Plotting confusion matrix for errors: ')
nclasses = probs.shape[1]
conf = np.zeros((nclasses, nclasses))
for i in range(nclasses):
for j in range(nclasses):
conf[i, j] = np.sum((gt == i).flatten() & (agg == j).flatten())
# print 'Acc for class %i: %f' % (i, skm.accuracy_score(gt==i, agg==i))
print(np.round(conf))
gold_doc_start = np.copy(doc_start)
gold_doc_start[gt == -1] = 0
Ndocs = int(np.sum(gold_doc_start))
if Ndocs < 100 and bootstrapping:
print('Using bootstrapping with small test set size')
# use bootstrap resampling with small datasets
nbootstraps = 100
nmetrics = len(SCORE_NAMES) - 3
resample_results = np.zeros((nmetrics, nbootstraps))
for i in range(nbootstraps):
print('Bootstrapping the evaluation: %i of %i' % (i, nbootstraps))
not_sampled = True
nsample_attempts = 0
while not_sampled:
sampleidxs = np.random.choice(Ndocs, Ndocs, replace=True)
sampleidxs = np.in1d(np.cumsum(gold_doc_start) - 1, sampleidxs)
if len(np.unique(gt[sampleidxs])) >= 2:
not_sampled = False
# if we have at least two class labels in the sample ground truth, we can use this sample
nsample_attempts += 1
if nsample_attempts >= Ndocs:
not_sampled = False
if nsample_attempts <= Ndocs:
resample_results[:, i] = calculate_sample_metrics(nclasses,
agg[sampleidxs],
gt[sampleidxs],
probs[sampleidxs],
doc_start[sampleidxs],
print_per_class_results)
else: # can't find enough valid samples for the bootstrap, let's just use what we got so far.
resample_results = resample_results[:, :i]
break
sample_res = np.mean(resample_results, axis=1)
result[:len(sample_res), 0] = sample_res
std_result = np.std(resample_results, axis=1)
else:
sample_res = calculate_sample_metrics(nclasses, agg, gt, probs, doc_start, print_per_class_results)
result[:len(sample_res), 0] = sample_res
std_result = None
result[len(sample_res)] = metrics.count_error(agg, gt)
result[len(sample_res) + 1] = metrics.num_invalid_labels(agg, doc_start)
result[len(sample_res) + 2] = metrics.mean_length_error(agg, gt, doc_start)
print('CEE tokens = %f' % result[5])
print('F1 score tokens = %f' % result[3])
print('F1 score spans strict = %f' % result[8])
print('F1 score spans relaxed = %f' % result[11])
return result, std_result
class Experiment(object):
'''
classdocs
'''
generator = None
config_file = None
param_values = None
param_idx = None
param_fixed = None
acc_bias = None
miss_bias = None
short_bias = None
generate_data= False
methods = None
alpha0 = None
nu0 = None
num_runs = None
doc_length = None
group_sizes = None
num_docs = None
num_classes = None
save_results = False
save_plots = False
show_plots = False
postprocess = False # previous papers did not use this so we leave out to make results comparable.
# Only simple IOB2 is implemented so far.
opt_hyper = False
crf_probs = False
random_sampling = False
def __init__(self, generator, nclasses=None, nannotators=None, config=None, alpha0_factor=1.0, alpha0_diags=1.0,
beta0_factor=0.1, max_iter=20, crf_probs=False, rep=0, max_internal_iter=20):
self.output_dir = '~/data/bayesian_sequence_combination/output/'
self.crf_probs = crf_probs
self.generator = generator
if config is not None:
self.config_file = config
self.read_config_file()
else:
self.num_classes = nclasses
self.nannotators = nannotators
self.output_dir = os.path.expanduser(self.output_dir)
self.alpha0_factor = alpha0_factor
self.alpha0_diags = alpha0_diags
self.nu0_factor = beta0_factor
self.max_internal_iter = max_internal_iter
# save results from methods here. If we use compound methods, we can reuse these results in different
# combinations of methods.
self.aggs = {}
self.probs = {}
self.max_iter = max_iter # allow all methods to use a maximum no. iterations
np.random.seed(3849)
self.seed = np.random.randint(1, 1000, 100)[rep] # seeds for AL
def read_config_file(self):
print('Reading experiment config file...')
parser = configparser.ConfigParser()
parser.read(self.config_file)
# set up parameters
parameters = dict(parser.items('parameters'))
self.param_idx = int(parameters['idx'].split('#')[0].strip())
self.param_values = np.array(eval(parameters['values'].split('#')[0].strip()))
self.acc_bias = np.array(eval(parameters['acc_bias'].split('#')[0].strip()))
self.miss_bias = np.array(eval(parameters['miss_bias'].split('#')[0].strip()))
self.short_bias = np.array(eval(parameters['short_bias'].split('#')[0].strip()))
self.methods = eval(parameters['methods'].split('#')[0].strip())
self.postprocess = eval(parameters['postprocess'].split('#')[0].strip())
print(self.methods)
self.num_runs = int(parameters['num_runs'].split('#')[0].strip())
self.doc_length = int(parameters['doc_length'].split('#')[0].strip())
self.group_sizes = np.array(eval(parameters['group_sizes'].split('#')[0].strip()))
self.num_classes = int(parameters['num_classes'].split('#')[0].strip())
self.num_docs = int(parameters['num_docs'].split('#')[0].strip())
self.generate_data = eval(parameters['generate_data'].split('#')[0].strip())
# set up output
parameters = dict(parser.items('output'))
self.output_dir = parameters['output_dir']
self.save_results = eval(parameters['save_results'].split('#')[0].strip())
self.save_plots = eval(parameters['save_plots'].split('#')[0].strip())
self.show_plots = eval(parameters['show_plots'].split('#')[0].strip())
def tune_alpha0(self, alpha0diag_proposals, alpha0factor_proposals, nu0factor_proposals, method,
annotations, ground_truth, doc_start,
outputdir, text, tune_lstm=False, metric_idx_to_optimise=8,
ground_truth_val=None, doc_start_val=None, text_val=None, new_data=False):
if outputdir is not None:
if not os.path.exists(outputdir):
os.mkdir(outputdir)
self.methods = [method]
scores = np.zeros((len(nu0factor_proposals) * len(alpha0diag_proposals), len(alpha0factor_proposals)))
best_scores = np.zeros(4)
best_idxs = np.zeros(4)
for h, nu0factor in enumerate(nu0factor_proposals):
self.nu0_factor = nu0factor
for i, alpha0diag in enumerate(alpha0diag_proposals):
if tune_lstm:
self.alpha0_diags_lstm = alpha0diag
else:
self.alpha0_diags = alpha0diag
for j, alpha0factor in enumerate(alpha0factor_proposals):
# reset saved data so that models are run again.
self.aggs = {}
self.probs = {}
outputdir_ij = outputdir + ('_%i_%i_%i_' % (h, i, j)) + method + '/'
if tune_lstm:
self.alpha0_factor_lstm = alpha0factor
else:
self.alpha0_factor = alpha0factor
all_scores, _, _, _, _, _ = self.run_methods(annotations, ground_truth, doc_start,
outputdir_ij,
text,
ground_truth_val=ground_truth_val,
doc_start_val=doc_start_val,
text_val=text_val,
bootstrapping=False,
new_data=new_data)
scores[(h*len(alpha0diag_proposals)) + i, j] = all_scores[metric_idx_to_optimise, :] # 3 is F1score
print('Scores for %f, %f, %f: %f' % (nu0factor, alpha0diag, alpha0factor,
scores[(h*len(alpha0diag_proposals)) + i, j]))
if scores[(h*len(alpha0diag_proposals)) + i, j] > best_scores[0]:
best_scores[0] = scores[(h*len(alpha0diag_proposals)) + i, j]
best_scores[1] = nu0factor
best_scores[2] = alpha0diag
best_scores[3] = alpha0factor
best_idxs[0] = scores[(h*len(alpha0diag_proposals)) + i, j]
best_idxs[1] = h
best_idxs[2] = i
best_idxs[3] = j
print('Saving scores for this setting to %s' % (outputdir + '/%s_scores.csv' % method))
np.savetxt(outputdir + '/%s_scores.csv' % method, scores, fmt='%s', delimiter=',',
header=str(self.methods).strip('[]'))
np.savetxt(outputdir + '/%s_bestscores.csv' % method, best_scores, fmt='%s', delimiter=',',
header=str(self.methods).strip('[]'))
return best_idxs
def tune_acc_bias(self, acc_bias_proposals, method,
annotations, ground_truth, doc_start,
outputdir, text, tune_lstm=False, metric_idx_to_optimise=8,
ground_truth_val=None, doc_start_val=None, text_val=None):
self.methods = [method]
scores = np.zeros(len(acc_bias_proposals))
best_score = -np.inf
best_idx = 0
for i, acc_bias in enumerate(acc_bias_proposals):
self.alpha0_acc_bias = acc_bias
# reset saved data so that models are run again.
self.aggs = {}
self.probs = {}
outputdir_i = outputdir + ('_acc_bias_%i' % (i)) + method + '/'
all_scores, _, _, _, _, _ = self.run_methods(annotations, ground_truth, doc_start,
outputdir_i,
text,
ground_truth_val=ground_truth_val,
doc_start_val=doc_start_val,
text_val=text_val,
bootstrapping=False)
scores[i] = all_scores[metric_idx_to_optimise, :] # 3 is F1score
print('Scores for %f: %f' % (acc_bias, scores[i]))
if scores[i] > best_score:
best_score = scores[i]
best_idx = scores[i]
print('Saving scores for this setting to %s' % (outputdir + '/%s_scores.csv' % method))
np.savetxt(outputdir + '/%s_acc_bias_scores.csv' % method, scores, fmt='%s', delimiter=',',
header=str(self.methods).strip('[]'))
return best_score, best_idx
def _run_best_worker(self, annos, gt, doc_start):
# choose the best classifier by f1-score
f1scores = np.zeros_like(annos) - 1.0
print('F1 scores for individual workers:')
individual_scores = []
for w in range(annos.shape[1]):
valididxs = annos[:, | |
# %% md
# Data Loading
# %%
import os
os.environ['CUDA_VISIBLE_DEVICES'] = '0,1,2,3' # specify GPUs locally
import pandas as pd
from matplotlib import pyplot as plt
# import seaborn as sns
# %%
#os.listdir('../input/cassava-leaf-disease-classification')
# %%
train = pd.read_csv('/root/disk/csy/cassava/data/data/csv/2020_csv_5folds/train.csv')
train_merged = pd.read_csv('/root/disk/csy/cassava/data/data/merged19_20.csv')
test = pd.read_csv('/root/disk/csy/cassava/data/data/sample_submission.csv')
label_map = pd.read_json('/root/disk/csy/cassava/data/data/label_num_to_disease_map.json',
orient='index')
# %%
# Directory settings
# %%
# ====================================================
# Directory settings
# ====================================================
import os
OUTPUT_DIR = './results'
if not os.path.exists(OUTPUT_DIR):
os.makedirs(OUTPUT_DIR)
# TRAIN_PATH = '../input/cassava-leaf-disease-classification/train_images'
TRAIN_PATH = '/root/disk/csy/cassava/data/data/train_images'
TEST_PATH = '/root/disk/csy/cassava/data/data/test_images'
# %% md
# CFG
# %%
# ====================================================
# CFG
# ====================================================
class CFG:
debug = False
apex = False
print_freq = 100
num_workers = 4
model_name='resnext50_32x4d'
#model_name = 'tf_efficientnet_b4_ns'
size = 500 # 256
scheduler = 'CosineAnnealingWarmRestarts' # ['ReduceLROnPlateau', 'CosineAnnealingLR', 'CosineAnnealingWarmRestarts']
criterion = 'TaylorCrossEntropyLoss' # ['CrossEntropyLoss', LabelSmoothing', 'FocalLoss' 'FocalCosineLoss', 'SymmetricCrossEntropyLoss', 'BiTemperedLoss', 'TaylorCrossEntropyLoss']
epochs = 12
# factor=0.2 # ReduceLROnPlateau
# patience=4 # ReduceLROnPlateau
# eps=1e-6 # ReduceLROnPlateau
# T_max=10 # CosineAnnealingLR
T_0 = 10 # CosineAnnealingWarmRestarts
lr = 1e-4
min_lr = 1e-6
batch_size = 32
weight_decay = 1e-6
gradient_accumulation_steps = 1
max_grad_norm = 1000
seed = 42
target_size = 5
target_col = 'label'
n_fold = 5
trn_fold = [0, 1, 2, 3, 4]
train = True
smoothing = 0.05
t1 = 0.3 # bi-tempered-loss https://www.kaggle.com/c/cassava-leaf-disease-classification/discussion/202017
t2 = 1.0 # bi-tempered-loss https://www.kaggle.com/c/cassava-leaf-disease-classification/discussion/202017
if CFG.debug:
CFG.epochs = 1
train = train.sample(n=1000, random_state=CFG.seed).reset_index(drop=True)
# %% md
# Library
# %%
# ====================================================
# Library
# ====================================================
import sys
sys.path.append('../pytorch-image-models-master')
import os
import math
import time
import random
import shutil
from pathlib import Path
from contextlib import contextmanager
from collections import defaultdict, Counter
import scipy as sp
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.metrics import accuracy_score
from sklearn.model_selection import StratifiedKFold
from tqdm.auto import tqdm
from functools import partial
import cv2
from PIL import Image
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam, SGD
import torchvision.models as models
from torch.nn.parameter import Parameter
from torch.utils.data import DataLoader, Dataset, WeightedRandomSampler
from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, CosineAnnealingLR, ReduceLROnPlateau
import albumentations as A
from albumentations.pytorch import ToTensorV2
from albumentations import ImageOnlyTransform
import timm
import warnings
warnings.filterwarnings('ignore')
if CFG.apex:
# from apex import amp
from torch.cuda.amp import autocast, GradScaler
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# %% md
# Utils
# %%
# ====================================================
# Utils
# ====================================================
def get_score(y_true, y_pred):
return accuracy_score(y_true, y_pred)
@contextmanager
def timer(name):
t0 = time.time()
LOGGER.info(f'[{name}] start')
yield
LOGGER.info(f'[{name}] done in {time.time() - t0:.0f} s.')
def init_logger(log_file=OUTPUT_DIR + 'train.log'):
from logging import getLogger, INFO, FileHandler, Formatter, StreamHandler
logger = getLogger(__name__)
logger.setLevel(INFO)
handler1 = StreamHandler()
handler1.setFormatter(Formatter("%(message)s"))
handler2 = FileHandler(filename=log_file)
handler2.setFormatter(Formatter("%(message)s"))
logger.addHandler(handler1)
logger.addHandler(handler2)
return logger
LOGGER = init_logger()
def seed_torch(seed=42):
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.backends.cudnn.deterministic = True
seed_torch(seed=CFG.seed)
# %% md
# CV split
# %%
#folds = train.copy()
folds = train_merged.copy()
Fold = StratifiedKFold(n_splits=CFG.n_fold, shuffle=True, random_state=CFG.seed)
for n, (train_index, val_index) in enumerate(Fold.split(folds, folds[CFG.target_col])):
folds.loc[val_index, 'fold'] = int(n)
folds['fold'] = folds['fold'].astype(int)
print(folds.groupby(['fold', CFG.target_col]).size())
# %% md
# Dataset
# %%
# ====================================================
# Dataset
# ====================================================
class TrainDataset(Dataset):
def __init__(self, df, transform=None):
self.df = df
self.file_names = df['image_id'].values
self.labels = df['label'].values
self.transform = transform
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
file_name = self.file_names[idx]
file_path = f'{TRAIN_PATH}/{file_name}'
image = cv2.imread(file_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if self.transform:
augmented = self.transform(image=image)
image = augmented['image']
label = torch.tensor(self.labels[idx]).long()
return image, label
class TestDataset(Dataset):
def __init__(self, df, transform=None):
self.df = df
self.file_names = df['image_id'].values
self.transform = transform
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
file_name = self.file_names[idx]
file_path = f'{TEST_PATH}/{file_name}'
image = cv2.imread(file_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
if self.transform:
augmented = self.transform(image=image)
image = augmented['image']
return image
# %%
train_dataset = TrainDataset(train, transform=None)
# for i in range(1):
# image, label = train_dataset[i]
# plt.imshow(image)
# plt.title(f'label: {label}')
# plt.show()
#
# %% md
# Transforms
# %%
# ====================================================
# Transforms
# ====================================================
def get_transforms(*, data):
if data == 'train':
return A.Compose([
#A.Resize(CFG.size, CFG.size),
A.RandomResizedCrop(CFG.size, CFG.size),
A.Transpose(p=0.5),
A.HorizontalFlip(p=0.5),
A.HueSaturationValue(hue_shift_limit=0.2, sat_shift_limit=0.2, val_shift_limit=0.2, p=0.5),
A.RandomBrightnessContrast(brightness_limit=(-0.1,0.1), contrast_limit=(-0.1, 0.1), p=0.5),
A.VerticalFlip(p=0.5),
A.ShiftScaleRotate(p=0.5),
A.CoarseDropout(p=0.5),
A.Cutout(p=0.5),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
elif data == 'valid':
return A.Compose([
A.CenterCrop(CFG.size, CFG.size),
A.Resize(CFG.size, CFG.size),
#A.CenterCrop(CFG.size, CFG.size),
A.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
),
ToTensorV2(),
])
# %%
train_dataset = TrainDataset(train, transform=get_transforms(data='train'))
# for i in range(1):
# image, label = train_dataset[i]
# plt.imshow(image[0])
# plt.title(f'label: {label}')
# plt.show()
#
# %%
# ====================================================
# MODEL
# ====================================================
class CustomEfficientNet(nn.Module):
def __init__(self, model_name=CFG.model_name, pretrained=False):
super().__init__()
self.model = timm.create_model(CFG.model_name, pretrained=pretrained)
n_features = self.model.classifier.in_features
self.model.classifier = nn.Linear(n_features, CFG.target_size)
def forward(self, x):
x = self.model(x)
return x
class CustomResNext(nn.Module):
def __init__(self, model_name='resnext50_32x4d', pretrained=False):
super().__init__()
self.model = timm.create_model(model_name, pretrained=pretrained)
n_features = self.model.fc.in_features
self.model.fc = nn.Linear(n_features, CFG.target_size)
def forward(self, x):
x = self.model(x)
return x
# %%
# model = CustomResNext(model_name=CFG.model_name, pretrained=True)
# # model = CustomEfficientNet(model_name=CFG.model_name, pretrained=False)
# train_dataset = TrainDataset(train, transform=get_transforms(data='train'))
# train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True,
# num_workers=4, pin_memory=True, drop_last=True)
#
# for image, label in train_loader:
# output = model(image)
# print(output)
# break
# %% md
# Criterion
# %% md
## Label Smoothing
# %%
# ====================================================
# Label Smoothing
# ====================================================
class LabelSmoothingLoss(nn.Module):
def __init__(self, classes=5, smoothing=0.0, dim=-1):
super(LabelSmoothingLoss, self).__init__()
self.confidence = 1.0 - smoothing
self.smoothing = smoothing
self.cls = classes
self.dim = dim
def forward(self, pred, target):
pred = pred.log_softmax(dim=self.dim)
with torch.no_grad():
true_dist = torch.zeros_like(pred)
true_dist.fill_(self.smoothing / (self.cls - 1))
true_dist.scatter_(1, target.data.unsqueeze(1), self.confidence)
return torch.mean(torch.sum(-true_dist * pred, dim=self.dim))
# %% md
## Focal Loss
# %%
class FocalLoss(nn.Module):
def __init__(self, alpha=1, gamma=2, reduce=True):
super(FocalLoss, self).__init__()
self.alpha = alpha
self.gamma = gamma
self.reduce = reduce
def forward(self, inputs, targets):
BCE_loss = nn.CrossEntropyLoss()(inputs, targets)
pt = torch.exp(-BCE_loss)
F_loss = self.alpha * (1 - pt) ** self.gamma * BCE_loss
if self.reduce:
return torch.mean(F_loss)
else:
return F_loss
# %% md
## FocalCosineLoss
# %%
class FocalCosineLoss(nn.Module):
def __init__(self, alpha=1, gamma=2, xent=.1):
super(FocalCosineLoss, self).__init__()
self.alpha = alpha
self.gamma = gamma
self.xent = xent
self.y = torch.Tensor([1]).cuda()
def forward(self, input, target, reduction="mean"):
cosine_loss = F.cosine_embedding_loss(input, F.one_hot(target, num_classes=input.size(-1)), self.y,
reduction=reduction)
cent_loss = F.cross_entropy(F.normalize(input), target, reduce=False)
pt = torch.exp(-cent_loss)
focal_loss = self.alpha * (1 - pt) ** self.gamma * cent_loss
if reduction == "mean":
focal_loss = torch.mean(focal_loss)
return cosine_loss + self.xent * focal_loss
# %% md
## SymmetricCrossEntropy
# %%
class SymmetricCrossEntropy(nn.Module):
def __init__(self, alpha=0.1, beta=1.0, num_classes=5):
super(SymmetricCrossEntropy, self).__init__()
self.alpha = alpha
self.beta = beta
self.num_classes = num_classes
def forward(self, logits, targets, reduction='mean'):
onehot_targets = torch.eye(self.num_classes)[targets].cuda()
ce_loss = F.cross_entropy(logits, targets, reduction=reduction)
rce_loss = (-onehot_targets * logits.softmax(1).clamp(1e-7, 1.0).log()).sum(1)
if reduction == 'mean':
rce_loss = rce_loss.mean()
elif reduction == 'sum':
rce_loss = rce_loss.sum()
return self.alpha * ce_loss + self.beta * rce_loss
# %% md
# Bi-Tempered-Loss
# %%
def log_t(u, t):
"""Compute log_t for `u'."""
if t == 1.0:
return u.log()
else:
return (u.pow(1.0 - t) - 1.0) / (1.0 - t)
def exp_t(u, t):
"""Compute exp_t for `u'."""
if t == 1:
return u.exp()
else:
return (1.0 + (1.0 - t) * u).relu().pow(1.0 / (1.0 - t))
def compute_normalization_fixed_point(activations, t, num_iters):
"""Returns the normalization value for each example (t > 1.0).
Args:
activations: A multi-dimensional tensor with last dimension `num_classes`.
t: Temperature 2 (> 1.0 for tail heaviness).
num_iters: Number of iterations to run the method.
Return: A tensor of same shape as activation with the last dimension being 1.
"""
mu, _ = torch.max(activations, -1, keepdim=True)
normalized_activations_step_0 = activations - mu
normalized_activations = normalized_activations_step_0
for _ in range(num_iters):
logt_partition = torch.sum(
exp_t(normalized_activations, t), -1, keepdim=True)
normalized_activations = normalized_activations_step_0 * \
logt_partition.pow(1.0 - t)
logt_partition = torch.sum(
exp_t(normalized_activations, t), -1, keepdim=True)
normalization_constants = - log_t(1.0 / logt_partition, t) + mu
return normalization_constants
def compute_normalization_binary_search(activations, t, num_iters):
"""Returns the normalization value for each example (t < 1.0).
Args:
activations: A multi-dimensional tensor with last dimension `num_classes`.
t: Temperature 2 (< 1.0 for finite support).
num_iters: Number of iterations to run the method.
Return: A tensor of same rank as activation with the last dimension being 1.
"""
mu, _ = torch.max(activations, -1, keepdim=True)
normalized_activations = activations - mu
effective_dim = \
torch.sum(
(normalized_activations > -1.0 / (1.0 - t)).to(torch.int32),
dim=-1, keepdim=True).to(activations.dtype)
shape_partition = activations.shape[:-1] + (1,)
lower = torch.zeros(shape_partition, dtype=activations.dtype, device=activations.device)
upper = -log_t(1.0 / effective_dim, t) * torch.ones_like(lower)
for _ in range(num_iters):
logt_partition = (upper + lower) / 2.0
sum_probs = torch.sum(
exp_t(normalized_activations - logt_partition, t),
dim=-1, keepdim=True)
update = (sum_probs < 1.0).to(activations.dtype)
lower = torch.reshape(
lower * update + (1.0 - update) * logt_partition,
shape_partition)
upper = torch.reshape(
upper * (1.0 - update) + update * logt_partition,
shape_partition)
logt_partition = (upper + lower) / 2.0
return logt_partition + mu
class ComputeNormalization(torch.autograd.Function):
"""
Class implementing custom backward pass for compute_normalization. See compute_normalization.
"""
@staticmethod
def forward(ctx, activations, t, num_iters):
if t < 1.0:
normalization_constants = compute_normalization_binary_search(activations, t, num_iters)
else:
normalization_constants = compute_normalization_fixed_point(activations, t, num_iters)
ctx.save_for_backward(activations, normalization_constants)
ctx.t = t
return normalization_constants
@staticmethod
def backward(ctx, grad_output):
activations, normalization_constants = ctx.saved_tensors
t = ctx.t
normalized_activations = | |
# ex:ts=4:sw=4:sts=4:et
# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
#
# BitBake Tests for the Data Store (data.py/data_smart.py)
#
# Copyright (C) 2010 <NAME>
# Copyright (C) 2012 <NAME>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
import unittest
import bb
import bb.data
import bb.parse
import logging
class LogRecord():
def __enter__(self):
logs = []
class LogHandler(logging.Handler):
def emit(self, record):
logs.append(record)
logger = logging.getLogger("BitBake")
handler = LogHandler()
self.handler = handler
logger.addHandler(handler)
return logs
def __exit__(self, type, value, traceback):
logger = logging.getLogger("BitBake")
logger.removeHandler(self.handler)
return
def logContains(item, logs):
for l in logs:
m = l.getMessage()
if item in m:
return True
return False
class DataExpansions(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d["foo"] = "value_of_foo"
self.d["bar"] = "value_of_bar"
self.d["value_of_foo"] = "value_of_'value_of_foo'"
def test_one_var(self):
val = self.d.expand("${foo}")
self.assertEqual(str(val), "value_of_foo")
def test_indirect_one_var(self):
val = self.d.expand("${${foo}}")
self.assertEqual(str(val), "value_of_'value_of_foo'")
def test_indirect_and_another(self):
val = self.d.expand("${${foo}} ${bar}")
self.assertEqual(str(val), "value_of_'value_of_foo' value_of_bar")
def test_python_snippet(self):
val = self.d.expand("${@5*12}")
self.assertEqual(str(val), "60")
def test_expand_in_python_snippet(self):
val = self.d.expand("${@'boo ' + '${foo}'}")
self.assertEqual(str(val), "boo value_of_foo")
def test_python_snippet_getvar(self):
val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
self.assertEqual(str(val), "value_of_foo value_of_bar")
def test_python_unexpanded(self):
self.d.setVar("bar", "${unsetvar}")
val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
self.assertEqual(str(val), "${@d.getVar('foo') + ' ${unsetvar}'}")
def test_python_snippet_syntax_error(self):
self.d.setVar("FOO", "${@foo = 5}")
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
def test_python_snippet_runtime_error(self):
self.d.setVar("FOO", "${@int('test')}")
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
def test_python_snippet_error_path(self):
self.d.setVar("FOO", "foo value ${BAR}")
self.d.setVar("BAR", "bar value ${@int('test')}")
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
def test_value_containing_value(self):
val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
self.assertEqual(str(val), "value_of_foo value_of_bar")
def test_reference_undefined_var(self):
val = self.d.expand("${undefinedvar} meh")
self.assertEqual(str(val), "${undefinedvar} meh")
def test_double_reference(self):
self.d.setVar("BAR", "bar value")
self.d.setVar("FOO", "${BAR} foo ${BAR}")
val = self.d.getVar("FOO")
self.assertEqual(str(val), "bar value foo bar value")
def test_direct_recursion(self):
self.d.setVar("FOO", "${FOO}")
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
def test_indirect_recursion(self):
self.d.setVar("FOO", "${BAR}")
self.d.setVar("BAR", "${BAZ}")
self.d.setVar("BAZ", "${FOO}")
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
def test_recursion_exception(self):
self.d.setVar("FOO", "${BAR}")
self.d.setVar("BAR", "${${@'FOO'}}")
self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
def test_incomplete_varexp_single_quotes(self):
self.d.setVar("FOO", "sed -i -e 's:IP{:I${:g' $pc")
val = self.d.getVar("FOO")
self.assertEqual(str(val), "sed -i -e 's:IP{:I${:g' $pc")
def test_nonstring(self):
self.d.setVar("TEST", 5)
val = self.d.getVar("TEST")
self.assertEqual(str(val), "5")
def test_rename(self):
self.d.renameVar("foo", "newfoo")
self.assertEqual(self.d.getVar("newfoo", False), "value_of_foo")
self.assertEqual(self.d.getVar("foo", False), None)
def test_deletion(self):
self.d.delVar("foo")
self.assertEqual(self.d.getVar("foo", False), None)
def test_keys(self):
keys = list(self.d.keys())
self.assertCountEqual(keys, ['value_of_foo', 'foo', 'bar'])
def test_keys_deletion(self):
newd = bb.data.createCopy(self.d)
newd.delVar("bar")
keys = list(newd.keys())
self.assertCountEqual(keys, ['value_of_foo', 'foo'])
class TestNestedExpansions(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d["foo"] = "foo"
self.d["bar"] = "bar"
self.d["value_of_foobar"] = "187"
def test_refs(self):
val = self.d.expand("${value_of_${foo}${bar}}")
self.assertEqual(str(val), "187")
#def test_python_refs(self):
# val = self.d.expand("${@${@3}**2 + ${@4}**2}")
# self.assertEqual(str(val), "25")
def test_ref_in_python_ref(self):
val = self.d.expand("${@'${foo}' + 'bar'}")
self.assertEqual(str(val), "foobar")
def test_python_ref_in_ref(self):
val = self.d.expand("${${@'f'+'o'+'o'}}")
self.assertEqual(str(val), "foo")
def test_deep_nesting(self):
depth = 100
val = self.d.expand("${" * depth + "foo" + "}" * depth)
self.assertEqual(str(val), "foo")
#def test_deep_python_nesting(self):
# depth = 50
# val = self.d.expand("${@" * depth + "1" + "+1}" * depth)
# self.assertEqual(str(val), str(depth + 1))
def test_mixed(self):
val = self.d.expand("${value_of_${@('${foo}'+'bar')[0:3]}${${@'BAR'.lower()}}}")
self.assertEqual(str(val), "187")
def test_runtime(self):
val = self.d.expand("${${@'value_of' + '_f'+'o'+'o'+'b'+'a'+'r'}}")
self.assertEqual(str(val), "187")
class TestMemoize(unittest.TestCase):
def test_memoized(self):
d = bb.data.init()
d.setVar("FOO", "bar")
self.assertTrue(d.getVar("FOO", False) is d.getVar("FOO", False))
def test_not_memoized(self):
d1 = bb.data.init()
d2 = bb.data.init()
d1.setVar("FOO", "bar")
d2.setVar("FOO", "bar2")
self.assertTrue(d1.getVar("FOO", False) is not d2.getVar("FOO", False))
def test_changed_after_memoized(self):
d = bb.data.init()
d.setVar("foo", "value of foo")
self.assertEqual(str(d.getVar("foo", False)), "value of foo")
d.setVar("foo", "second value of foo")
self.assertEqual(str(d.getVar("foo", False)), "second value of foo")
def test_same_value(self):
d = bb.data.init()
d.setVar("foo", "value of")
d.setVar("bar", "value of")
self.assertEqual(d.getVar("foo", False),
d.getVar("bar", False))
class TestConcat(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d.setVar("FOO", "foo")
self.d.setVar("VAL", "val")
self.d.setVar("BAR", "bar")
def test_prepend(self):
self.d.setVar("TEST", "${VAL}")
self.d.prependVar("TEST", "${FOO}:")
self.assertEqual(self.d.getVar("TEST"), "foo:val")
def test_append(self):
self.d.setVar("TEST", "${VAL}")
self.d.appendVar("TEST", ":${BAR}")
self.assertEqual(self.d.getVar("TEST"), "val:bar")
def test_multiple_append(self):
self.d.setVar("TEST", "${VAL}")
self.d.prependVar("TEST", "${FOO}:")
self.d.appendVar("TEST", ":val2")
self.d.appendVar("TEST", ":${BAR}")
self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
class TestConcatOverride(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d.setVar("FOO", "foo")
self.d.setVar("VAL", "val")
self.d.setVar("BAR", "bar")
def test_prepend(self):
self.d.setVar("TEST", "${VAL}")
self.d.setVar("TEST_prepend", "${FOO}:")
self.assertEqual(self.d.getVar("TEST"), "foo:val")
def test_append(self):
self.d.setVar("TEST", "${VAL}")
self.d.setVar("TEST_append", ":${BAR}")
self.assertEqual(self.d.getVar("TEST"), "val:bar")
def test_multiple_append(self):
self.d.setVar("TEST", "${VAL}")
self.d.setVar("TEST_prepend", "${FOO}:")
self.d.setVar("TEST_append", ":val2")
self.d.setVar("TEST_append", ":${BAR}")
self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
def test_append_unset(self):
self.d.setVar("TEST_prepend", "${FOO}:")
self.d.setVar("TEST_append", ":val2")
self.d.setVar("TEST_append", ":${BAR}")
self.assertEqual(self.d.getVar("TEST"), "foo::val2:bar")
def test_remove(self):
self.d.setVar("TEST", "${VAL} ${BAR}")
self.d.setVar("TEST_remove", "val")
self.assertEqual(self.d.getVar("TEST"), " bar")
def test_remove_cleared(self):
self.d.setVar("TEST", "${VAL} ${BAR}")
self.d.setVar("TEST_remove", "val")
self.d.setVar("TEST", "${VAL} ${BAR}")
self.assertEqual(self.d.getVar("TEST"), "val bar")
# Ensure the value is unchanged if we have an inactive remove override
# (including that whitespace is preserved)
def test_remove_inactive_override(self):
self.d.setVar("TEST", "${VAL} ${BAR} 123")
self.d.setVar("TEST_remove_inactiveoverride", "val")
self.assertEqual(self.d.getVar("TEST"), "val bar 123")
def test_doubleref_remove(self):
self.d.setVar("TEST", "${VAL} ${BAR}")
self.d.setVar("TEST_remove", "val")
self.d.setVar("TEST_TEST", "${TEST} ${TEST}")
self.assertEqual(self.d.getVar("TEST_TEST"), " bar bar")
def test_empty_remove(self):
self.d.setVar("TEST", "")
self.d.setVar("TEST_remove", "val")
self.assertEqual(self.d.getVar("TEST"), "")
def test_remove_expansion(self):
self.d.setVar("BAR", "Z")
self.d.setVar("TEST", "${BAR}/X Y")
self.d.setVar("TEST_remove", "${BAR}/X")
self.assertEqual(self.d.getVar("TEST"), " Y")
def test_remove_expansion_items(self):
self.d.setVar("TEST", "A B C D")
self.d.setVar("BAR", "B D")
self.d.setVar("TEST_remove", "${BAR}")
self.assertEqual(self.d.getVar("TEST"), "A C ")
def test_remove_preserve_whitespace(self):
# When the removal isn't active, the original value should be preserved
self.d.setVar("TEST", " A B")
self.d.setVar("TEST_remove", "C")
self.assertEqual(self.d.getVar("TEST"), " A B")
def test_remove_preserve_whitespace2(self):
# When the removal is active preserve the whitespace
self.d.setVar("TEST", " A B")
self.d.setVar("TEST_remove", "B")
self.assertEqual(self.d.getVar("TEST"), " A ")
class TestOverrides(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d.setVar("OVERRIDES", "foo:bar:local")
self.d.setVar("TEST", "testvalue")
def test_no_override(self):
self.assertEqual(self.d.getVar("TEST"), "testvalue")
def test_one_override(self):
self.d.setVar("TEST_bar", "testvalue2")
self.assertEqual(self.d.getVar("TEST"), "testvalue2")
def test_one_override_unset(self):
self.d.setVar("TEST2_bar", "testvalue2")
self.assertEqual(self.d.getVar("TEST2"), "testvalue2")
self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST2', 'OVERRIDES', 'TEST2_bar'])
def test_multiple_override(self):
self.d.setVar("TEST_bar", "testvalue2")
self.d.setVar("TEST_local", "testvalue3")
self.d.setVar("TEST_foo", "testvalue4")
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST_foo', 'OVERRIDES', 'TEST_bar', 'TEST_local'])
def test_multiple_combined_overrides(self):
self.d.setVar("TEST_local_foo_bar", "testvalue3")
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
def test_multiple_overrides_unset(self):
self.d.setVar("TEST2_local_foo_bar", "testvalue3")
self.assertEqual(self.d.getVar("TEST2"), "testvalue3")
def test_keyexpansion_override(self):
self.d.setVar("LOCAL", "local")
self.d.setVar("TEST_bar", "testvalue2")
self.d.setVar("TEST_${LOCAL}", "testvalue3")
self.d.setVar("TEST_foo", "testvalue4")
bb.data.expandKeys(self.d)
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
def test_rename_override(self):
self.d.setVar("ALTERNATIVE_ncurses-tools_class-target", "a")
self.d.setVar("OVERRIDES", "class-target")
self.d.renameVar("ALTERNATIVE_ncurses-tools", "ALTERNATIVE_lib32-ncurses-tools")
self.assertEqual(self.d.getVar("ALTERNATIVE_lib32-ncurses-tools"), "a")
def test_underscore_override(self):
self.d.setVar("TEST_bar", "testvalue2")
self.d.setVar("TEST_some_val", "testvalue3")
self.d.setVar("TEST_foo", "testvalue4")
self.d.setVar("OVERRIDES", "foo:bar:some_val")
self.assertEqual(self.d.getVar("TEST"), "testvalue3")
def test_remove_with_override(self):
self.d.setVar("TEST_bar", "testvalue2")
self.d.setVar("TEST_some_val", "testvalue3 testvalue5")
self.d.setVar("TEST_some_val_remove", "testvalue3")
self.d.setVar("TEST_foo", "testvalue4")
self.d.setVar("OVERRIDES", "foo:bar:some_val")
self.assertEqual(self.d.getVar("TEST"), " testvalue5")
class TestKeyExpansion(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d.setVar("FOO", "foo")
self.d.setVar("BAR", "foo")
def test_keyexpand(self):
self.d.setVar("VAL_${FOO}", "A")
self.d.setVar("VAL_${BAR}", "B")
with LogRecord() as logs:
bb.data.expandKeys(self.d)
self.assertTrue(logContains("Variable key VAL_${FOO} (A) replaces original key VAL_foo (B)", logs))
self.assertEqual(self.d.getVar("VAL_foo"), "A")
class TestFlags(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d.setVar("foo", "value of foo")
self.d.setVarFlag("foo", "flag1", "value of flag1")
self.d.setVarFlag("foo", "flag2", "value of flag2")
def test_setflag(self):
self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
self.assertEqual(self.d.getVarFlag("foo", "flag2", False), "value of flag2")
def test_delflag(self):
self.d.delVarFlag("foo", "flag2")
self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
self.assertEqual(self.d.getVarFlag("foo", "flag2", False), None)
class Contains(unittest.TestCase):
def setUp(self):
self.d = bb.data.init()
self.d.setVar("SOMEFLAG", "a b c")
def test_contains(self):
self.assertTrue(bb.utils.contains("SOMEFLAG", "a", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "b", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "c", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "a b", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "b c", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "c a", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "a b c", True, False, self.d))
self.assertTrue(bb.utils.contains("SOMEFLAG", "c b a", True, False, self.d))
self.assertFalse(bb.utils.contains("SOMEFLAG", "x", True, False, self.d))
self.assertFalse(bb.utils.contains("SOMEFLAG", "a x", True, False, self.d))
self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b", True, False, self.d))
self.assertFalse(bb.utils.contains("SOMEFLAG", "x c b a", True, False, self.d))
def test_contains_any(self):
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a b", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "b c", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "c a", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "a x", True, False, self.d))
self.assertTrue(bb.utils.contains_any("SOMEFLAG", "x c", True, False, self.d))
self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x", True, False, self.d))
self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x y z", True, False, self.d))
class TaskHash(unittest.TestCase):
def test_taskhashes(self):
def gettask_bashhash(taskname, d):
tasklist, gendeps, lookupcache = bb.data.generate_dependencies(d)
taskdeps, basehash = bb.data.generate_dependency_hash(tasklist, gendeps, lookupcache, set(), "somefile")
bb.warn(str(lookupcache))
return basehash["somefile." + taskname]
d = bb.data.init()
d.setVar("__BBTASKS", ["mytask"])
d.setVar("__exportlist", [])
d.setVar("mytask", "${MYCOMMAND}")
d.setVar("MYCOMMAND", "${VAR}; foo; bar; exit 0")
d.setVar("VAR", "val")
orighash = gettask_bashhash("mytask", d)
# Changing a variable should change the hash
d.setVar("VAR", "val2")
nexthash = gettask_bashhash("mytask", d)
self.assertNotEqual(orighash, nexthash)
d.setVar("VAR", "val")
# Adding an inactive removal shouldn't change the hash
d.setVar("BAR", "notbar")
d.setVar("MYCOMMAND_remove", "${BAR}")
nexthash = gettask_bashhash("mytask", d)
self.assertEqual(orighash, nexthash)
# Adding an active removal should change the hash
d.setVar("BAR", "bar;")
nexthash = gettask_bashhash("mytask", d)
self.assertNotEqual(orighash, nexthash)
# Setup | |
# osid.resource.ResourceAdminSession.can_update_resources
return (self._can('update') or
bool(self._get_overriding_catalog_ids('update')))
@raise_null_argument
def get_qualifier_form_for_update(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceAdminSession.get_resource_form_for_update
if not self._can_for_qualifier('update', qualifier_id):
raise PermissionDenied()
return self._provider_session.get_qualifier_form_for_update(qualifier_id)
def duplicate_qualifier(self, qualifier_id):
if not self._can('update'):
raise PermissionDenied()
return self._provider_session.duplicate_qualifier(qualifier_id)
@raise_null_argument
def update_qualifier(self, qualifier_form):
# Implemented from azosid template for -
# osid.resource.ResourceAdminSession.update_resource
if not self._can('update'):
raise PermissionDenied()
return self._provider_session.update_qualifier(qualifier_form)
def can_delete_qualifiers(self):
# Implemented from azosid template for -
# osid.resource.ResourceAdminSession.can_delete_resources
return (self._can('delete') or
bool(self._get_overriding_catalog_ids('delete')))
@raise_null_argument
def delete_qualifier(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceAdminSession.delete_resource
if not self._can_for_qualifier('delete', qualifier_id):
raise PermissionDenied()
return self._provider_session.delete_qualifier(qualifier_id)
def can_manage_qualifier_aliases(self):
# Implemented from azosid template for -
# osid.resource.ResourceAdminSession.can_manage_resource_aliases
return (self._can('manage') or
bool(self._get_overriding_catalog_ids('manage')))
@raise_null_argument
def alias_qualifier(self, qualifier_id, alias_id):
# Implemented from azosid template for -
# osid.resource.ResourceAdminSession.alias_resources
if not self._can_for_qualifier('alias', qualifier_id):
raise PermissionDenied()
return self._provider_session.alias_qualifier(qualifier_id, alias_id)
class QualifierNotificationSession(abc_authorization_sessions.QualifierNotificationSession, osid_sessions.OsidSession):
"""Adapts underlying QualifierNotificationSession methodswith authorization checks."""
def __init__(self, *args, **kwargs):
osid_sessions.OsidSession.__init__(self, *args, **kwargs)
self._qualifier_id = self._provider_session.get_vault_id()
self._id_namespace = 'authorization.Qualifier'
def get_vault_id(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.get_bin_id_template
return self._provider_session.get_vault_id()
vault_id = property(fget=get_vault_id)
def get_vault(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.get_bin_template
if not self._can('lookup'):
raise PermissionDenied()
else:
return self._provider_session.get_vault()
vault = property(fget=get_vault)
def can_register_for_qualifier_notifications(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.can_register_for_resource_notifications
return self._can('register')
def use_federated_vault_view(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.use_federated_bin_view_template
self._use_federated_catalog_view()
self._provider_session.use_federated_vault_view()
if self._query_session:
self._query_session.use_federated_vault_view()
def use_isolated_vault_view(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.use_isolated_bin_view_template
self._use_isolated_catalog_view()
self._provider_session.use_isolated_vault_view()
if self._query_session:
self._query_session.use_isolated_vault_view()
def reliable_qualifier_notifications(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_new_resources
self._provider_session.reliable_qualifier_notifications()
def unreliable_qualifier_notifications(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_new_resources
self._provider_session.unreliable_qualifier_notifications()
@raise_null_argument
def acknowledge_qualifier_notification(self, notification_id):
raise Unimplemented()
def register_for_new_qualifiers(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_new_resources
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_new_qualifiers()
def register_for_changed_qualifiers(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_changed_resources
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_changed_qualifiers()
@raise_null_argument
def register_for_changed_qualifier(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_changed_resource
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_changed_qualifier(qualifier_id)
def register_for_deleted_qualifiers(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_deleted_resources
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_deleted_qualifiers()
@raise_null_argument
def register_for_deleted_qualifier(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_deleted_resource
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_deleted_qualifier(qualifier_id)
def register_for_changed_qualifier_hierarchy(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_changed_resources
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_changed_qualifier_hierarchy()
@raise_null_argument
def register_for_changed_qualifier_hierarchy_for_ancestors(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_changed_resource
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_changed_qualifier_hierarchy_for_ancestors(qualifier_id)
@raise_null_argument
def register_for_changed_qualifier_hierarchy_for_descendants(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_changed_resource
if not self._can('register'):
raise PermissionDenied()
self._provider_session.register_for_changed_qualifier_hierarchy_for_descendants(qualifier_id)
def reliable_qualifier_notifications(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_new_resources
self._provider_session.reliable_qualifier_notifications()
def unreliable_qualifier_notifications(self):
# Implemented from azosid template for -
# osid.resource.ResourceNotificationSession.register_for_new_resources
self._provider_session.unreliable_qualifier_notifications()
@raise_null_argument
def acknowledge_qualifier_notification(self, notification_id):
raise Unimplemented()
class QualifierHierarchySession(abc_authorization_sessions.QualifierHierarchySession, osid_sessions.OsidSession):
"""Adapts underlying QualifierHierarchySession methodswith authorization checks."""
def get_qualifier_hierarchy_id(self):
raise Unimplemented()
qualifier_hierarchy_id = property(fget=get_qualifier_hierarchy_id)
def get_qualifier_hierarchy(self):
raise Unimplemented()
qualifier_hierarchy = property(fget=get_qualifier_hierarchy)
def can_access_qualifier_hierarchy(self):
raise Unimplemented()
def use_comparative_qualifier_view(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.use_comparative_resource_view_template
self._use_comparative_object_view()
self._provider_session.use_comparative_qualifier_view()
def use_plenary_qualifier_view(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.use_plenary_resource_view_template
self._use_plenary_object_view()
self._provider_session.use_plenary_qualifier_view()
def get_root_qualifier_ids(self):
raise Unimplemented()
root_qualifier_ids = property(fget=get_root_qualifier_ids)
def get_root_qualifiers(self):
# From azosid_templates/ontology.py::SubjectHierarchySession::get_root_subjects_template
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_root_qualifiers()
root_qualifiers = property(fget=get_root_qualifiers)
@raise_null_argument
def has_parent_qualifiers(self, qualifier_id):
raise Unimplemented()
@raise_null_argument
def is_parent_of_qualifier(self, id_, qualifier_id):
raise Unimplemented()
@raise_null_argument
def get_parent_qualifier_ids(self, qualifier_id):
raise Unimplemented()
@raise_null_argument
def get_parent_qualifiers(self, qualifier_id):
raise Unimplemented()
@raise_null_argument
def is_ancestor_of_qualifier(self, id_, qualifier_id):
raise Unimplemented()
@raise_null_argument
def has_child_qualifiers(self, qualifier_id):
raise Unimplemented()
@raise_null_argument
def is_child_of_qualifier(self, id_, qualifier_id):
raise Unimplemented()
@raise_null_argument
def get_child_qualifier_ids(self, qualifier_id):
raise Unimplemented()
@raise_null_argument
def get_child_qualifiers(self, qualifier_id):
# From azosid_templates/ontology.py::SubjectHierarchySession::get_child_subjects_template
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_child_qualifiers(qualifier_id)
@raise_null_argument
def is_descendant_of_qualifier(self, id_, qualifier_id):
raise Unimplemented()
@raise_null_argument
def get_qualifier_node_ids(self, qualifier_id, ancestor_levels, descendant_levels, include_siblings):
raise Unimplemented()
@raise_null_argument
def get_qualifier_nodes(self, qualifier_id, ancestor_levels, descendant_levels, include_siblings):
raise Unimplemented()
class QualifierHierarchyDesignSession(abc_authorization_sessions.QualifierHierarchyDesignSession, osid_sessions.OsidSession):
"""Adapts underlying QualifierHierarchyDesignSession methodswith authorization checks."""
def get_qualifier_hierarchy_id(self):
raise Unimplemented()
qualifier_hierarchy_id = property(fget=get_qualifier_hierarchy_id)
def get_qualifier_hierarchy(self):
raise Unimplemented()
qualifier_hierarchy = property(fget=get_qualifier_hierarchy)
def can_modify_qualifier_hierarchy(self):
# From azosid_templates/ontology.py::SubjectHierarchyDesignSession::can_modify_subject_hierarchy_template
return self._can('modify')
@raise_null_argument
def add_root_qualifier(self, qualifier_id):
# From azosid_templates/ontology.py::SubjectHierarchyDesignSession::add_root_subject_template
if not self._can('modify'):
raise PermissionDenied()
return self._provider_session.add_root_qualifier(qualifier_id)
@raise_null_argument
def remove_root_qualifier(self, qualifier_id):
# From azosid_templates/ontology.py::SubjectHierarchyDesignSession::remove_root_subject_template
if not self._can('modify'):
raise PermissionDenied()
return self._provider_session.remove_root_qualifier(qualifier_id)
@raise_null_argument
def add_child_qualifier(self, qualifier_id, child_id):
# From azosid_templates/ontology.py::SubjectHierarchyDesignSession::add_child_subject_template
if not self._can('modify'):
raise PermissionDenied()
return self._provider_session.add_child_qualifier(qualifier_id, child_id)
@raise_null_argument
def remove_child_qualifier(self, qualifier_id, child_id):
# From azosid_templates/ontology.py::SubjectHierarchyDesignSession::remove_child_subject_template
if not self._can('modify'):
raise PermissionDenied()
return self._provider_session.remove_child_qualifier(qualifier_id, child_id)
@raise_null_argument
def remove_child_qualifiers(self, qualifier_id):
# From azosid_templates/ontology.py::SubjectHierarchyDesignSession::remove_child_subjects_template
if not self._can('modify'):
raise PermissionDenied()
return self._provider_session.remove_child_qualifiers(qualifier_id)
class QualifierVaultSession(abc_authorization_sessions.QualifierVaultSession, osid_sessions.OsidSession):
"""Adapts underlying QualifierVaultSession methodswith authorization checks."""
def __init__(self, *args, **kwargs):
osid_sessions.OsidSession.__init__(self, *args, **kwargs)
self._qualifier_id = Id('authorization.Vault%3AROOT%40ODL.MIT.EDU') # This could be better
self._id_namespace = 'authorization.QualifierVault'
def can_lookup_qualifier_vault_mappings(self):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.can_lookup_resource_bin_mappings
return self._can('lookup')
def use_comparative_vault_view(self):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.use_comparative_bin_view_template
self._provider_session.use_comparative_vault_view()
def use_plenary_vault_view(self):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.use_plenary_bin_view_template
self._provider_session.use_plenary_vault_view()
@raise_null_argument
def get_qualifier_ids_by_vault(self, vault_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.get_resource_ids_by_bin
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_qualifier_ids_by_vault(vault_id)
@raise_null_argument
def get_qualifiers_by_vault(self, vault_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.get_resources_by_bin_template
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_qualifiers_by_vault(vault_id)
@raise_null_argument
def get_qualifier_ids_by_vaults(self, vault_ids):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.get_resource_ids_by_bins
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_qualifier_ids_by_vaults(vault_ids)
@raise_null_argument
def get_qualifiers_by_vaults(self, vault_ids):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.get_resources_by_bins
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_qualifiers_by_vaults(vault_ids)
@raise_null_argument
def get_vault_ids_by_qualifier(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.get_bin_ids_by_resource
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_vault_ids_by_qualifier(qualifier_id)
@raise_null_argument
def get_vaults_by_qualifier(self, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinSession.get_bins_by_resource
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_vaults_by_qualifier(qualifier_id)
class QualifierVaultAssignmentSession(abc_authorization_sessions.QualifierVaultAssignmentSession, osid_sessions.OsidSession):
"""Adapts underlying QualifierVaultAssignmentSession methodswith authorization checks."""
def __init__(self, *args, **kwargs):
osid_sessions.OsidSession.__init__(self, *args, **kwargs)
self._qualifier_id = Id('authorization.Vault%3AROOT%40ODL.MIT.EDU') # This could be better
self._id_namespace = 'authorization.QualifierVault'
def can_assign_qualifiers(self):
# Implemented from azosid template for -
# osid.resource.ResourceBinAssignmentSession.can_assign_resources
return self._can('assign')
@raise_null_argument
def can_assign_qualifiers_to_vault(self, vault_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinAssignmentSession.can_assign_resources_to_bin
return self._can('assign', qualifier_id=vault_id)
@raise_null_argument
def get_assignable_vault_ids(self, vault_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinAssignmentSession.get_assignable_bin_ids
if not self._can('assign'):
raise PermissionDenied()
return self._provider_session.get_assignable_vault_ids(vault_id)
@raise_null_argument
def get_assignable_vault_ids_for_qualifier(self, vault_id, qualifier_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinAssignmentSession.get_assignable_bin_ids_for_resource
if not self._can('assign'):
raise PermissionDenied()
return self._provider_session.get_assignable_vault_ids_for_qualifier(vault_id, qualifier_id)
@raise_null_argument
def assign_qualifier_to_vault(self, qualifier_id, vault_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinAssignmentSession.assign_resource_to_bin
if not self._can('assign'):
raise PermissionDenied()
return self._provider_session.assign_qualifier_to_vault(qualifier_id, vault_id)
@raise_null_argument
def unassign_qualifier_from_vault(self, qualifier_id, vault_id):
# Implemented from azosid template for -
# osid.resource.ResourceBinAssignmentSession.assign_resource_to_bin
if not self._can('assign'):
raise PermissionDenied()
return self._provider_session.unassign_qualifier_from_vault(qualifier_id, vault_id)
@raise_null_argument
def reassign_qualifier_to_vault(self, qualifier_id, from_vault_id, to_vault_id):
raise Unimplemented()
class QualifierSmartVaultSession(abc_authorization_sessions.QualifierSmartVaultSession, osid_sessions.OsidSession):
"""Adapts underlying QualifierSmartVaultSession methodswith authorization checks."""
def get_vault_id(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.get_bin_id_template
return self._provider_session.get_vault_id()
vault_id = property(fget=get_vault_id)
def get_vault(self):
# Implemented from azosid template for -
# osid.resource.ResourceLookupSession.get_bin_template
if not self._can('lookup'):
raise PermissionDenied()
else:
return self._provider_session.get_vault()
vault = property(fget=get_vault)
def can_manage_smart_vaults(self):
raise Unimplemented()
def get_qualifier_query(self):
raise Unimplemented()
qualifier_query = property(fget=get_qualifier_query)
def get_qualifier_search_order(self):
raise Unimplemented()
qualifier_search_order = property(fget=get_qualifier_search_order)
@raise_null_argument
def apply_qualifier_query(self, qualifier_query):
raise Unimplemented()
def inspect_qualifier_query(self):
raise Unimplemented()
@raise_null_argument
def apply_qualifier_sequencing(self, qualifier_search_order):
raise Unimplemented()
@raise_null_argument
def get_qualifier_query_from_inspector(self, qualifier_query_inspector):
raise Unimplemented()
class VaultLookupSession(abc_authorization_sessions.VaultLookupSession, osid_sessions.OsidSession):
"""Adapts underlying VaultLookupSession methodswith authorization checks."""
def __init__(self, *args, **kwargs):
osid_sessions.OsidSession.__init__(self, *args, **kwargs)
# This needs to be done right
# Build from authority in config
self._qualifier_id = Id('authorization.Vault%3AROOT%40ODL.MIT.EDU')
self._id_namespace = 'authorization.Vault'
def can_lookup_vaults(self):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.can_lookup_bins_template
return self._can('lookup')
def use_comparative_vault_view(self):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.use_comparative_bin_view_template
self._provider_session.use_comparative_vault_view()
def use_plenary_vault_view(self):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.use_plenary_bin_view_template
self._provider_session.use_plenary_vault_view()
@raise_null_argument
def get_vault(self, vault_id):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.get_bin_template
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_vault(vault_id)
@raise_null_argument
def get_vaults_by_ids(self, vault_ids):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.get_bins_by_ids_template
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_vaults_by_ids(vault_ids)
@raise_null_argument
def get_vaults_by_genus_type(self, vault_genus_type):
if not self._can('lookup'):
raise PermissionDenied()
return self._provider_session.get_vaults_by_genus_type(vault_genus_type)
@raise_null_argument
def get_vaults_by_parent_genus_type(self, vault_genus_type):
raise Unimplemented()
@raise_null_argument
def get_vaults_by_record_type(self, vault_record_type):
raise Unimplemented()
@raise_null_argument
def get_vaults_by_provider(self, resource_id):
raise Unimplemented()
def get_vaults(self):
# Implemented from azosid template for -
# osid.resource.BinLookupSession.get_bins_template
if not self._can('lookup'):
raise PermissionDenied()
| |
<reponame>kazoup/boto
# Copyright (c) 2012 Amazon.com, Inc. or its affiliates. All Rights Reserved
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish, dis-
# tribute, sublicense, and/or sell copies of the Software, and to permit
# persons to whom the Software is furnished to do so, subject to the fol-
# lowing conditions:
#
# The above copyright notice and this permission notice shall be included
# in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABIL-
# ITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
# SHALL THE AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
import copy
import pickle
import os
from tests.compat import unittest, mock
from tests.unit import MockServiceWithConfigTestCase
from boto.auth import HmacAuthV4Handler
from boto.auth import S3HmacAuthV4Handler
from boto.auth import detect_potential_s3sigv4
from boto.auth import detect_potential_sigv4
from boto.connection import HTTPRequest
from boto.provider import Provider
from boto.regioninfo import RegionInfo
class TestSigV4Handler(unittest.TestCase):
def setUp(self):
self.provider = mock.Mock()
self.provider.access_key = 'access_key'
self.provider.secret_key = 'secret_key'
self.request = HTTPRequest(
'POST', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'/-/vaults/foo/archives', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
def test_not_adding_empty_qs(self):
self.provider.security_token = None
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com', mock.Mock(), self.provider)
req = copy.copy(self.request)
auth.add_auth(req)
self.assertEqual(req.path, '/-/vaults/foo/archives')
def test_inner_whitespace_is_collapsed(self):
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
self.request.headers['x-amz-archive-description'] = 'two spaces'
self.request.headers['x-amz-quoted-string'] = ' "a b c" '
headers = auth.headers_to_sign(self.request)
self.assertEqual(headers, {'Host': 'glacier.us-east-1.amazonaws.com',
'x-amz-archive-description': 'two spaces',
'x-amz-glacier-version': '2012-06-01',
'x-amz-quoted-string': ' "a b c" '})
# Note the single space between the "two spaces".
self.assertEqual(auth.canonical_headers(headers),
'host:glacier.us-east-1.amazonaws.com\n'
'x-amz-archive-description:two spaces\n'
'x-amz-glacier-version:2012-06-01\n'
'x-amz-quoted-string:"a b c"')
def test_canonical_query_string(self):
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'/-/vaults/foo/archives', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
request.params['Foo.1'] = 'aaa'
request.params['Foo.10'] = 'zzz'
query_string = auth.canonical_query_string(request)
self.assertEqual(query_string, 'Foo.1=aaa&Foo.10=zzz')
def test_query_string(self):
auth = HmacAuthV4Handler('sns.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
params = {
'Message': u'We \u2665 utf-8'.encode('utf-8'),
}
request = HTTPRequest(
'POST', 'https', 'sns.us-east-1.amazonaws.com', 443,
'/', None, params, {}, '')
query_string = auth.query_string(request)
self.assertEqual(query_string, 'Message=We%20%E2%99%A5%20utf-8')
def test_canonical_uri(self):
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'x/./././x .html', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
canonical_uri = auth.canonical_uri(request)
# This should be both normalized & urlencoded.
self.assertEqual(canonical_uri, 'x/x%20.html')
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'x/./././x/html/', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
canonical_uri = auth.canonical_uri(request)
# Trailing slashes should be preserved.
self.assertEqual(canonical_uri, 'x/x/html/')
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'/', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
canonical_uri = auth.canonical_uri(request)
# There should not be two-slashes.
self.assertEqual(canonical_uri, '/')
# Make sure Windows-style slashes are converted properly
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'\\x\\x.html', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
canonical_uri = auth.canonical_uri(request)
self.assertEqual(canonical_uri, '/x/x.html')
def test_credential_scope(self):
# test the AWS standard regions IAM endpoint
auth = HmacAuthV4Handler('iam.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'POST', 'https', 'iam.amazonaws.com', 443,
'/', '/',
{'Action': 'ListAccountAliases', 'Version': '2010-05-08'},
{
'Content-Length': '44',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Amz-Date': '20130808T013210Z'
},
'Action=ListAccountAliases&Version=2010-05-08')
credential_scope = auth.credential_scope(request)
region_name = credential_scope.split('/')[1]
self.assertEqual(region_name, 'us-east-1')
# test the AWS GovCloud region IAM endpoint
auth = HmacAuthV4Handler('iam.us-gov.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'POST', 'https', 'iam.us-gov.amazonaws.com', 443,
'/', '/',
{'Action': 'ListAccountAliases', 'Version': '2010-05-08'},
{
'Content-Length': '44',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Amz-Date': '20130808T013210Z'
},
'Action=ListAccountAliases&Version=2010-05-08')
credential_scope = auth.credential_scope(request)
region_name = credential_scope.split('/')[1]
self.assertEqual(region_name, 'us-gov-west-1')
# iam.us-west-1.amazonaws.com does not exist however this
# covers the remaining region_name control structure for a
# different region name
auth = HmacAuthV4Handler('iam.us-west-1.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'POST', 'https', 'iam.us-west-1.amazonaws.com', 443,
'/', '/',
{'Action': 'ListAccountAliases', 'Version': '2010-05-08'},
{
'Content-Length': '44',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Amz-Date': '20130808T013210Z'
},
'Action=ListAccountAliases&Version=2010-05-08')
credential_scope = auth.credential_scope(request)
region_name = credential_scope.split('/')[1]
self.assertEqual(region_name, 'us-west-1')
# Test connections to custom locations, e.g. localhost:8080
auth = HmacAuthV4Handler('localhost', mock.Mock(), self.provider,
service_name='iam')
request = HTTPRequest(
'POST', 'http', 'localhost', 8080,
'/', '/',
{'Action': 'ListAccountAliases', 'Version': '2010-05-08'},
{
'Content-Length': '44',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Amz-Date': '20130808T013210Z'
},
'Action=ListAccountAliases&Version=2010-05-08')
credential_scope = auth.credential_scope(request)
timestamp, region, service, v = credential_scope.split('/')
self.assertEqual(region, 'localhost')
self.assertEqual(service, 'iam')
def test_headers_to_sign(self):
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'GET', 'http', 'glacier.us-east-1.amazonaws.com', 80,
'x/./././x .html', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
headers = auth.headers_to_sign(request)
# Port 80 & not secure excludes the port.
self.assertEqual(headers['Host'], 'glacier.us-east-1.amazonaws.com')
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 443,
'x/./././x .html', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
headers = auth.headers_to_sign(request)
# SSL port excludes the port.
self.assertEqual(headers['Host'], 'glacier.us-east-1.amazonaws.com')
request = HTTPRequest(
'GET', 'https', 'glacier.us-east-1.amazonaws.com', 8080,
'x/./././x .html', None, {},
{'x-amz-glacier-version': '2012-06-01'}, '')
headers = auth.headers_to_sign(request)
# URL should include port.
self.assertEqual(headers['Host'], 'glacier.us-east-1.amazonaws.com:8080')
def test_region_and_service_can_be_overriden(self):
auth = HmacAuthV4Handler('queue.amazonaws.com',
mock.Mock(), self.provider)
self.request.headers['X-Amz-Date'] = '20121121000000'
auth.region_name = 'us-west-2'
auth.service_name = 'sqs'
scope = auth.credential_scope(self.request)
self.assertEqual(scope, '20121121/us-west-2/sqs/aws4_request')
def test_pickle_works(self):
provider = Provider('aws', access_key='access_key',
secret_key='secret_key')
auth = HmacAuthV4Handler('queue.amazonaws.com', None, provider)
# Pickle it!
pickled = pickle.dumps(auth)
# Now restore it
auth2 = pickle.loads(pickled)
self.assertEqual(auth.host, auth2.host)
def test_bytes_header(self):
auth = HmacAuthV4Handler('glacier.us-east-1.amazonaws.com',
mock.Mock(), self.provider)
request = HTTPRequest(
'GET', 'http', 'glacier.us-east-1.amazonaws.com', 80,
'x/./././x .html', None, {},
{'x-amz-glacier-version': '2012-06-01', 'x-amz-hash': b'f00'}, '')
canonical = auth.canonical_request(request)
self.assertIn('f00', canonical)
class TestS3HmacAuthV4Handler(unittest.TestCase):
def setUp(self):
self.provider = mock.Mock()
self.provider.access_key = 'access_key'
self.provider.secret_key = 'secret_key'
self.provider.security_token = '<PASSWORD>'
self.request = HTTPRequest(
'GET', 'https', 's3-us-west-2.amazonaws.com', 443,
'/awesome-bucket/?max-keys=0', None, {},
{}, ''
)
self.awesome_bucket_request = HTTPRequest(
method='GET',
protocol='https',
host='awesome-bucket.s3-us-west-2.amazonaws.com',
port=443,
path='/',
auth_path=None,
params={
'max-keys': 0,
},
headers={
'User-Agent': 'Boto',
'X-AMZ-Content-sha256': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
'X-AMZ-Date': '20130605T193245Z',
},
body=''
)
self.auth = S3HmacAuthV4Handler(
host='awesome-bucket.s3-us-west-2.amazonaws.com',
config=mock.Mock(),
provider=self.provider,
region_name='s3-us-west-2'
)
def test_clean_region_name(self):
# Untouched.
cleaned = self.auth.clean_region_name('us-west-2')
self.assertEqual(cleaned, 'us-west-2')
# Stripped of the ``s3-`` prefix.
cleaned = self.auth.clean_region_name('s3-us-west-2')
self.assertEqual(cleaned, 'us-west-2')
# Untouched (classic).
cleaned = self.auth.clean_region_name('s3.amazonaws.com')
self.assertEqual(cleaned, 's3.amazonaws.com')
# Untouched.
cleaned = self.auth.clean_region_name('something-s3-us-west-2')
self.assertEqual(cleaned, 'something-s3-us-west-2')
def test_region_stripping(self):
auth = S3HmacAuthV4Handler(
host='s3-us-west-2.amazonaws.com',
config=mock.Mock(),
provider=self.provider
)
self.assertEqual(auth.region_name, None)
# What we wish we got.
auth = S3HmacAuthV4Handler(
host='s3-us-west-2.amazonaws.com',
config=mock.Mock(),
provider=self.provider,
region_name='us-west-2'
)
self.assertEqual(auth.region_name, 'us-west-2')
# What we actually get (i.e. ``s3-us-west-2``).
self.assertEqual(self.auth.region_name, 'us-west-2')
def test_determine_region_name(self):
name = self.auth.determine_region_name('s3-us-west-2.amazonaws.com')
self.assertEqual(name, 'us-west-2')
def test_canonical_uri(self):
request = HTTPRequest(
'GET', 'https', 's3-us-west-2.amazonaws.com', 443,
'x/./././x .html', None, {},
{}, ''
)
canonical_uri = self.auth.canonical_uri(request)
# S3 doesn't canonicalize the way other SigV4 services do.
# This just urlencoded, no normalization of the path.
self.assertEqual(canonical_uri, 'x/./././x%20.html')
def test_determine_service_name(self):
# What we wish we got.
name = self.auth.determine_service_name(
's3.us-west-2.amazonaws.com'
)
self.assertEqual(name, 's3')
# What we actually get.
name = self.auth.determine_service_name(
's3-us-west-2.amazonaws.com'
)
self.assertEqual(name, 's3')
# What we wish we got with virtual hosting.
name = self.auth.determine_service_name(
'bucket.s3.us-west-2.amazonaws.com'
)
self.assertEqual(name, 's3')
# What we actually get with virtual hosting.
name = self.auth.determine_service_name(
'bucket.s3-us-west-2.amazonaws.com'
)
self.assertEqual(name, 's3')
def test_add_auth(self):
# The side-effects sideshow.
self.assertFalse('x-amz-content-sha256' in self.request.headers)
self.auth.add_auth(self.request)
self.assertTrue('x-amz-content-sha256' in self.request.headers)
the_sha = self.request.headers['x-amz-content-sha256']
self.assertEqual(
the_sha,
'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
)
def test_host_header(self):
host = self.auth.host_header(
self.awesome_bucket_request.host,
self.awesome_bucket_request
)
self.assertEqual(host, 'awesome-bucket.s3-us-west-2.amazonaws.com')
def test_canonical_query_string(self):
qs = self.auth.canonical_query_string(self.awesome_bucket_request)
self.assertEqual(qs, 'max-keys=0')
def test_correct_handling_of_plus_sign(self):
request = HTTPRequest(
'GET', 'https', 's3-us-west-2.amazonaws.com', 443,
'hello+world.txt', None, {},
{}, ''
)
canonical_uri = self.auth.canonical_uri(request)
# Ensure that things are properly quoted.
self.assertEqual(canonical_uri, 'hello%2Bworld.txt')
request = HTTPRequest(
'GET', 'https', 's3-us-west-2.amazonaws.com', 443,
'hello%2Bworld.txt', None, {},
{}, ''
)
canonical_uri = self.auth.canonical_uri(request)
# Verify double escaping hasn't occurred.
self.assertEqual(canonical_uri, 'hello%2Bworld.txt')
def test_mangle_path_and_params(self):
request = HTTPRequest(
method='GET',
protocol='https',
host='awesome-bucket.s3-us-west-2.amazonaws.com',
port=443,
# LOOK AT THIS PATH. JUST LOOK AT IT.
path='/?delete&max-keys=0',
auth_path=None,
params={
'key': 'why hello there',
# This gets overwritten, to make sure back-compat is maintained.
'max-keys': 1,
},
headers={
'User-Agent': 'Boto',
'X-AMZ-Content-sha256': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
'X-AMZ-Date': '20130605T193245Z',
},
body=''
)
mod_req = self.auth.mangle_path_and_params(request)
self.assertEqual(mod_req.path, '/?delete&max-keys=0')
self.assertEqual(mod_req.auth_path, '/')
self.assertEqual(mod_req.params, {
'max-keys': '0',
'key': 'why hello there',
'delete': ''
})
def test_canonical_request(self):
expected = """GET
/
max-keys=0
host:awesome-bucket.s3-us-west-2.amazonaws.com
user-agent:Boto
x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
x-amz-date:20130605T193245Z
host;user-agent;x-amz-content-sha256;x-amz-date
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"""
authed_req = self.auth.canonical_request(self.awesome_bucket_request)
self.assertEqual(authed_req, expected)
# Now the way ``boto.s3`` actually sends data.
request = copy.copy(self.awesome_bucket_request)
request.path = request.auth_path = '/?max-keys=0'
request.params = {}
expected = """GET
/
max-keys=0
host:awesome-bucket.s3-us-west-2.amazonaws.com
user-agent:Boto
x-amz-content-sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
x-amz-date:20130605T193245Z
host;user-agent;x-amz-content-sha256;x-amz-date
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"""
# Pre-mangle it. In practice, this happens as part of ``add_auth``,
# but that's a side-effect that's hard to test.
request = self.auth.mangle_path_and_params(request)
authed_req = self.auth.canonical_request(request)
self.assertEqual(authed_req, expected)
def | |
. target_eid , I11i1i1i1iii . rloc , to_etr = True )
if 60 - 60: I1ii11iIi11i * iII111i / OoOoOO00 . o0oOOo0O0Ooo / iIii1I11I1II1
return ( [ ooOOOo0o0oo . eid , ooOOOo0o0oo . group , LISP_DDT_ACTION_MS_ACK ] )
if 94 - 94: OoO0O00 . ooOoO0o
if 25 - 25: I1Ii111 % OOooOOo
if 82 - 82: Ii1I
if 17 - 17: iII111i . i1IIi . i1IIi
if 76 - 76: OoooooooOO % IiII
if 81 - 81: iII111i . OOooOOo * i1IIi
if 14 - 14: oO0o
def lisp_ddt_process_map_request ( lisp_sockets , map_request , ecm_source , port ) :
if 16 - 16: iII111i
if 26 - 26: iII111i . oO0o * i11iIiiIii . iIii1I11I1II1
if 74 - 74: Ii1I / iIii1I11I1II1 + OOooOOo . II111iiii
if 65 - 65: OOooOOo * I11i * Oo0Ooo
o00oo00oo = map_request . target_eid
ii1I1 = map_request . target_group
oOoo0OooOOo00 = lisp_print_eid_tuple ( o00oo00oo , ii1I1 )
iI1III = map_request . nonce
oo0oOOo0 = LISP_DDT_ACTION_NULL
if 21 - 21: Ii1I . iIii1I11I1II1
if 84 - 84: OOooOOo
if 67 - 67: I1IiiI % OoO0O00 % o0oOOo0O0Ooo % IiII
if 33 - 33: ooOoO0o % I1IiiI
if 98 - 98: oO0o . o0oOOo0O0Ooo + II111iiii
O0oooOO0O = None
if ( lisp_i_am_ms ) :
ooOOOo0o0oo = lisp_site_eid_lookup ( o00oo00oo , ii1I1 , False )
if ( ooOOOo0o0oo == None ) : return
if 70 - 70: oO0o % OoooooooOO * I1IiiI - OoOoOO00 * OoOoOO00 . OOooOOo
if ( ooOOOo0o0oo . registered ) :
oo0oOOo0 = LISP_DDT_ACTION_MS_ACK
oooOooOO = 1440
else :
o00oo00oo , ii1I1 , oo0oOOo0 = lisp_ms_compute_neg_prefix ( o00oo00oo , ii1I1 )
oo0oOOo0 = LISP_DDT_ACTION_MS_NOT_REG
oooOooOO = 1
if 9 - 9: iII111i * Oo0Ooo % iII111i % Oo0Ooo * II111iiii
else :
O0oooOO0O = lisp_ddt_cache_lookup ( o00oo00oo , ii1I1 , False )
if ( O0oooOO0O == None ) :
oo0oOOo0 = LISP_DDT_ACTION_NOT_AUTH
oooOooOO = 0
lprint ( "DDT delegation entry not found for EID {}" . format ( green ( oOoo0OooOOo00 , False ) ) )
if 71 - 71: II111iiii + I1ii11iIi11i * II111iiii
elif ( O0oooOO0O . is_auth_prefix ( ) ) :
if 59 - 59: OoO0O00
if 81 - 81: i11iIiiIii
if 57 - 57: Oo0Ooo * iIii1I11I1II1 - OoOoOO00 % iII111i % I1ii11iIi11i + Ii1I
if 82 - 82: IiII * Oo0Ooo - iIii1I11I1II1 - i11iIiiIii
oo0oOOo0 = LISP_DDT_ACTION_DELEGATION_HOLE
oooOooOO = 15
oO0 = O0oooOO0O . print_eid_tuple ( )
lprint ( ( "DDT delegation entry not found but auth-prefix {} " + "found for EID {}" ) . format ( oO0 ,
# OoO0O00 / OoO0O00 . I1ii11iIi11i
green ( oOoo0OooOOo00 , False ) ) )
if 100 - 100: iIii1I11I1II1 % II111iiii - I1ii11iIi11i . iIii1I11I1II1 + IiII % iIii1I11I1II1
if ( ii1I1 . is_null ( ) ) :
o00oo00oo = lisp_ddt_compute_neg_prefix ( o00oo00oo , O0oooOO0O ,
lisp_ddt_cache )
else :
ii1I1 = lisp_ddt_compute_neg_prefix ( ii1I1 , O0oooOO0O ,
lisp_ddt_cache )
o00oo00oo = lisp_ddt_compute_neg_prefix ( o00oo00oo , O0oooOO0O ,
O0oooOO0O . source_cache )
if 48 - 48: Ii1I % i1IIi
O0oooOO0O = None
else :
oO0 = O0oooOO0O . print_eid_tuple ( )
lprint ( "DDT delegation entry {} found for EID {}" . format ( oO0 , green ( oOoo0OooOOo00 , False ) ) )
if 38 - 38: OOooOOo / I1ii11iIi11i % oO0o / o0oOOo0O0Ooo
oooOooOO = 1440
if 54 - 54: OoOoOO00 * OoooooooOO - OoO0O00 * OoOoOO00 % I1ii11iIi11i * I11i
if 34 - 34: I11i - oO0o + I11i * OoooooooOO * I11i
if 73 - 73: OOooOOo * iII111i * OoO0O00
if 11 - 11: I1Ii111 * II111iiii
if 3 - 3: Oo0Ooo * OOooOOo
if 13 - 13: I1Ii111 + i11iIiiIii / OOooOOo
i1II1IiiIi = lisp_build_map_referral ( o00oo00oo , ii1I1 , O0oooOO0O , oo0oOOo0 , oooOooOO , iI1III )
iI1III = map_request . nonce >> 32
if ( map_request . nonce != 0 and iI1III != 0xdfdf0e1d ) : port = LISP_CTRL_PORT
lisp_send_map_referral ( lisp_sockets , i1II1IiiIi , ecm_source , port )
return
if 98 - 98: I1IiiI * Oo0Ooo
if 9 - 9: O0 / i11iIiiIii . iIii1I11I1II1 . IiII
if 14 - 14: OoOoOO00 . OOooOOo - Oo0Ooo + I1Ii111 % ooOoO0o
if 95 - 95: OoO0O00 * II111iiii + i1IIi
if 22 - 22: Ii1I / ooOoO0o % I11i + OoO0O00 . ooOoO0o
if 61 - 61: O0 - iIii1I11I1II1 * Oo0Ooo . Ii1I + O0
if 20 - 20: ooOoO0o / ooOoO0o - Ii1I - ooOoO0o
if 93 - 93: O0 * OoOoOO00 * iIii1I11I1II1
if 3 - 3: I1ii11iIi11i - O0
if 46 - 46: iII111i
if 99 - 99: oO0o
if 85 - 85: I1Ii111 * iIii1I11I1II1 . OoOoOO00
if 20 - 20: I11i * O0 - OoooooooOO * OOooOOo % oO0o * iII111i
def lisp_find_negative_mask_len ( eid , entry_prefix , neg_prefix ) :
O0oooo = eid . hash_address ( entry_prefix )
o0oO0ooOOoOo = eid . addr_length ( ) * 8
iI1iiII1iii111 = 0
if 24 - 24: I1IiiI
if 63 - 63: I11i - iIii1I11I1II1 * Ii1I + OoooooooOO . i11iIiiIii
if 94 - 94: OoO0O00 . oO0o . OoOoOO00 * i11iIiiIii
if 96 - 96: i1IIi . OoO0O00 . OoO0O00 - o0oOOo0O0Ooo - Ii1I
for iI1iiII1iii111 in range ( o0oO0ooOOoOo ) :
I1IIiI = 1 << ( o0oO0ooOOoOo - iI1iiII1iii111 - 1 )
if ( O0oooo & I1IIiI ) : break
if 30 - 30: I1Ii111 + oO0o + iIii1I11I1II1 % OoO0O00 / I1IiiI
if 55 - 55: Ii1I
if ( iI1iiII1iii111 > neg_prefix . mask_len ) : neg_prefix . mask_len = iI1iiII1iii111
return
if 14 - 14: i1IIi * I1ii11iIi11i
if 77 - 77: ooOoO0o . II111iiii
if 41 - 41: IiII
if 27 - 27: IiII / IiII
if 91 - 91: Ii1I
if 93 - 93: OoO0O00 * OoO0O00 * I1ii11iIi11i * OoO0O00 * o0oOOo0O0Ooo
if 84 - 84: I1Ii111 * OoO0O00 - ooOoO0o - Oo0Ooo . OoO0O00 % oO0o
if 98 - 98: OoO0O00 . i1IIi
if 58 - 58: i1IIi * O0 + I1ii11iIi11i . IiII
if 11 - 11: OOooOOo + iIii1I11I1II1 - ooOoO0o * OoO0O00 * i11iIiiIii
def lisp_neg_prefix_walk ( entry , parms ) :
o00oo00oo , iIIiIII , O0oo00000o00 = parms
if 78 - 78: Oo0Ooo
if ( iIIiIII == None ) :
if ( entry . eid . instance_id != o00oo00oo . instance_id ) :
return ( [ True , parms ] )
if 90 - 90: OoooooooOO * i11iIiiIii / OoOoOO00 % I1ii11iIi11i - iIii1I11I1II1 % i1IIi
if ( entry . eid . afi != o00oo00oo . afi ) : return ( [ True , parms ] )
else :
if ( entry . eid . is_more_specific ( iIIiIII ) == False ) :
return ( [ True , parms ] )
if 71 - 71: Oo0Ooo % i11iIiiIii
if 54 - 54: IiII . iII111i * OOooOOo / ooOoO0o . i11iIiiIii
if 91 - 91: ooOoO0o % iII111i
if 41 - 41: o0oOOo0O0Ooo . I1Ii111 + IiII / oO0o
if 86 - 86: iII111i % OoOoOO00 . i11iIiiIii . I1Ii111 + II111iiii . i1IIi
if 88 - 88: O0
lisp_find_negative_mask_len ( o00oo00oo , entry . eid , O0oo00000o00 )
return ( [ True , parms ] )
if 28 - 28: OOooOOo % IiII * Oo0Ooo / OoO0O00
if 67 - 67: Oo0Ooo * I11i - IiII + I1Ii111
if 90 - 90: iII111i % II111iiii % o0oOOo0O0Ooo + o0oOOo0O0Ooo + II111iiii
if 54 - 54: OoooooooOO . IiII - oO0o
if 26 - 26: o0oOOo0O0Ooo - i1IIi / I1ii11iIi11i / OoooooooOO . i1IIi
if 22 - 22: o0oOOo0O0Ooo * I1Ii111 * I1ii11iIi11i . OoOoOO00 . i1IIi % ooOoO0o
if 67 - 67: I11i
if 95 - 95: OoO0O00 % I1Ii111
def lisp_ddt_compute_neg_prefix ( eid , ddt_entry | |
['id'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_folder" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if ('id' not in local_var_params or
local_var_params['id'] is None):
raise ApiValueError("Missing the required parameter `id` when calling `get_folder`") # noqa: E501
if ('id' in local_var_params and
len(local_var_params['id']) > 40):
raise ApiValueError("Invalid value for parameter `id` when calling `get_folder`, length must be less than or equal to `40`") # noqa: E501
if ('id' in local_var_params and
len(local_var_params['id']) < 30):
raise ApiValueError("Invalid value for parameter `id` when calling `get_folder`, length must be greater than or equal to `30`") # noqa: E501
if 'id' in local_var_params and not re.search(r'^[a-zA-Z0-9\-]+$', local_var_params['id']): # noqa: E501
raise ApiValueError("Invalid value for parameter `id` when calling `get_folder`, must conform to the pattern `/^[a-zA-Z0-9\-]+$/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
query_params = []
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['text/plain', 'application/json', 'text/json']) # noqa: E501
# Authentication setting
auth_settings = ['oauth2'] # noqa: E501
# set the LUSID header
header_params['X-LUSID-SDK-Language'] = 'Python'
header_params['X-LUSID-SDK-Version'] = '0.1.185'
return self.api_client.call_api(
'/api/folders/{id}', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='StorageObject', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_folder_contents(self, id, **kwargs): # noqa: E501
"""[BETA] List contents of a folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_folder_contents(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: Unique ID of the folder (required)
:param str page: The pagination token to use to continue listing contents from a previous call to list contents. This value is returned from the previous call. If a pagination token is provided the sortBy and filter fields must not have changed since the original request. Also, if set, a start value cannot be provided.
:param list[str] sort_by: Order the results by these fields. Use use the '-' sign to denote descending order.
:param int start: When paginating, skip this number of results.
:param int limit: When paginating, limit the number of returned results to this many.
:param str filter: Expression to filter the result set.
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: PagedResourceListOfStorageObject
If the method is called asynchronously,
returns the request thread.
"""
kwargs['_return_http_data_only'] = True
return self.get_folder_contents_with_http_info(id, **kwargs) # noqa: E501
def get_folder_contents_with_http_info(self, id, **kwargs): # noqa: E501
"""[BETA] List contents of a folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_folder_contents_with_http_info(id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str id: Unique ID of the folder (required)
:param str page: The pagination token to use to continue listing contents from a previous call to list contents. This value is returned from the previous call. If a pagination token is provided the sortBy and filter fields must not have changed since the original request. Also, if set, a start value cannot be provided.
:param list[str] sort_by: Order the results by these fields. Use use the '-' sign to denote descending order.
:param int start: When paginating, skip this number of results.
:param int limit: When paginating, limit the number of returned results to this many.
:param str filter: Expression to filter the result set.
:param _return_http_data_only: response data without head status code
and headers
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(PagedResourceListOfStorageObject, status_code(int), headers(HTTPHeaderDict))
If the method is called asynchronously,
returns the request thread.
"""
local_var_params = locals()
all_params = ['id', 'page', 'sort_by', 'start', 'limit', 'filter'] # noqa: E501
all_params.append('async_req')
all_params.append('_return_http_data_only')
all_params.append('_preload_content')
all_params.append('_request_timeout')
for key, val in six.iteritems(local_var_params['kwargs']):
if key not in all_params:
raise ApiTypeError(
"Got an unexpected keyword argument '%s'"
" to method get_folder_contents" % key
)
local_var_params[key] = val
del local_var_params['kwargs']
# verify the required parameter 'id' is set
if ('id' not in local_var_params or
local_var_params['id'] is None):
raise ApiValueError("Missing the required parameter `id` when calling `get_folder_contents`") # noqa: E501
if ('id' in local_var_params and
len(local_var_params['id']) > 40):
raise ApiValueError("Invalid value for parameter `id` when calling `get_folder_contents`, length must be less than or equal to `40`") # noqa: E501
if ('id' in local_var_params and
len(local_var_params['id']) < 30):
raise ApiValueError("Invalid value for parameter `id` when calling `get_folder_contents`, length must be greater than or equal to `30`") # noqa: E501
if 'id' in local_var_params and not re.search(r'^[a-zA-Z0-9\-]+$', local_var_params['id']): # noqa: E501
raise ApiValueError("Invalid value for parameter `id` when calling `get_folder_contents`, must conform to the pattern `/^[a-zA-Z0-9\-]+$/`") # noqa: E501
if ('page' in local_var_params and
len(local_var_params['page']) > 200):
raise ApiValueError("Invalid value for parameter `page` when calling `get_folder_contents`, length must be less than or equal to `200`") # noqa: E501
if ('page' in local_var_params and
len(local_var_params['page']) < 1):
raise ApiValueError("Invalid value for parameter `page` when calling `get_folder_contents`, length must be greater than or equal to `1`") # noqa: E501
if 'page' in local_var_params and not re.search(r'^[a-zA-Z0-9\+\/]*={0,3}$', local_var_params['page']): # noqa: E501
raise ApiValueError("Invalid value for parameter `page` when calling `get_folder_contents`, must conform to the pattern `/^[a-zA-Z0-9\+\/]*={0,3}$/`") # noqa: E501
if ('filter' in local_var_params and
len(local_var_params['filter']) > 2147483647):
raise ApiValueError("Invalid value for parameter `filter` when calling `get_folder_contents`, length must be less than or equal to `2147483647`") # noqa: E501
if ('filter' in local_var_params and
len(local_var_params['filter']) < 0):
raise ApiValueError("Invalid value for parameter `filter` when calling `get_folder_contents`, length must be greater than or equal to `0`") # noqa: E501
if 'filter' in local_var_params and not re.search(r'(?s).*', local_var_params['filter']): # noqa: E501
raise ApiValueError("Invalid value for parameter `filter` when calling `get_folder_contents`, must conform to the pattern `/(?s).*/`") # noqa: E501
collection_formats = {}
path_params = {}
if 'id' in local_var_params:
path_params['id'] = local_var_params['id'] # noqa: E501
query_params = []
if 'page' in local_var_params:
query_params.append(('page', local_var_params['page'])) # noqa: E501
if 'sort_by' in local_var_params:
query_params.append(('sortBy', local_var_params['sort_by'])) # noqa: E501
collection_formats['sortBy'] = 'multi' # noqa: E501
if 'start' in local_var_params:
query_params.append(('start', local_var_params['start'])) # noqa: E501
if 'limit' in local_var_params:
query_params.append(('limit', local_var_params['limit'])) # noqa: E501
if 'filter' in local_var_params:
query_params.append(('filter', local_var_params['filter'])) # noqa: E501
header_params = {}
form_params = []
local_var_files = {}
body_params = None
# HTTP header `Accept`
header_params['Accept'] = self.api_client.select_header_accept(
['text/plain', 'application/json', 'text/json']) # noqa: E501
# Authentication setting
auth_settings = ['oauth2'] # noqa: E501
# set the LUSID header
header_params['X-LUSID-SDK-Language'] = 'Python'
header_params['X-LUSID-SDK-Version'] = '0.1.185'
return self.api_client.call_api(
'/api/folders/{id}/contents', 'GET',
path_params,
query_params,
header_params,
body=body_params,
post_params=form_params,
files=local_var_files,
response_type='PagedResourceListOfStorageObject', # noqa: E501
auth_settings=auth_settings,
async_req=local_var_params.get('async_req'),
_return_http_data_only=local_var_params.get('_return_http_data_only'), # noqa: E501
_preload_content=local_var_params.get('_preload_content', True),
_request_timeout=local_var_params.get('_request_timeout'),
collection_formats=collection_formats)
def get_root_folder(self, **kwargs): # noqa: E501
"""[BETA] List contents of root folder # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_root_folder(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str page: The pagination token to use to continue listing contents from a previous call to list contents. This value is returned from the previous call. If a pagination token is provided the sortBy and filter fields must not have changed since the original request. Also, if set, | |
3932, 3721, 4910, 5801, 6580, 5195, 3551, 5907, 3221, 3471, 3029, 6019, 3999,
5908, 5909, 5266, 5267, 3444, 3023, 3828, 3170, 4796, 5646, 4979, 4259, 6356, 5647, 5337, 3694,
6357, 5648, 5338, 4520, 4322, 5802, 3031, 3759, 4071, 6020, 5586, 4836, 4386, 5048, 6581, 3571,
4679, 4174, 4949, 6154, 4813, 3787, 3402, 3822, 3958, 3215, 3552, 5268, 4387, 3933, 4950, 4359,
6021, 5910, 5075, 3579, 6358, 4234, 4566, 5521, 6359, 3613, 5049, 6022, 5911, 3375, 3702, 3178,
4911, 5339, 4521, 6582, 6583, 4395, 3087, 3811, 5377, 6023, 6360, 6155, 4027, 5171, 5649, 4421,
4249, 2804, 6584, 2270, 6585, 4000, 4235, 3045, 6156, 5137, 5729, 4140, 4312, 3886, 6361, 4330,
6157, 4215, 6158, 3500, 3676, 4929, 4331, 3713, 4930, 5912, 4265, 3776, 3368, 5587, 4470, 4855,
3038, 4980, 3631, 6159, 6160, 4132, 4680, 6161, 6362, 3923, 4379, 5588, 4255, 6586, 4121, 6587,
6363, 4649, 6364, 3288, 4773, 4774, 6162, 6024, 6365, 3543, 6588, 4274, 3107, 3737, 5050, 5803,
4797, 4522, 5589, 5051, 5730, 3714, 4887, 5378, 4001, 4523, 6163, 5026, 5522, 4701, 4175, 2791,
3760, 6589, 5473, 4224, 4133, 3847, 4814, 4815, 4775, 3259, 5416, 6590, 2738, 6164, 6025, 5304,
3733, 5076, 5650, 4816, 5590, 6591, 6165, 6592, 3934, 5269, 6593, 3396, 5340, 6594, 5804, 3445,
3602, 4042, 4488, 5731, 5732, 3525, 5591, 4601, 5196, 6166, 6026, 5172, 3642, 4612, 3202, 4506,
4798, 6366, 3818, 5108, 4303, 5138, 5139, 4776, 3332, 4304, 2915, 3415, 4434, 5077, 5109, 4856,
2879, 5305, 4817, 6595, 5913, 3104, 3144, 3903, 4634, 5341, 3133, 5110, 5651, 5805, 6167, 4057,
5592, 2945, 4371, 5593, 6596, 3474, 4182, 6367, 6597, 6168, 4507, 4279, 6598, 2822, 6599, 4777,
4713, 5594, 3829, 6169, 3887, 5417, 6170, 3653, 5474, 6368, 4216, 2971, 5228, 3790, 4579, 6369,
5733, 6600, 6601, 4951, 4746, 4555, 6602, 5418, 5475, 6027, 3400, 4665, 5806, 6171, 4799, 6028,
5052, 6172, 3343, 4800, 4747, 5006, 6370, 4556, 4217, 5476, 4396, 5229, 5379, 5477, 3839, 5914,
5652, 5807, 4714, 3068, 4635, 5808, 6173, 5342, 4192, 5078, 5419, 5523, 5734, 6174, 4557, 6175,
4602, 6371, 6176, 6603, 5809, 6372, 5735, 4260, 3869, 5111, 5230, 6029, 5112, 6177, 3126, 4681,
5524, 5915, 2706, 3563, 4748, 3130, 6178, 4018, 5525, 6604, 6605, 5478, 4012, 4837, 6606, 4534,
4193, 5810, 4857, 3615, 5479, 6030, 4082, 3697, 3539, 4086, 5270, 3662, 4508, 4931, 5916, 4912,
5811, 5027, 3888, 6607, 4397, 3527, 3302, 3798, 2775, 2921, 2637, 3966, 4122, 4388, 4028, 4054,
1633, 4858, 5079, 3024, 5007, 3982, 3412, 5736, 6608, 3426, 3236, 5595, 3030, 6179, 3427, 3336,
3279, 3110, 6373, 3874, 3039, 5080, 5917, 5140, 4489, 3119, 6374, 5812, 3405, 4494, 6031, 4666,
4141, 6180, 4166, 6032, 5813, 4981, 6609, 5081, 4422, 4982, 4112, 3915, 5653, 3296, 3983, 6375,
4266, 4410, 5654, 6610, 6181, 3436, 5082, 6611, 5380, 6033, 3819, 5596, 4535, 5231, 5306, 5113,
6612, 4952, 5918, 4275, 3113, 6613, 6376, 6182, 6183, 5814, 3073, 4731, 4838, 5008, 3831, 6614,
4888, 3090, 3848, 4280, 5526, 5232, 3014, 5655, 5009, 5737, 5420, 5527, 6615, 5815, 5343, 5173,
5381, 4818, 6616, 3151, 4953, 6617, 5738, 2796, 3204, 4360, 2989, 4281, 5739, 5174, 5421, 5197,
3132, 5141, 3849, 5142, 5528, 5083, 3799, 3904, 4839, 5480, 2880, 4495, 3448, 6377, 6184, 5271,
5919, 3771, 3193, 6034, 6035, 5920, 5010, 6036, 5597, 6037, 6378, 6038, 3106, 5422, 6618, 5423,
5424, 4142, 6619, 4889, 5084, 4890, 4313, 5740, 6620, 3437, 5175, 5307, 5816, 4199, 5198, 5529,
5817, 5199, 5656, 4913, 5028, 5344, 3850, 6185, 2955, 5272, 5011, 5818, 4567, 4580, 5029, 5921,
3616, 5233, 6621, 6622, 6186, 4176, 6039, 6379, 6380, 3352, 5200, 5273, 2908, 5598, 5234, 3837,
5308, 6623, 6624, 5819, 4496, 4323, 5309, 5201, 6625, 6626, 4983, 3194, 3838, 4167, 5530, 5922,
5274, 6381, 6382, 3860, 3861, 5599, 3333, 4292, 4509, 6383, 3553, 5481, 5820, 5531, 4778, 6187,
3955, 3956, 4324, 4389, 4218, 3945, 4325, 3397, 2681, 5923, 4779, 5085, 4019, 5482, 4891, 5382,
5383, 6040, 4682, 3425, 5275, 4094, 6627, 5310, 3015, 5483, 5657, 4398, 5924, 3168, 4819, 6628,
5925, 6629, 5532, 4932, 4613, 6041, 6630, 4636, 6384, 4780, 4204, 5658, 4423, 5821, 3989, 4683,
5822, 6385, 4954, 6631, 5345, 6188, 5425, 5012, 5384, 3894, 6386, 4490, 4104, 6632, 5741, 5053,
6633, 5823, 5926, 5659, 5660, 5927, 6634, 5235, 5742, 5824, 4840, 4933, 4820, 6387, 4859, 5928,
4955, 6388, 4143, 3584, 5825, 5346, 5013, 6635, 5661, 6389, 5014, 5484, 5743, 4337, 5176, 5662,
6390, 2836, 6391, 3268, 6392, 6636, 6042, 5236, 6637, 4158, 6638, 5744, 5663, 4471, 5347, 3663,
4123, 5143, 4293, 3895, 6639, 6640, 5311, 5929, 5826, 3800, 6189, 6393, 6190, 5664, 5348, 3554,
3594, 4749, 4603, 6641, 5385, 4801, 6043, 5827, 4183, 6642, 5312, 5426, 4761, 6394, 5665, 6191,
4715, 2669, 6643, 6644, 5533, 3185, 5427, 5086, 5930, 5931, 5386, 6192, 6044, 6645, 4781, 4013,
5745, 4282, 4435, 5534, 4390, 4267, 6045, 5746, 4984, 6046, 2743, 6193, 3501, 4087, 5485, 5932,
5428, 4184, 4095, 5747, 4061, 5054, 3058, 3862, 5933, 5600, 6646, 5144, 3618, 6395, 3131, 5055,
5313, 6396, 4650, 4956, 3855, 6194, 3896, 5202, 4985, 4029, 4225, 6195, 6647, 5828, 5486, 5829,
3589, 3002, 6648, 6397, 4782, 5276, 6649, 6196, 6650, 4105, 3803, 4043, 5237, 5830, 6398, 4096,
3643, 6399, 3528, 6651, 4453, 3315, 4637, 6652, 3984, 6197, 5535, 3182, 3339, 6653, 3096, 2660,
6400, 6654, 3449, 5934, 4250, 4236, 6047, 6401, 5831, 6655, 5487, 3753, 4062, 5832, 6198, 6199,
6656, 3766, 6657, 3403, 4667, 6048, 6658, 4338, 2897, 5833, 3880, 2797, 3780, 4326, 6659, 5748,
5015, 6660, 5387, 4351, 5601, 4411, 6661, 3654, 4424, 5935, 4339, 4072, 5277, 4568, 5536, 6402,
6662, 5238, 6663, 5349, 5203, 6200, 5204, 6201, 5145, 4536, 5016, 5056, 4762, 5834, 4399, 4957,
6202, 6403, 5666, 5749, 6664, 4340, 6665, 5936, 5177, 5667, 6666, 6667, 3459, 4668, 6404, 6668,
6669, 4543, 6203, 6670, 4276, 6405, 4480, 5537, 6671, 4614, 5205, 5668, 6672, 3348, 2193, 4763,
6406, 6204, 5937, 5602, 4177, 5669, 3419, 6673, 4020, 6205, 4443, 4569, 5388, 3715, 3639, 6407,
6049, 4058, 6206, 6674, 5938, 4544, 6050, 4185, 4294, 4841, 4651, 4615, 5488, 6207, 6408, 6051,
5178, 3241, 3509, 5835, 6208, 4958, 5836, 4341, 5489, 5278, 6209, 2823, 5538, 5350, 5206, 5429,
6675, 4638, 4875, 4073, 3516, 4684, 4914, 4860, 5939, 5603, 5389, 6052, 5057, 3237, 5490, 3791,
6676, 6409, 6677, 4821, 4915, 4106, 5351, 5058, 4243, 5539, 4244, 5604, 4842, 4916, 5239, 3028,
3716, 5837, 5114, 5605, 5390, 5940, 5430, 6210, 4332, 6678, 5540, 4732, 3667, 3840, 6053, 4305,
3408, 5670, 5541, 6410, 2744, 5240, 5750, 6679, 3234, 5606, 6680, 5607, 5671, 3608, 4283, 4159,
4400, 5352, 4783, 6681, 6411, 6682, 4491, 4802, 6211, 6412, 5941, 6413, 6414, 5542, 5751, 6683,
4669, 3734, 5942, 6684, 6415, 5943, 5059, 3328, 4670, 4144, 4268, 6685, 6686, 6687, 6688, 4372,
3603, 6689, 5944, 5491, 4373, 3440, 6416, 5543, 4784, 4822, 5608, 3792, 4616, 5838, 5672, 3514,
5391, 6417, 4892, 6690, 4639, 6691, 6054, 5673, 5839, 6055, 6692, 6056, 5392, 6212, 4038, 5544,
5674, 4497, 6057, 6693, 5840, 4284, 5675, 4021, 4545, 5609, 6418, 4454, 6419, 6213, 4113, 4472,
5314, 3738, 5087, 5279, 4074, 5610, 4959, 4063, 3179, 4750, 6058, 6420, 6214, 3476, 4498, 4716,
5431, 4960, 4685, 6215, 5241, 6694, 6421, 6216, 6695, 5841, 5945, 6422, 3748, 5946, 5179, 3905,
5752, 5545, 5947, 4374, 6217, 4455, 6423, 4412, 6218, 4803, 5353, 6696, 3832, 5280, 6219, 4327,
4702, 6220, 6221, 6059, 4652, 5432, 6424, 3749, 4751, 6425, 5753, 4986, 5393, 4917, 5948, 5030,
5754, 4861, 4733, 6426, 4703, 6697, 6222, 4671, 5949, 4546, 4961, 5180, 6223, 5031, 3316, 5281,
6698, 4862, 4295, 4934, 5207, 3644, 6427, 5842, 5950, 6428, 6429, 4570, 5843, 5282, 6430, 6224,
5088, 3239, 6060, 6699, 5844, 5755, 6061, 6431, 2701, 5546, 6432, 5115, 5676, 4039, 3993, 3327,
4752, 4425, 5315, 6433, 3941, 6434, 5677, 4617, 4604, 3074, 4581, 6225, 5433, 6435, 6226, 6062,
4823, 5756, 5116, | |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from . import outputs
from ._enums import *
from ._inputs import *
__all__ = ['MigratingVmArgs', 'MigratingVm']
@pulumi.input_type
class MigratingVmArgs:
def __init__(__self__, *,
migrating_vm_id: pulumi.Input[str],
source_id: pulumi.Input[str],
compute_engine_target_defaults: Optional[pulumi.Input['ComputeEngineTargetDefaultsArgs']] = None,
description: Optional[pulumi.Input[str]] = None,
display_name: Optional[pulumi.Input[str]] = None,
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
location: Optional[pulumi.Input[str]] = None,
policy: Optional[pulumi.Input['SchedulePolicyArgs']] = None,
project: Optional[pulumi.Input[str]] = None,
request_id: Optional[pulumi.Input[str]] = None,
source_vm_id: Optional[pulumi.Input[str]] = None):
"""
The set of arguments for constructing a MigratingVm resource.
:param pulumi.Input['ComputeEngineTargetDefaultsArgs'] compute_engine_target_defaults: Details of the target VM in Compute Engine.
:param pulumi.Input[str] description: The description attached to the migrating VM by the user.
:param pulumi.Input[str] display_name: The display name attached to the MigratingVm by the user.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The labels of the migrating VM.
:param pulumi.Input['SchedulePolicyArgs'] policy: The replication schedule policy.
:param pulumi.Input[str] source_vm_id: The unique ID of the VM in the source. The VM's name in vSphere can be changed, so this is not the VM's name but rather its moRef id. This id is of the form vm-.
"""
pulumi.set(__self__, "migrating_vm_id", migrating_vm_id)
pulumi.set(__self__, "source_id", source_id)
if compute_engine_target_defaults is not None:
pulumi.set(__self__, "compute_engine_target_defaults", compute_engine_target_defaults)
if description is not None:
pulumi.set(__self__, "description", description)
if display_name is not None:
pulumi.set(__self__, "display_name", display_name)
if labels is not None:
pulumi.set(__self__, "labels", labels)
if location is not None:
pulumi.set(__self__, "location", location)
if policy is not None:
pulumi.set(__self__, "policy", policy)
if project is not None:
pulumi.set(__self__, "project", project)
if request_id is not None:
pulumi.set(__self__, "request_id", request_id)
if source_vm_id is not None:
pulumi.set(__self__, "source_vm_id", source_vm_id)
@property
@pulumi.getter(name="migratingVmId")
def migrating_vm_id(self) -> pulumi.Input[str]:
return pulumi.get(self, "migrating_vm_id")
@migrating_vm_id.setter
def migrating_vm_id(self, value: pulumi.Input[str]):
pulumi.set(self, "migrating_vm_id", value)
@property
@pulumi.getter(name="sourceId")
def source_id(self) -> pulumi.Input[str]:
return pulumi.get(self, "source_id")
@source_id.setter
def source_id(self, value: pulumi.Input[str]):
pulumi.set(self, "source_id", value)
@property
@pulumi.getter(name="computeEngineTargetDefaults")
def compute_engine_target_defaults(self) -> Optional[pulumi.Input['ComputeEngineTargetDefaultsArgs']]:
"""
Details of the target VM in Compute Engine.
"""
return pulumi.get(self, "compute_engine_target_defaults")
@compute_engine_target_defaults.setter
def compute_engine_target_defaults(self, value: Optional[pulumi.Input['ComputeEngineTargetDefaultsArgs']]):
pulumi.set(self, "compute_engine_target_defaults", value)
@property
@pulumi.getter
def description(self) -> Optional[pulumi.Input[str]]:
"""
The description attached to the migrating VM by the user.
"""
return pulumi.get(self, "description")
@description.setter
def description(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "description", value)
@property
@pulumi.getter(name="displayName")
def display_name(self) -> Optional[pulumi.Input[str]]:
"""
The display name attached to the MigratingVm by the user.
"""
return pulumi.get(self, "display_name")
@display_name.setter
def display_name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "display_name", value)
@property
@pulumi.getter
def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
"""
The labels of the migrating VM.
"""
return pulumi.get(self, "labels")
@labels.setter
def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
pulumi.set(self, "labels", value)
@property
@pulumi.getter
def location(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "location")
@location.setter
def location(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "location", value)
@property
@pulumi.getter
def policy(self) -> Optional[pulumi.Input['SchedulePolicyArgs']]:
"""
The replication schedule policy.
"""
return pulumi.get(self, "policy")
@policy.setter
def policy(self, value: Optional[pulumi.Input['SchedulePolicyArgs']]):
pulumi.set(self, "policy", value)
@property
@pulumi.getter
def project(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "project")
@project.setter
def project(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "project", value)
@property
@pulumi.getter(name="requestId")
def request_id(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "request_id")
@request_id.setter
def request_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "request_id", value)
@property
@pulumi.getter(name="sourceVmId")
def source_vm_id(self) -> Optional[pulumi.Input[str]]:
"""
The unique ID of the VM in the source. The VM's name in vSphere can be changed, so this is not the VM's name but rather its moRef id. This id is of the form vm-.
"""
return pulumi.get(self, "source_vm_id")
@source_vm_id.setter
def source_vm_id(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "source_vm_id", value)
class MigratingVm(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
compute_engine_target_defaults: Optional[pulumi.Input[pulumi.InputType['ComputeEngineTargetDefaultsArgs']]] = None,
description: Optional[pulumi.Input[str]] = None,
display_name: Optional[pulumi.Input[str]] = None,
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
location: Optional[pulumi.Input[str]] = None,
migrating_vm_id: Optional[pulumi.Input[str]] = None,
policy: Optional[pulumi.Input[pulumi.InputType['SchedulePolicyArgs']]] = None,
project: Optional[pulumi.Input[str]] = None,
request_id: Optional[pulumi.Input[str]] = None,
source_id: Optional[pulumi.Input[str]] = None,
source_vm_id: Optional[pulumi.Input[str]] = None,
__props__=None):
"""
Creates a new MigratingVm in a given Source.
Auto-naming is currently not supported for this resource.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[pulumi.InputType['ComputeEngineTargetDefaultsArgs']] compute_engine_target_defaults: Details of the target VM in Compute Engine.
:param pulumi.Input[str] description: The description attached to the migrating VM by the user.
:param pulumi.Input[str] display_name: The display name attached to the MigratingVm by the user.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The labels of the migrating VM.
:param pulumi.Input[pulumi.InputType['SchedulePolicyArgs']] policy: The replication schedule policy.
:param pulumi.Input[str] source_vm_id: The unique ID of the VM in the source. The VM's name in vSphere can be changed, so this is not the VM's name but rather its moRef id. This id is of the form vm-.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: MigratingVmArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Creates a new MigratingVm in a given Source.
Auto-naming is currently not supported for this resource.
:param str resource_name: The name of the resource.
:param MigratingVmArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def __init__(__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(MigratingVmArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
compute_engine_target_defaults: Optional[pulumi.Input[pulumi.InputType['ComputeEngineTargetDefaultsArgs']]] = None,
description: Optional[pulumi.Input[str]] = None,
display_name: Optional[pulumi.Input[str]] = None,
labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
location: Optional[pulumi.Input[str]] = None,
migrating_vm_id: Optional[pulumi.Input[str]] = None,
policy: Optional[pulumi.Input[pulumi.InputType['SchedulePolicyArgs']]] = None,
project: Optional[pulumi.Input[str]] = None,
request_id: Optional[pulumi.Input[str]] = None,
source_id: Optional[pulumi.Input[str]] = None,
source_vm_id: Optional[pulumi.Input[str]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = MigratingVmArgs.__new__(MigratingVmArgs)
__props__.__dict__["compute_engine_target_defaults"] = compute_engine_target_defaults
__props__.__dict__["description"] = description
__props__.__dict__["display_name"] = display_name
__props__.__dict__["labels"] = labels
__props__.__dict__["location"] = location
if migrating_vm_id is None and not opts.urn:
raise TypeError("Missing required property 'migrating_vm_id'")
__props__.__dict__["migrating_vm_id"] = migrating_vm_id
__props__.__dict__["policy"] = policy
__props__.__dict__["project"] = project
__props__.__dict__["request_id"] = request_id
if source_id is None and not opts.urn:
raise TypeError("Missing required property 'source_id'")
__props__.__dict__["source_id"] = source_id
__props__.__dict__["source_vm_id"] = source_vm_id
__props__.__dict__["create_time"] = None
__props__.__dict__["current_sync_info"] = None
__props__.__dict__["error"] = None
__props__.__dict__["group"] = None
__props__.__dict__["last_sync"] = None
__props__.__dict__["name"] = None
__props__.__dict__["recent_clone_jobs"] = None
__props__.__dict__["recent_cutover_jobs"] = None
__props__.__dict__["state"] = None
__props__.__dict__["state_time"] = None
__props__.__dict__["update_time"] = None
super(MigratingVm, __self__).__init__(
'google-native:vmmigration/v1alpha1:MigratingVm',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'MigratingVm':
"""
Get an existing MigratingVm resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = MigratingVmArgs.__new__(MigratingVmArgs)
__props__.__dict__["compute_engine_target_defaults"] = None
__props__.__dict__["create_time"] = None
__props__.__dict__["current_sync_info"] = None
__props__.__dict__["description"] = None
__props__.__dict__["display_name"] = None
__props__.__dict__["error"] = None
__props__.__dict__["group"] = None
__props__.__dict__["labels"] = None
__props__.__dict__["last_sync"] = None
__props__.__dict__["name"] = None
__props__.__dict__["policy"] = None
__props__.__dict__["recent_clone_jobs"] = None
__props__.__dict__["recent_cutover_jobs"] = None
__props__.__dict__["source_vm_id"] = None
__props__.__dict__["state"] = None
__props__.__dict__["state_time"] = None
__props__.__dict__["update_time"] = None
return MigratingVm(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="computeEngineTargetDefaults")
def compute_engine_target_defaults(self) -> pulumi.Output['outputs.ComputeEngineTargetDefaultsResponse']:
"""
Details of the target VM in Compute Engine.
"""
return pulumi.get(self, "compute_engine_target_defaults")
@property
@pulumi.getter(name="createTime")
def create_time(self) -> pulumi.Output[str]:
"""
The time the migrating VM was created (this refers to this resource and not to the time it was installed in the source).
"""
return pulumi.get(self, "create_time")
@property
@pulumi.getter(name="currentSyncInfo")
def current_sync_info(self) -> pulumi.Output['outputs.ReplicationCycleResponse']:
"""
The percentage progress of the current running replication cycle.
"""
return pulumi.get(self, "current_sync_info")
@property
@pulumi.getter
def description(self) -> pulumi.Output[str]:
"""
The description attached to the migrating VM by the user.
"""
return pulumi.get(self, "description")
@property
@pulumi.getter(name="displayName")
def display_name(self) -> pulumi.Output[str]:
"""
The display name attached to the MigratingVm by the user.
"""
return pulumi.get(self, "display_name")
@property
@pulumi.getter
def error(self) -> pulumi.Output['outputs.StatusResponse']:
"""
Provides details on | |
<filename>regraph/category_op.py
"""Category operations used by graph rewriting tool."""
import networkx as nx
import copy
from regraph.primitives import (add_node,
add_edge,
set_edge,
add_node_attrs,
get_edge,
add_edge_attrs,
clone_node,
merge_nodes,
update_node_attrs,
remove_node,
remove_edge,
remove_node_attrs,
remove_edge_attrs,
unique_node_id,
subtract,
print_graph)
from regraph.utils import (keys_by_value,
merge_attributes,
restrict_mapping,
dict_sub,
id_of,
valid_attributes,
attrs_intersection)
from regraph.exceptions import (InvalidHomomorphism, ReGraphError)
def subgraph(graph, nodes):
"""Get a subgraph induced by a set nodes.
:param graph:
:param nodes:
:return:
"""
subgraph = copy.deepcopy(graph)
for node in graph.nodes():
if node not in nodes:
remove_node(subgraph, node)
return subgraph
def compose(d1, d2):
"""Compose two homomorphisms given by dicts."""
res = dict()
for key, value in d1.items():
if value in d2.keys():
res[key] = d2[value]
return res
def is_total_homomorphism(elements, mapping):
"""Return True if mapping is total."""
return set(elements) == set(mapping.keys())
def check_totality(elements, dictionary):
"""Check that a mapping is total."""
if set(elements) != set(dictionary.keys()):
raise InvalidHomomorphism(
"Invalid homomorphism: Mapping is not "
"covering all the nodes of source graph! "
"domain: {}, domain of definition: {}"
.format(set(elements), set(dictionary.keys())))
def check_homomorphism(source, target, dictionary, total=True):
"""Check if the homomorphism is valid.
Valid homomorphism preserves edges,
and attributes if requires.
"""
# check if there is mapping for all the nodes of source graph
if total:
check_totality(source.nodes(), dictionary)
if not set(dictionary.values()).issubset(target.nodes()):
raise InvalidHomomorphism(
"Some of the image nodes in mapping %s do not "
"exist in target graph (target graph nodes %s) "
"namely %s" %
(dictionary.values(),
target.nodes(),
set(dictionary.values()) - set(target.nodes()))
)
# check connectivity
for s, t in source.edges():
try:
if (s in dictionary.keys() and
t in dictionary.keys() and
not (dictionary[s], dictionary[t])
in target.edges()):
if not target.is_directed():
if not (dictionary[t], dictionary[s]) in target.edges():
raise InvalidHomomorphism(
"Connectivity is not preserved!"
" Was expecting an edge '%s' and '%s'" %
(dictionary[t], dictionary[s]))
else:
raise InvalidHomomorphism(
"Connectivity is not preserved!"
" Was expecting an edge between '%s' and '%s'" %
(dictionary[s], dictionary[t]))
except KeyError:
pass
for s, t in dictionary.items():
# check sets of attributes of nodes (here homomorphism = set
# inclusion)
if not valid_attributes(source.node[s], target.node[t]):
raise InvalidHomomorphism(
"Attributes of nodes source:'%s' %s and "
"target:'%s' %s do not match!" %
(s, source.node[s], t, target.node[t])
)
# check sets of attributes of edges (homomorphism = set inclusion)
for s1, s2 in source.edges():
try:
if (s1 in dictionary.keys() and s2 in dictionary.keys() and
not valid_attributes(
source.edge[s1][s2],
target.edge[dictionary[s1]][dictionary[s2]])):
raise InvalidHomomorphism(
"Attributes of edges (%s)-(%s) (%s) and "
"(%s)-(%s) (%s) do not match!" %
(s1, s2, source.edge[s1][s2], dictionary[s1],
dictionary[s2],
target.edge[dictionary[s1]][dictionary[s2]]))
except KeyError:
pass
return True
def compose_chain(chain):
"""Compose a chain of homomorphisms."""
homomorphism = chain[0]
for i in range(1, len(chain)):
homomorphism = compose(
homomorphism,
chain[i]
)
return homomorphism
def get_unique_map_to_pullback(p, p_a, p_b, z_a, z_b):
"""Find a unique map to pullback."""
z_p = dict()
for value in p:
z_keys_from_a = set()
if value in p_a.keys():
a_value = p_a[value]
z_keys_from_a = set(keys_by_value(z_a, a_value))
z_keys_from_b = set()
if value in p_b.keys():
b_value = p_b[value]
z_keys_from_b.update(keys_by_value(z_b, b_value))
z_keys = z_keys_from_a.intersection(z_keys_from_b)
for z_key in z_keys:
z_p[z_key] = value
return z_p
def get_unique_map_from_pushout(p, a_p, b_p, a_z, b_z):
"""Find a unique map to pushout."""
p_z = dict()
for value in p:
z_values = set()
a_values = set(keys_by_value(a_p, value))
for a_value in a_values:
if a_value in a_z.keys():
z_values.add(a_z[a_value])
b_values = set(keys_by_value(b_p, value))
for b_value in b_values:
if b_value in b_z.keys():
z_values.add(b_z[b_value])
if len(z_values) > 0:
if len(z_values) > 1:
raise ReGraphError("Cannot construct a unique map!")
p_z[value] = z_values.pop()
return p_z
def get_unique_map(a, b, c, d, a_b, b_d, c_d):
"""Get a map a->c that makes a square commute."""
a_c = dict()
for node in b.nodes():
a_keys = keys_by_value(a_b, node)
if len(a_keys) > 0:
# node stayed in the rule
if node in b_d.keys():
d_node = b_d[node]
c_keys = keys_by_value(
c_d,
d_node
)
if len(a_keys) != len(c_keys):
raise ReGraphError("Map is not unique!")
else:
for i, a_key in enumerate(a_keys):
a_c[a_key] = c_keys[i]
return a_c
def identity(a, b):
"""Return identity homomorphism from a to b."""
dic = {}
for n in a.nodes():
if n in b.nodes():
dic[n] = n
else:
raise ReGraphError(
"Cannot construct morphism by names: "
"node '%s' not found in the second graph!" % n
)
return dic
def is_monic(f):
"""Check if the homomorphism is monic."""
return len(set(f.keys())) ==\
len(set(f.values()))
def nary_pullback(b, cds, total=True):
"""Find a pullback with multiple conspans."""
# 1. find individual pullbacks
pullbacks = []
for c_name, (c, d, b_d, c_d) in cds.items():
if total:
pb = pullback(b, c, d, b_d, c_d)
else:
pb = partial_pullback(b, c, d, b_d, c_d)
pullbacks.append((
c_name, pb
))
# 2. find pullbacks of pullbacks
if len(pullbacks) > 1:
c_name1, (a1, a_b1, a_c1) = pullbacks[0]
a_c = dict([(c_name1, a_c1)])
for i in range(1, len(pullbacks)):
c_name2, (a2, a_b2, a_c2) = pullbacks[i]
if total:
a1, a1_old_a1, a1_a2 = pullback(
a1, a2, b, a_b1, a_b2)
else:
a1, a1_old_a1, a1_a2 = partial_pullback(
a1, a2, b, a_b1, a_b2)
a_b1 = compose(a1_old_a1, a_b1)
# update a_c
for c_name, old_a_c in a_c.items():
a_c[c_name] = compose(a1_old_a1, old_a_c)
a_c[c_name2] = compose(a1_a2, a_c2)
# at the end of pullback iterations assign right a and a_b
a_b = a_b1
a = a1
check_homomorphism(a, b, a_b, total=False)
for c_name, a_c_guy in a_c.items():
check_homomorphism(a, cds[c_name][0], a_c_guy, total=False)
return (a, a_b, a_c)
def partial_pullback(b, c, d, b_d, c_d):
"""Find partail pullback."""
check_homomorphism(b, d, b_d, total=False)
check_homomorphism(c, d, c_d, total=False)
bd_dom = subgraph(b, b_d.keys())
cd_dom = subgraph(c, c_d.keys())
bd_b = {n: n for n in bd_dom.nodes()}
cd_c = {n: n for n in cd_dom.nodes()}
(tmp, tmp_bddom, tmp_cddom) = pullback(bd_dom, cd_dom, d, b_d, c_d)
(b2, tmp_b2, b2_b) = pullback_complement(
tmp, bd_dom, b, tmp_bddom, bd_b)
(c2, tmp_c2, c2_c) = pullback_complement(
tmp, cd_dom, c, tmp_cddom, cd_c)
(new, b2_new, c2_new) = pushout(tmp, b2, c2, tmp_b2, tmp_c2)
hom1 = {v: b2_b[k] for (k, v) in b2_new.items()}
hom2 = {v: c2_c[k] for (k, v) in c2_new.items()}
return(new, hom1, hom2)
def pullback(b, c, d, b_d, c_d, inplace=False):
"""Find the pullback from b -> d <- c.
Given h1 : B -> D; h2 : C -> D returns A, rh1, rh2
with rh1 : A -> B; rh2 : A -> C and A the pullback.
"""
if inplace is True:
a = b
else:
a = type(b)()
# Check homomorphisms
check_homomorphism(b, d, b_d)
check_homomorphism(c, d, c_d)
hom1 = {}
hom2 = {}
f = b_d
g = c_d
for n1 in b.nodes():
for n2 in c.nodes():
if f[n1] == g[n2]:
new_attrs = merge_attributes(b.node[n1],
c.node[n2],
'intersection')
if n1 not in a.nodes():
add_node(a, n1, new_attrs)
hom1[n1] = n1
hom2[n1] = n2
else:
i = 1
new_name = str(n1) + str(i)
while new_name in a.nodes():
i += 1
new_name = str(n1) + str(i)
# if n2 not in a.nodes():
add_node(a, new_name, new_attrs)
hom1[new_name] = n1
hom2[new_name] = n2
for n1 in a.nodes():
for n2 in a.nodes():
if (hom1[n1], hom1[n2]) in b.edges() or \
((not a.is_directed()) and (hom1[n2], hom1[n1]) in b.edges()):
if (hom2[n1], hom2[n2]) in c.edges() or \
((not a.is_directed) and (hom2[n2], hom2[n1]) in c.edges()):
add_edge(a, n1, n2)
set_edge(
a,
n1,
n2,
merge_attributes(
get_edge(b, hom1[n1], hom1[n2]),
get_edge(c, hom2[n1], hom2[n2]),
'intersection'))
check_homomorphism(a, b, hom1)
check_homomorphism(a, c, hom2)
return (a, hom1, hom2)
def partial_pushout(a, b, c, a_b, a_c):
"""Find the partial pushout."""
check_homomorphism(a, b, a_b, total=False)
check_homomorphism(a, c, a_c, total=False)
if a.is_directed():
ab_dom = nx.DiGraph(a.subgraph(a_b.keys()))
ac_dom = nx.DiGraph(a.subgraph(a_c.keys()))
else:
ab_dom = nx.Graph(a.subgraph(a_b.keys()))
ac_dom = nx.Graph(a.subgraph(a_c.keys()))
ac_a = {n: n for n in ac_dom.nodes()}
ab_a = {n: n for n in ab_dom.nodes()}
(c2, a_c2, c_c2) = pushout(ac_dom, a, c, ac_a, a_c)
(b2, a_b2, b_b2) = pushout(ab_dom, a, b, ab_a, a_b)
(d, b2_d, c2_d) = pushout(a, b2, c2, a_b2, a_c2)
b_d = compose(b_b2, b2_d)
c_d = compose(c_c2, c2_d)
return(d, b_d, c_d)
def pushout(a, b, c, a_b, a_c, inplace=False):
"""Find the pushour of the span b <- a -> c."""
check_homomorphism(a, b, a_b)
check_homomorphism(a, c, a_c)
if inplace is True:
d = b
else:
d = copy.deepcopy(b)
b_d = id_of(b.nodes())
c_d = dict()
# Add/merge nodes
for c_n in c.nodes():
a_keys = keys_by_value(a_c, c_n)
# Add nodes
if len(a_keys) == 0:
add_node(d, c_n, c.node[c_n])
c_d[c_n] = c_n
# Keep nodes
elif len(a_keys) == 1:
c_d[a_c[a_keys[0]]] = a_b[a_keys[0]]
# Merge nodes
else:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.